1/* 2 * Copyright © 2010 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24#include "ir_reader.h" 25#include "glsl_parser_extras.h" 26#include "compiler/glsl_types.h" 27#include "s_expression.h" 28 29static const bool debug = false; 30 31namespace { 32 33class ir_reader { 34public: 35 ir_reader(_mesa_glsl_parse_state *); 36 37 void read(exec_list *instructions, const char *src, bool scan_for_protos); 38 39private: 40 void *mem_ctx; 41 _mesa_glsl_parse_state *state; 42 43 void ir_read_error(s_expression *, const char *fmt, ...); 44 45 const glsl_type *read_type(s_expression *); 46 47 void scan_for_prototypes(exec_list *, s_expression *); 48 ir_function *read_function(s_expression *, bool skip_body); 49 void read_function_sig(ir_function *, s_expression *, bool skip_body); 50 51 void read_instructions(exec_list *, s_expression *, ir_loop *); 52 ir_instruction *read_instruction(s_expression *, ir_loop *); 53 ir_variable *read_declaration(s_expression *); 54 ir_if *read_if(s_expression *, ir_loop *); 55 ir_loop *read_loop(s_expression *); 56 ir_call *read_call(s_expression *); 57 ir_return *read_return(s_expression *); 58 ir_rvalue *read_rvalue(s_expression *); 59 ir_assignment *read_assignment(s_expression *); 60 ir_expression *read_expression(s_expression *); 61 ir_swizzle *read_swizzle(s_expression *); 62 ir_constant *read_constant(s_expression *); 63 ir_texture *read_texture(s_expression *); 64 ir_emit_vertex *read_emit_vertex(s_expression *); 65 ir_end_primitive *read_end_primitive(s_expression *); 66 ir_barrier *read_barrier(s_expression *); 67 68 ir_dereference *read_dereference(s_expression *); 69 ir_dereference_variable *read_var_ref(s_expression *); 70}; 71 72} /* anonymous namespace */ 73 74ir_reader::ir_reader(_mesa_glsl_parse_state *state) : state(state) 75{ 76 this->mem_ctx = state; 77} 78 79void 80_mesa_glsl_read_ir(_mesa_glsl_parse_state *state, exec_list *instructions, 81 const char *src, bool scan_for_protos) 82{ 83 ir_reader r(state); 84 r.read(instructions, src, scan_for_protos); 85} 86 87void 88ir_reader::read(exec_list *instructions, const char *src, bool scan_for_protos) 89{ 90 void *sx_mem_ctx = ralloc_context(NULL); 91 s_expression *expr = s_expression::read_expression(sx_mem_ctx, src); 92 if (expr == NULL) { 93 ir_read_error(NULL, "couldn't parse S-Expression."); 94 return; 95 } 96 97 if (scan_for_protos) { 98 scan_for_prototypes(instructions, expr); 99 if (state->error) 100 return; 101 } 102 103 read_instructions(instructions, expr, NULL); 104 ralloc_free(sx_mem_ctx); 105 106 if (debug) 107 validate_ir_tree(instructions); 108} 109 110void 111ir_reader::ir_read_error(s_expression *expr, const char *fmt, ...) 112{ 113 va_list ap; 114 115 state->error = true; 116 117 if (state->current_function != NULL) 118 ralloc_asprintf_append(&state->info_log, "In function %s:\n", 119 state->current_function->function_name()); 120 ralloc_strcat(&state->info_log, "error: "); 121 122 va_start(ap, fmt); 123 ralloc_vasprintf_append(&state->info_log, fmt, ap); 124 va_end(ap); 125 ralloc_strcat(&state->info_log, "\n"); 126 127 if (expr != NULL) { 128 ralloc_strcat(&state->info_log, "...in this context:\n "); 129 expr->print(); 130 ralloc_strcat(&state->info_log, "\n\n"); 131 } 132} 133 134const glsl_type * 135ir_reader::read_type(s_expression *expr) 136{ 137 s_expression *s_base_type; 138 s_int *s_size; 139 140 s_pattern pat[] = { "array", s_base_type, s_size }; 141 if (MATCH(expr, pat)) { 142 const glsl_type *base_type = read_type(s_base_type); 143 if (base_type == NULL) { 144 ir_read_error(NULL, "when reading base type of array type"); 145 return NULL; 146 } 147 148 return glsl_type::get_array_instance(base_type, s_size->value()); 149 } 150 151 s_symbol *type_sym = SX_AS_SYMBOL(expr); 152 if (type_sym == NULL) { 153 ir_read_error(expr, "expected <type>"); 154 return NULL; 155 } 156 157 const glsl_type *type = state->symbols->get_type(type_sym->value()); 158 if (type == NULL) 159 ir_read_error(expr, "invalid type: %s", type_sym->value()); 160 161 return type; 162} 163 164 165void 166ir_reader::scan_for_prototypes(exec_list *instructions, s_expression *expr) 167{ 168 s_list *list = SX_AS_LIST(expr); 169 if (list == NULL) { 170 ir_read_error(expr, "Expected (<instruction> ...); found an atom."); 171 return; 172 } 173 174 foreach_in_list(s_list, sub, &list->subexpressions) { 175 if (!sub->is_list()) 176 continue; // not a (function ...); ignore it. 177 178 s_symbol *tag = SX_AS_SYMBOL(sub->subexpressions.get_head()); 179 if (tag == NULL || strcmp(tag->value(), "function") != 0) 180 continue; // not a (function ...); ignore it. 181 182 ir_function *f = read_function(sub, true); 183 if (f == NULL) 184 return; 185 instructions->push_tail(f); 186 } 187} 188 189ir_function * 190ir_reader::read_function(s_expression *expr, bool skip_body) 191{ 192 bool added = false; 193 s_symbol *name; 194 195 s_pattern pat[] = { "function", name }; 196 if (!PARTIAL_MATCH(expr, pat)) { 197 ir_read_error(expr, "Expected (function <name> (signature ...) ...)"); 198 return NULL; 199 } 200 201 ir_function *f = state->symbols->get_function(name->value()); 202 if (f == NULL) { 203 f = new(mem_ctx) ir_function(name->value()); 204 added = state->symbols->add_function(f); 205 assert(added); 206 } 207 208 /* Skip over "function" tag and function name (which are guaranteed to be 209 * present by the above PARTIAL_MATCH call). 210 */ 211 exec_node *node = ((s_list *) expr)->subexpressions.get_head_raw()->next->next; 212 for (/* nothing */; !node->is_tail_sentinel(); node = node->next) { 213 s_expression *s_sig = (s_expression *) node; 214 read_function_sig(f, s_sig, skip_body); 215 } 216 return added ? f : NULL; 217} 218 219static bool 220always_available(const _mesa_glsl_parse_state *) 221{ 222 return true; 223} 224 225void 226ir_reader::read_function_sig(ir_function *f, s_expression *expr, bool skip_body) 227{ 228 s_expression *type_expr; 229 s_list *paramlist; 230 s_list *body_list; 231 232 s_pattern pat[] = { "signature", type_expr, paramlist, body_list }; 233 if (!MATCH(expr, pat)) { 234 ir_read_error(expr, "Expected (signature <type> (parameters ...) " 235 "(<instruction> ...))"); 236 return; 237 } 238 239 const glsl_type *return_type = read_type(type_expr); 240 if (return_type == NULL) 241 return; 242 243 s_symbol *paramtag = SX_AS_SYMBOL(paramlist->subexpressions.get_head()); 244 if (paramtag == NULL || strcmp(paramtag->value(), "parameters") != 0) { 245 ir_read_error(paramlist, "Expected (parameters ...)"); 246 return; 247 } 248 249 // Read the parameters list into a temporary place. 250 exec_list hir_parameters; 251 state->symbols->push_scope(); 252 253 /* Skip over the "parameters" tag. */ 254 exec_node *node = paramlist->subexpressions.get_head_raw()->next; 255 for (/* nothing */; !node->is_tail_sentinel(); node = node->next) { 256 ir_variable *var = read_declaration((s_expression *) node); 257 if (var == NULL) 258 return; 259 260 hir_parameters.push_tail(var); 261 } 262 263 ir_function_signature *sig = 264 f->exact_matching_signature(state, &hir_parameters); 265 if (sig == NULL && skip_body) { 266 /* If scanning for prototypes, generate a new signature. */ 267 /* ir_reader doesn't know what languages support a given built-in, so 268 * just say that they're always available. For now, other mechanisms 269 * guarantee the right built-ins are available. 270 */ 271 sig = new(mem_ctx) ir_function_signature(return_type, always_available); 272 f->add_signature(sig); 273 } else if (sig != NULL) { 274 const char *badvar = sig->qualifiers_match(&hir_parameters); 275 if (badvar != NULL) { 276 ir_read_error(expr, "function `%s' parameter `%s' qualifiers " 277 "don't match prototype", f->name, badvar); 278 return; 279 } 280 281 if (sig->return_type != return_type) { 282 ir_read_error(expr, "function `%s' return type doesn't " 283 "match prototype", f->name); 284 return; 285 } 286 } else { 287 /* No prototype for this body exists - skip it. */ 288 state->symbols->pop_scope(); 289 return; 290 } 291 assert(sig != NULL); 292 293 sig->replace_parameters(&hir_parameters); 294 295 if (!skip_body && !body_list->subexpressions.is_empty()) { 296 if (sig->is_defined) { 297 ir_read_error(expr, "function %s redefined", f->name); 298 return; 299 } 300 state->current_function = sig; 301 read_instructions(&sig->body, body_list, NULL); 302 state->current_function = NULL; 303 sig->is_defined = true; 304 } 305 306 state->symbols->pop_scope(); 307} 308 309void 310ir_reader::read_instructions(exec_list *instructions, s_expression *expr, 311 ir_loop *loop_ctx) 312{ 313 // Read in a list of instructions 314 s_list *list = SX_AS_LIST(expr); 315 if (list == NULL) { 316 ir_read_error(expr, "Expected (<instruction> ...); found an atom."); 317 return; 318 } 319 320 foreach_in_list(s_expression, sub, &list->subexpressions) { 321 ir_instruction *ir = read_instruction(sub, loop_ctx); 322 if (ir != NULL) { 323 /* Global variable declarations should be moved to the top, before 324 * any functions that might use them. Functions are added to the 325 * instruction stream when scanning for prototypes, so without this 326 * hack, they always appear before variable declarations. 327 */ 328 if (state->current_function == NULL && ir->as_variable() != NULL) 329 instructions->push_head(ir); 330 else 331 instructions->push_tail(ir); 332 } 333 } 334} 335 336 337ir_instruction * 338ir_reader::read_instruction(s_expression *expr, ir_loop *loop_ctx) 339{ 340 s_symbol *symbol = SX_AS_SYMBOL(expr); 341 if (symbol != NULL) { 342 if (strcmp(symbol->value(), "break") == 0 && loop_ctx != NULL) 343 return new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break); 344 if (strcmp(symbol->value(), "continue") == 0 && loop_ctx != NULL) 345 return new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_continue); 346 } 347 348 s_list *list = SX_AS_LIST(expr); 349 if (list == NULL || list->subexpressions.is_empty()) { 350 ir_read_error(expr, "Invalid instruction.\n"); 351 return NULL; 352 } 353 354 s_symbol *tag = SX_AS_SYMBOL(list->subexpressions.get_head()); 355 if (tag == NULL) { 356 ir_read_error(expr, "expected instruction tag"); 357 return NULL; 358 } 359 360 ir_instruction *inst = NULL; 361 if (strcmp(tag->value(), "declare") == 0) { 362 inst = read_declaration(list); 363 } else if (strcmp(tag->value(), "assign") == 0) { 364 inst = read_assignment(list); 365 } else if (strcmp(tag->value(), "if") == 0) { 366 inst = read_if(list, loop_ctx); 367 } else if (strcmp(tag->value(), "loop") == 0) { 368 inst = read_loop(list); 369 } else if (strcmp(tag->value(), "call") == 0) { 370 inst = read_call(list); 371 } else if (strcmp(tag->value(), "return") == 0) { 372 inst = read_return(list); 373 } else if (strcmp(tag->value(), "function") == 0) { 374 inst = read_function(list, false); 375 } else if (strcmp(tag->value(), "emit-vertex") == 0) { 376 inst = read_emit_vertex(list); 377 } else if (strcmp(tag->value(), "end-primitive") == 0) { 378 inst = read_end_primitive(list); 379 } else if (strcmp(tag->value(), "barrier") == 0) { 380 inst = read_barrier(list); 381 } else { 382 inst = read_rvalue(list); 383 if (inst == NULL) 384 ir_read_error(NULL, "when reading instruction"); 385 } 386 return inst; 387} 388 389ir_variable * 390ir_reader::read_declaration(s_expression *expr) 391{ 392 s_list *s_quals; 393 s_expression *s_type; 394 s_symbol *s_name; 395 396 s_pattern pat[] = { "declare", s_quals, s_type, s_name }; 397 if (!MATCH(expr, pat)) { 398 ir_read_error(expr, "expected (declare (<qualifiers>) <type> <name>)"); 399 return NULL; 400 } 401 402 const glsl_type *type = read_type(s_type); 403 if (type == NULL) 404 return NULL; 405 406 ir_variable *var = new(mem_ctx) ir_variable(type, s_name->value(), 407 ir_var_auto); 408 409 foreach_in_list(s_symbol, qualifier, &s_quals->subexpressions) { 410 if (!qualifier->is_symbol()) { 411 ir_read_error(expr, "qualifier list must contain only symbols"); 412 return NULL; 413 } 414 415 // FINISHME: Check for duplicate/conflicting qualifiers. 416 if (strcmp(qualifier->value(), "centroid") == 0) { 417 var->data.centroid = 1; 418 } else if (strcmp(qualifier->value(), "sample") == 0) { 419 var->data.sample = 1; 420 } else if (strcmp(qualifier->value(), "patch") == 0) { 421 var->data.patch = 1; 422 } else if (strcmp(qualifier->value(), "explicit_invariant") == 0) { 423 var->data.explicit_invariant = true; 424 } else if (strcmp(qualifier->value(), "invariant") == 0) { 425 var->data.invariant = true; 426 } else if (strcmp(qualifier->value(), "uniform") == 0) { 427 var->data.mode = ir_var_uniform; 428 } else if (strcmp(qualifier->value(), "shader_storage") == 0) { 429 var->data.mode = ir_var_shader_storage; 430 } else if (strcmp(qualifier->value(), "auto") == 0) { 431 var->data.mode = ir_var_auto; 432 } else if (strcmp(qualifier->value(), "in") == 0) { 433 var->data.mode = ir_var_function_in; 434 } else if (strcmp(qualifier->value(), "shader_in") == 0) { 435 var->data.mode = ir_var_shader_in; 436 } else if (strcmp(qualifier->value(), "const_in") == 0) { 437 var->data.mode = ir_var_const_in; 438 } else if (strcmp(qualifier->value(), "out") == 0) { 439 var->data.mode = ir_var_function_out; 440 } else if (strcmp(qualifier->value(), "shader_out") == 0) { 441 var->data.mode = ir_var_shader_out; 442 } else if (strcmp(qualifier->value(), "inout") == 0) { 443 var->data.mode = ir_var_function_inout; 444 } else if (strcmp(qualifier->value(), "temporary") == 0) { 445 var->data.mode = ir_var_temporary; 446 } else if (strcmp(qualifier->value(), "stream1") == 0) { 447 var->data.stream = 1; 448 } else if (strcmp(qualifier->value(), "stream2") == 0) { 449 var->data.stream = 2; 450 } else if (strcmp(qualifier->value(), "stream3") == 0) { 451 var->data.stream = 3; 452 } else if (strcmp(qualifier->value(), "smooth") == 0) { 453 var->data.interpolation = INTERP_MODE_SMOOTH; 454 } else if (strcmp(qualifier->value(), "flat") == 0) { 455 var->data.interpolation = INTERP_MODE_FLAT; 456 } else if (strcmp(qualifier->value(), "noperspective") == 0) { 457 var->data.interpolation = INTERP_MODE_NOPERSPECTIVE; 458 } else { 459 ir_read_error(expr, "unknown qualifier: %s", qualifier->value()); 460 return NULL; 461 } 462 } 463 464 // Add the variable to the symbol table 465 state->symbols->add_variable(var); 466 467 return var; 468} 469 470 471ir_if * 472ir_reader::read_if(s_expression *expr, ir_loop *loop_ctx) 473{ 474 s_expression *s_cond; 475 s_expression *s_then; 476 s_expression *s_else; 477 478 s_pattern pat[] = { "if", s_cond, s_then, s_else }; 479 if (!MATCH(expr, pat)) { 480 ir_read_error(expr, "expected (if <condition> (<then>...) (<else>...))"); 481 return NULL; 482 } 483 484 ir_rvalue *condition = read_rvalue(s_cond); 485 if (condition == NULL) { 486 ir_read_error(NULL, "when reading condition of (if ...)"); 487 return NULL; 488 } 489 490 ir_if *iff = new(mem_ctx) ir_if(condition); 491 492 read_instructions(&iff->then_instructions, s_then, loop_ctx); 493 read_instructions(&iff->else_instructions, s_else, loop_ctx); 494 if (state->error) { 495 delete iff; 496 iff = NULL; 497 } 498 return iff; 499} 500 501 502ir_loop * 503ir_reader::read_loop(s_expression *expr) 504{ 505 s_expression *s_body; 506 507 s_pattern loop_pat[] = { "loop", s_body }; 508 if (!MATCH(expr, loop_pat)) { 509 ir_read_error(expr, "expected (loop <body>)"); 510 return NULL; 511 } 512 513 ir_loop *loop = new(mem_ctx) ir_loop; 514 515 read_instructions(&loop->body_instructions, s_body, loop); 516 if (state->error) { 517 delete loop; 518 loop = NULL; 519 } 520 return loop; 521} 522 523 524ir_return * 525ir_reader::read_return(s_expression *expr) 526{ 527 s_expression *s_retval; 528 529 s_pattern return_value_pat[] = { "return", s_retval}; 530 s_pattern return_void_pat[] = { "return" }; 531 if (MATCH(expr, return_value_pat)) { 532 ir_rvalue *retval = read_rvalue(s_retval); 533 if (retval == NULL) { 534 ir_read_error(NULL, "when reading return value"); 535 return NULL; 536 } 537 return new(mem_ctx) ir_return(retval); 538 } else if (MATCH(expr, return_void_pat)) { 539 return new(mem_ctx) ir_return; 540 } else { 541 ir_read_error(expr, "expected (return <rvalue>) or (return)"); 542 return NULL; 543 } 544} 545 546 547ir_rvalue * 548ir_reader::read_rvalue(s_expression *expr) 549{ 550 s_list *list = SX_AS_LIST(expr); 551 if (list == NULL || list->subexpressions.is_empty()) 552 return NULL; 553 554 s_symbol *tag = SX_AS_SYMBOL(list->subexpressions.get_head()); 555 if (tag == NULL) { 556 ir_read_error(expr, "expected rvalue tag"); 557 return NULL; 558 } 559 560 ir_rvalue *rvalue = read_dereference(list); 561 if (rvalue != NULL || state->error) 562 return rvalue; 563 else if (strcmp(tag->value(), "swiz") == 0) { 564 rvalue = read_swizzle(list); 565 } else if (strcmp(tag->value(), "expression") == 0) { 566 rvalue = read_expression(list); 567 } else if (strcmp(tag->value(), "constant") == 0) { 568 rvalue = read_constant(list); 569 } else { 570 rvalue = read_texture(list); 571 if (rvalue == NULL && !state->error) 572 ir_read_error(expr, "unrecognized rvalue tag: %s", tag->value()); 573 } 574 575 return rvalue; 576} 577 578ir_assignment * 579ir_reader::read_assignment(s_expression *expr) 580{ 581 s_expression *cond_expr = NULL; 582 s_expression *lhs_expr, *rhs_expr; 583 s_list *mask_list; 584 585 s_pattern pat4[] = { "assign", mask_list, lhs_expr, rhs_expr }; 586 s_pattern pat5[] = { "assign", cond_expr, mask_list, lhs_expr, rhs_expr }; 587 if (!MATCH(expr, pat4) && !MATCH(expr, pat5)) { 588 ir_read_error(expr, "expected (assign (<write mask>) <lhs> <rhs>)"); 589 return NULL; 590 } 591 592 if (cond_expr != NULL) { 593 ir_rvalue *condition = read_rvalue(cond_expr); 594 if (condition == NULL) 595 ir_read_error(NULL, "when reading condition of assignment"); 596 else 597 ir_read_error(expr, "conditional assignemnts are deprecated"); 598 599 return NULL; 600 } 601 602 unsigned mask = 0; 603 604 s_symbol *mask_symbol; 605 s_pattern mask_pat[] = { mask_symbol }; 606 if (MATCH(mask_list, mask_pat)) { 607 const char *mask_str = mask_symbol->value(); 608 unsigned mask_length = strlen(mask_str); 609 if (mask_length > 4) { 610 ir_read_error(expr, "invalid write mask: %s", mask_str); 611 return NULL; 612 } 613 614 const unsigned idx_map[] = { 3, 0, 1, 2 }; /* w=bit 3, x=0, y=1, z=2 */ 615 616 for (unsigned i = 0; i < mask_length; i++) { 617 if (mask_str[i] < 'w' || mask_str[i] > 'z') { 618 ir_read_error(expr, "write mask contains invalid character: %c", 619 mask_str[i]); 620 return NULL; 621 } 622 mask |= 1 << idx_map[mask_str[i] - 'w']; 623 } 624 } else if (!mask_list->subexpressions.is_empty()) { 625 ir_read_error(mask_list, "expected () or (<write mask>)"); 626 return NULL; 627 } 628 629 ir_dereference *lhs = read_dereference(lhs_expr); 630 if (lhs == NULL) { 631 ir_read_error(NULL, "when reading left-hand side of assignment"); 632 return NULL; 633 } 634 635 ir_rvalue *rhs = read_rvalue(rhs_expr); 636 if (rhs == NULL) { 637 ir_read_error(NULL, "when reading right-hand side of assignment"); 638 return NULL; 639 } 640 641 if (mask == 0 && (lhs->type->is_vector() || lhs->type->is_scalar())) { 642 ir_read_error(expr, "non-zero write mask required."); 643 return NULL; 644 } 645 646 return new(mem_ctx) ir_assignment(lhs, rhs, mask); 647} 648 649ir_call * 650ir_reader::read_call(s_expression *expr) 651{ 652 s_symbol *name; 653 s_list *params; 654 s_list *s_return = NULL; 655 656 ir_dereference_variable *return_deref = NULL; 657 658 s_pattern void_pat[] = { "call", name, params }; 659 s_pattern non_void_pat[] = { "call", name, s_return, params }; 660 if (MATCH(expr, non_void_pat)) { 661 return_deref = read_var_ref(s_return); 662 if (return_deref == NULL) { 663 ir_read_error(s_return, "when reading a call's return storage"); 664 return NULL; 665 } 666 } else if (!MATCH(expr, void_pat)) { 667 ir_read_error(expr, "expected (call <name> [<deref>] (<param> ...))"); 668 return NULL; 669 } 670 671 exec_list parameters; 672 673 foreach_in_list(s_expression, e, ¶ms->subexpressions) { 674 ir_rvalue *param = read_rvalue(e); 675 if (param == NULL) { 676 ir_read_error(e, "when reading parameter to function call"); 677 return NULL; 678 } 679 parameters.push_tail(param); 680 } 681 682 ir_function *f = state->symbols->get_function(name->value()); 683 if (f == NULL) { 684 ir_read_error(expr, "found call to undefined function %s", 685 name->value()); 686 return NULL; 687 } 688 689 ir_function_signature *callee = 690 f->matching_signature(state, ¶meters, true); 691 if (callee == NULL) { 692 ir_read_error(expr, "couldn't find matching signature for function " 693 "%s", name->value()); 694 return NULL; 695 } 696 697 if (callee->return_type == glsl_type::void_type && return_deref) { 698 ir_read_error(expr, "call has return value storage but void type"); 699 return NULL; 700 } else if (callee->return_type != glsl_type::void_type && !return_deref) { 701 ir_read_error(expr, "call has non-void type but no return value storage"); 702 return NULL; 703 } 704 705 return new(mem_ctx) ir_call(callee, return_deref, ¶meters); 706} 707 708ir_expression * 709ir_reader::read_expression(s_expression *expr) 710{ 711 s_expression *s_type; 712 s_symbol *s_op; 713 s_expression *s_arg[4] = {NULL}; 714 715 s_pattern pat[] = { "expression", s_type, s_op, s_arg[0] }; 716 if (!PARTIAL_MATCH(expr, pat)) { 717 ir_read_error(expr, "expected (expression <type> <operator> " 718 "<operand> [<operand>] [<operand>] [<operand>])"); 719 return NULL; 720 } 721 s_arg[1] = (s_expression *) s_arg[0]->next; // may be tail sentinel 722 s_arg[2] = (s_expression *) s_arg[1]->next; // may be tail sentinel or NULL 723 if (s_arg[2]) 724 s_arg[3] = (s_expression *) s_arg[2]->next; // may be tail sentinel or NULL 725 726 const glsl_type *type = read_type(s_type); 727 if (type == NULL) 728 return NULL; 729 730 /* Read the operator */ 731 ir_expression_operation op = ir_expression::get_operator(s_op->value()); 732 if (op == (ir_expression_operation) -1) { 733 ir_read_error(expr, "invalid operator: %s", s_op->value()); 734 return NULL; 735 } 736 737 /* Skip "expression" <type> <operation> by subtracting 3. */ 738 int num_operands = (int) ((s_list *) expr)->subexpressions.length() - 3; 739 740 int expected_operands = ir_expression::get_num_operands(op); 741 if (num_operands != expected_operands) { 742 ir_read_error(expr, "found %d expression operands, expected %d", 743 num_operands, expected_operands); 744 return NULL; 745 } 746 747 ir_rvalue *arg[4] = {NULL}; 748 for (int i = 0; i < num_operands; i++) { 749 arg[i] = read_rvalue(s_arg[i]); 750 if (arg[i] == NULL) { 751 ir_read_error(NULL, "when reading operand #%d of %s", i, s_op->value()); 752 return NULL; 753 } 754 } 755 756 return new(mem_ctx) ir_expression(op, type, arg[0], arg[1], arg[2], arg[3]); 757} 758 759ir_swizzle * 760ir_reader::read_swizzle(s_expression *expr) 761{ 762 s_symbol *swiz; 763 s_expression *sub; 764 765 s_pattern pat[] = { "swiz", swiz, sub }; 766 if (!MATCH(expr, pat)) { 767 ir_read_error(expr, "expected (swiz <swizzle> <rvalue>)"); 768 return NULL; 769 } 770 771 if (strlen(swiz->value()) > 4) { 772 ir_read_error(expr, "expected a valid swizzle; found %s", swiz->value()); 773 return NULL; 774 } 775 776 ir_rvalue *rvalue = read_rvalue(sub); 777 if (rvalue == NULL) 778 return NULL; 779 780 ir_swizzle *ir = ir_swizzle::create(rvalue, swiz->value(), 781 rvalue->type->vector_elements); 782 if (ir == NULL) 783 ir_read_error(expr, "invalid swizzle"); 784 785 return ir; 786} 787 788ir_constant * 789ir_reader::read_constant(s_expression *expr) 790{ 791 s_expression *type_expr; 792 s_list *values; 793 794 s_pattern pat[] = { "constant", type_expr, values }; 795 if (!MATCH(expr, pat)) { 796 ir_read_error(expr, "expected (constant <type> (...))"); 797 return NULL; 798 } 799 800 const glsl_type *type = read_type(type_expr); 801 if (type == NULL) 802 return NULL; 803 804 if (values == NULL) { 805 ir_read_error(expr, "expected (constant <type> (...))"); 806 return NULL; 807 } 808 809 if (type->is_array()) { 810 unsigned elements_supplied = 0; 811 exec_list elements; 812 foreach_in_list(s_expression, elt, &values->subexpressions) { 813 ir_constant *ir_elt = read_constant(elt); 814 if (ir_elt == NULL) 815 return NULL; 816 elements.push_tail(ir_elt); 817 elements_supplied++; 818 } 819 820 if (elements_supplied != type->length) { 821 ir_read_error(values, "expected exactly %u array elements, " 822 "given %u", type->length, elements_supplied); 823 return NULL; 824 } 825 return new(mem_ctx) ir_constant(type, &elements); 826 } 827 828 ir_constant_data data = { { 0 } }; 829 830 // Read in list of values (at most 16). 831 unsigned k = 0; 832 foreach_in_list(s_expression, expr, &values->subexpressions) { 833 if (k >= 16) { 834 ir_read_error(values, "expected at most 16 numbers"); 835 return NULL; 836 } 837 838 if (type->is_float()) { 839 s_number *value = SX_AS_NUMBER(expr); 840 if (value == NULL) { 841 ir_read_error(values, "expected numbers"); 842 return NULL; 843 } 844 data.f[k] = value->fvalue(); 845 } else { 846 s_int *value = SX_AS_INT(expr); 847 if (value == NULL) { 848 ir_read_error(values, "expected integers"); 849 return NULL; 850 } 851 852 switch (type->base_type) { 853 case GLSL_TYPE_UINT: { 854 data.u[k] = value->value(); 855 break; 856 } 857 case GLSL_TYPE_INT: { 858 data.i[k] = value->value(); 859 break; 860 } 861 case GLSL_TYPE_BOOL: { 862 data.b[k] = value->value(); 863 break; 864 } 865 default: 866 ir_read_error(values, "unsupported constant type"); 867 return NULL; 868 } 869 } 870 ++k; 871 } 872 if (k != type->components()) { 873 ir_read_error(values, "expected %u constant values, found %u", 874 type->components(), k); 875 return NULL; 876 } 877 878 return new(mem_ctx) ir_constant(type, &data); 879} 880 881ir_dereference_variable * 882ir_reader::read_var_ref(s_expression *expr) 883{ 884 s_symbol *s_var; 885 s_pattern var_pat[] = { "var_ref", s_var }; 886 887 if (MATCH(expr, var_pat)) { 888 ir_variable *var = state->symbols->get_variable(s_var->value()); 889 if (var == NULL) { 890 ir_read_error(expr, "undeclared variable: %s", s_var->value()); 891 return NULL; 892 } 893 return new(mem_ctx) ir_dereference_variable(var); 894 } 895 return NULL; 896} 897 898ir_dereference * 899ir_reader::read_dereference(s_expression *expr) 900{ 901 s_expression *s_subject; 902 s_expression *s_index; 903 s_symbol *s_field; 904 905 s_pattern array_pat[] = { "array_ref", s_subject, s_index }; 906 s_pattern record_pat[] = { "record_ref", s_subject, s_field }; 907 908 ir_dereference_variable *var_ref = read_var_ref(expr); 909 if (var_ref != NULL) { 910 return var_ref; 911 } else if (MATCH(expr, array_pat)) { 912 ir_rvalue *subject = read_rvalue(s_subject); 913 if (subject == NULL) { 914 ir_read_error(NULL, "when reading the subject of an array_ref"); 915 return NULL; 916 } 917 918 ir_rvalue *idx = read_rvalue(s_index); 919 if (idx == NULL) { 920 ir_read_error(NULL, "when reading the index of an array_ref"); 921 return NULL; 922 } 923 return new(mem_ctx) ir_dereference_array(subject, idx); 924 } else if (MATCH(expr, record_pat)) { 925 ir_rvalue *subject = read_rvalue(s_subject); 926 if (subject == NULL) { 927 ir_read_error(NULL, "when reading the subject of a record_ref"); 928 return NULL; 929 } 930 return new(mem_ctx) ir_dereference_record(subject, s_field->value()); 931 } 932 return NULL; 933} 934 935ir_texture * 936ir_reader::read_texture(s_expression *expr) 937{ 938 s_symbol *tag = NULL; 939 s_expression *s_sparse = NULL; 940 s_expression *s_type = NULL; 941 s_expression *s_sampler = NULL; 942 s_expression *s_coord = NULL; 943 s_expression *s_offset = NULL; 944 s_expression *s_proj = NULL; 945 s_list *s_shadow = NULL; 946 s_list *s_clamp = NULL; 947 s_expression *s_lod = NULL; 948 s_expression *s_sample_index = NULL; 949 s_expression *s_component = NULL; 950 951 ir_texture_opcode op = ir_tex; /* silence warning */ 952 953 s_pattern tex_pattern[] = 954 { "tex", s_type, s_sampler, s_coord, s_sparse, s_offset, s_proj, s_shadow, s_clamp }; 955 s_pattern txb_pattern[] = 956 { "txb", s_type, s_sampler, s_coord, s_sparse, s_offset, s_proj, s_shadow, s_clamp, s_lod }; 957 s_pattern txd_pattern[] = 958 { "txd", s_type, s_sampler, s_coord, s_sparse, s_offset, s_proj, s_shadow, s_clamp, s_lod }; 959 s_pattern lod_pattern[] = 960 { "lod", s_type, s_sampler, s_coord }; 961 s_pattern txf_pattern[] = 962 { "txf", s_type, s_sampler, s_coord, s_sparse, s_offset, s_lod }; 963 s_pattern txf_ms_pattern[] = 964 { "txf_ms", s_type, s_sampler, s_coord, s_sparse, s_sample_index }; 965 s_pattern txs_pattern[] = 966 { "txs", s_type, s_sampler, s_lod }; 967 s_pattern tg4_pattern[] = 968 { "tg4", s_type, s_sampler, s_coord, s_sparse, s_offset, s_component }; 969 s_pattern query_levels_pattern[] = 970 { "query_levels", s_type, s_sampler }; 971 s_pattern texture_samples_pattern[] = 972 { "samples", s_type, s_sampler }; 973 s_pattern other_pattern[] = 974 { tag, s_type, s_sampler, s_coord, s_sparse, s_offset, s_proj, s_shadow, s_lod }; 975 976 if (MATCH(expr, lod_pattern)) { 977 op = ir_lod; 978 } else if (MATCH(expr, tex_pattern)) { 979 op = ir_tex; 980 } else if (MATCH(expr, txb_pattern)) { 981 op = ir_txb; 982 } else if (MATCH(expr, txd_pattern)) { 983 op = ir_txd; 984 } else if (MATCH(expr, txf_pattern)) { 985 op = ir_txf; 986 } else if (MATCH(expr, txf_ms_pattern)) { 987 op = ir_txf_ms; 988 } else if (MATCH(expr, txs_pattern)) { 989 op = ir_txs; 990 } else if (MATCH(expr, tg4_pattern)) { 991 op = ir_tg4; 992 } else if (MATCH(expr, query_levels_pattern)) { 993 op = ir_query_levels; 994 } else if (MATCH(expr, texture_samples_pattern)) { 995 op = ir_texture_samples; 996 } else if (MATCH(expr, other_pattern)) { 997 op = ir_texture::get_opcode(tag->value()); 998 if (op == (ir_texture_opcode) -1) 999 return NULL; 1000 } else { 1001 ir_read_error(NULL, "unexpected texture pattern %s", tag->value()); 1002 return NULL; 1003 } 1004 1005 bool is_sparse = false; 1006 if (s_sparse) { 1007 s_int *sparse = SX_AS_INT(s_sparse); 1008 if (sparse == NULL) { 1009 ir_read_error(NULL, "when reading sparse"); 1010 return NULL; 1011 } 1012 is_sparse = sparse->value(); 1013 } 1014 1015 ir_texture *tex = new(mem_ctx) ir_texture(op, is_sparse); 1016 1017 // Read return type 1018 const glsl_type *type = read_type(s_type); 1019 if (type == NULL) { 1020 ir_read_error(NULL, "when reading type in (%s ...)", 1021 tex->opcode_string()); 1022 return NULL; 1023 } 1024 1025 // Read sampler (must be a deref) 1026 ir_dereference *sampler = read_dereference(s_sampler); 1027 if (sampler == NULL) { 1028 ir_read_error(NULL, "when reading sampler in (%s ...)", 1029 tex->opcode_string()); 1030 return NULL; 1031 } 1032 1033 if (is_sparse) { 1034 const glsl_type *texel = type->field_type("texel"); 1035 if (texel == glsl_type::error_type) { 1036 ir_read_error(NULL, "invalid type for sparse texture"); 1037 return NULL; 1038 } 1039 type = texel; 1040 } 1041 tex->set_sampler(sampler, type); 1042 1043 if (op != ir_txs) { 1044 // Read coordinate (any rvalue) 1045 tex->coordinate = read_rvalue(s_coord); 1046 if (tex->coordinate == NULL) { 1047 ir_read_error(NULL, "when reading coordinate in (%s ...)", 1048 tex->opcode_string()); 1049 return NULL; 1050 } 1051 1052 if (op != ir_txf_ms && op != ir_lod) { 1053 // Read texel offset - either 0 or an rvalue. 1054 s_int *si_offset = SX_AS_INT(s_offset); 1055 if (si_offset == NULL || si_offset->value() != 0) { 1056 tex->offset = read_rvalue(s_offset); 1057 if (tex->offset == NULL) { 1058 ir_read_error(s_offset, "expected 0 or an expression"); 1059 return NULL; 1060 } 1061 } 1062 } 1063 } 1064 1065 if (op != ir_txf && op != ir_txf_ms && 1066 op != ir_txs && op != ir_lod && op != ir_tg4 && 1067 op != ir_query_levels && op != ir_texture_samples) { 1068 s_int *proj_as_int = SX_AS_INT(s_proj); 1069 if (proj_as_int && proj_as_int->value() == 1) { 1070 tex->projector = NULL; 1071 } else { 1072 tex->projector = read_rvalue(s_proj); 1073 if (tex->projector == NULL) { 1074 ir_read_error(NULL, "when reading projective divide in (%s ..)", 1075 tex->opcode_string()); 1076 return NULL; 1077 } 1078 } 1079 1080 if (s_shadow->subexpressions.is_empty()) { 1081 tex->shadow_comparator = NULL; 1082 } else { 1083 tex->shadow_comparator = read_rvalue(s_shadow); 1084 if (tex->shadow_comparator == NULL) { 1085 ir_read_error(NULL, "when reading shadow comparator in (%s ..)", 1086 tex->opcode_string()); 1087 return NULL; 1088 } 1089 } 1090 } 1091 1092 if (op == ir_tex || op == ir_txb || op == ir_txd) { 1093 if (s_clamp->subexpressions.is_empty()) { 1094 tex->clamp = NULL; 1095 } else { 1096 tex->clamp = read_rvalue(s_clamp); 1097 if (tex->clamp == NULL) { 1098 ir_read_error(NULL, "when reading clamp in (%s ..)", 1099 tex->opcode_string()); 1100 return NULL; 1101 } 1102 } 1103 } 1104 1105 switch (op) { 1106 case ir_txb: 1107 tex->lod_info.bias = read_rvalue(s_lod); 1108 if (tex->lod_info.bias == NULL) { 1109 ir_read_error(NULL, "when reading LOD bias in (txb ...)"); 1110 return NULL; 1111 } 1112 break; 1113 case ir_txl: 1114 case ir_txf: 1115 case ir_txs: 1116 tex->lod_info.lod = read_rvalue(s_lod); 1117 if (tex->lod_info.lod == NULL) { 1118 ir_read_error(NULL, "when reading LOD in (%s ...)", 1119 tex->opcode_string()); 1120 return NULL; 1121 } 1122 break; 1123 case ir_txf_ms: 1124 tex->lod_info.sample_index = read_rvalue(s_sample_index); 1125 if (tex->lod_info.sample_index == NULL) { 1126 ir_read_error(NULL, "when reading sample_index in (txf_ms ...)"); 1127 return NULL; 1128 } 1129 break; 1130 case ir_txd: { 1131 s_expression *s_dx, *s_dy; 1132 s_pattern dxdy_pat[] = { s_dx, s_dy }; 1133 if (!MATCH(s_lod, dxdy_pat)) { 1134 ir_read_error(s_lod, "expected (dPdx dPdy) in (txd ...)"); 1135 return NULL; 1136 } 1137 tex->lod_info.grad.dPdx = read_rvalue(s_dx); 1138 if (tex->lod_info.grad.dPdx == NULL) { 1139 ir_read_error(NULL, "when reading dPdx in (txd ...)"); 1140 return NULL; 1141 } 1142 tex->lod_info.grad.dPdy = read_rvalue(s_dy); 1143 if (tex->lod_info.grad.dPdy == NULL) { 1144 ir_read_error(NULL, "when reading dPdy in (txd ...)"); 1145 return NULL; 1146 } 1147 break; 1148 } 1149 case ir_tg4: 1150 tex->lod_info.component = read_rvalue(s_component); 1151 if (tex->lod_info.component == NULL) { 1152 ir_read_error(NULL, "when reading component in (tg4 ...)"); 1153 return NULL; 1154 } 1155 break; 1156 default: 1157 // tex and lod don't have any extra parameters. 1158 break; 1159 }; 1160 return tex; 1161} 1162 1163ir_emit_vertex * 1164ir_reader::read_emit_vertex(s_expression *expr) 1165{ 1166 s_expression *s_stream = NULL; 1167 1168 s_pattern pat[] = { "emit-vertex", s_stream }; 1169 1170 if (MATCH(expr, pat)) { 1171 ir_rvalue *stream = read_dereference(s_stream); 1172 if (stream == NULL) { 1173 ir_read_error(NULL, "when reading stream info in emit-vertex"); 1174 return NULL; 1175 } 1176 return new(mem_ctx) ir_emit_vertex(stream); 1177 } 1178 ir_read_error(NULL, "when reading emit-vertex"); 1179 return NULL; 1180} 1181 1182ir_end_primitive * 1183ir_reader::read_end_primitive(s_expression *expr) 1184{ 1185 s_expression *s_stream = NULL; 1186 1187 s_pattern pat[] = { "end-primitive", s_stream }; 1188 1189 if (MATCH(expr, pat)) { 1190 ir_rvalue *stream = read_dereference(s_stream); 1191 if (stream == NULL) { 1192 ir_read_error(NULL, "when reading stream info in end-primitive"); 1193 return NULL; 1194 } 1195 return new(mem_ctx) ir_end_primitive(stream); 1196 } 1197 ir_read_error(NULL, "when reading end-primitive"); 1198 return NULL; 1199} 1200 1201ir_barrier * 1202ir_reader::read_barrier(s_expression *expr) 1203{ 1204 s_pattern pat[] = { "barrier" }; 1205 1206 if (MATCH(expr, pat)) { 1207 return new(mem_ctx) ir_barrier(); 1208 } 1209 ir_read_error(NULL, "when reading barrier"); 1210 return NULL; 1211} 1212