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 29 static const bool debug = false; 30 31 namespace { 32 33 class ir_reader { 34 public: 35 ir_reader(_mesa_glsl_parse_state *); 36 37 void read(exec_list *instructions, const char *src, bool scan_for_protos); 38 39 private: 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 74 ir_reader::ir_reader(_mesa_glsl_parse_state *state) : state(state) 75 { 76 this->mem_ctx = state; 77 } 78 79 void 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 87 void 88 ir_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 110 void 111 ir_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 134 const glsl_type * 135 ir_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 165 void 166 ir_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 189 ir_function * 190 ir_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 219 static bool 220 always_available(const _mesa_glsl_parse_state *) 221 { 222 return true; 223 } 224 225 void 226 ir_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 309 void 310 ir_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 337 ir_instruction * 338 ir_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 389 ir_variable * 390 ir_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(), "invariant") == 0) { 423 var->data.invariant = 1; 424 } else if (strcmp(qualifier->value(), "uniform") == 0) { 425 var->data.mode = ir_var_uniform; 426 } else if (strcmp(qualifier->value(), "shader_storage") == 0) { 427 var->data.mode = ir_var_shader_storage; 428 } else if (strcmp(qualifier->value(), "auto") == 0) { 429 var->data.mode = ir_var_auto; 430 } else if (strcmp(qualifier->value(), "in") == 0) { 431 var->data.mode = ir_var_function_in; 432 } else if (strcmp(qualifier->value(), "shader_in") == 0) { 433 var->data.mode = ir_var_shader_in; 434 } else if (strcmp(qualifier->value(), "const_in") == 0) { 435 var->data.mode = ir_var_const_in; 436 } else if (strcmp(qualifier->value(), "out") == 0) { 437 var->data.mode = ir_var_function_out; 438 } else if (strcmp(qualifier->value(), "shader_out") == 0) { 439 var->data.mode = ir_var_shader_out; 440 } else if (strcmp(qualifier->value(), "inout") == 0) { 441 var->data.mode = ir_var_function_inout; 442 } else if (strcmp(qualifier->value(), "temporary") == 0) { 443 var->data.mode = ir_var_temporary; 444 } else if (strcmp(qualifier->value(), "stream1") == 0) { 445 var->data.stream = 1; 446 } else if (strcmp(qualifier->value(), "stream2") == 0) { 447 var->data.stream = 2; 448 } else if (strcmp(qualifier->value(), "stream3") == 0) { 449 var->data.stream = 3; 450 } else if (strcmp(qualifier->value(), "smooth") == 0) { 451 var->data.interpolation = INTERP_MODE_SMOOTH; 452 } else if (strcmp(qualifier->value(), "flat") == 0) { 453 var->data.interpolation = INTERP_MODE_FLAT; 454 } else if (strcmp(qualifier->value(), "noperspective") == 0) { 455 var->data.interpolation = INTERP_MODE_NOPERSPECTIVE; 456 } else { 457 ir_read_error(expr, "unknown qualifier: %s", qualifier->value()); 458 return NULL; 459 } 460 } 461 462 // Add the variable to the symbol table 463 state->symbols->add_variable(var); 464 465 return var; 466 } 467 468 469 ir_if * 470 ir_reader::read_if(s_expression *expr, ir_loop *loop_ctx) 471 { 472 s_expression *s_cond; 473 s_expression *s_then; 474 s_expression *s_else; 475 476 s_pattern pat[] = { "if", s_cond, s_then, s_else }; 477 if (!MATCH(expr, pat)) { 478 ir_read_error(expr, "expected (if <condition> (<then>...) (<else>...))"); 479 return NULL; 480 } 481 482 ir_rvalue *condition = read_rvalue(s_cond); 483 if (condition == NULL) { 484 ir_read_error(NULL, "when reading condition of (if ...)"); 485 return NULL; 486 } 487 488 ir_if *iff = new(mem_ctx) ir_if(condition); 489 490 read_instructions(&iff->then_instructions, s_then, loop_ctx); 491 read_instructions(&iff->else_instructions, s_else, loop_ctx); 492 if (state->error) { 493 delete iff; 494 iff = NULL; 495 } 496 return iff; 497 } 498 499 500 ir_loop * 501 ir_reader::read_loop(s_expression *expr) 502 { 503 s_expression *s_body; 504 505 s_pattern loop_pat[] = { "loop", s_body }; 506 if (!MATCH(expr, loop_pat)) { 507 ir_read_error(expr, "expected (loop <body>)"); 508 return NULL; 509 } 510 511 ir_loop *loop = new(mem_ctx) ir_loop; 512 513 read_instructions(&loop->body_instructions, s_body, loop); 514 if (state->error) { 515 delete loop; 516 loop = NULL; 517 } 518 return loop; 519 } 520 521 522 ir_return * 523 ir_reader::read_return(s_expression *expr) 524 { 525 s_expression *s_retval; 526 527 s_pattern return_value_pat[] = { "return", s_retval}; 528 s_pattern return_void_pat[] = { "return" }; 529 if (MATCH(expr, return_value_pat)) { 530 ir_rvalue *retval = read_rvalue(s_retval); 531 if (retval == NULL) { 532 ir_read_error(NULL, "when reading return value"); 533 return NULL; 534 } 535 return new(mem_ctx) ir_return(retval); 536 } else if (MATCH(expr, return_void_pat)) { 537 return new(mem_ctx) ir_return; 538 } else { 539 ir_read_error(expr, "expected (return <rvalue>) or (return)"); 540 return NULL; 541 } 542 } 543 544 545 ir_rvalue * 546 ir_reader::read_rvalue(s_expression *expr) 547 { 548 s_list *list = SX_AS_LIST(expr); 549 if (list == NULL || list->subexpressions.is_empty()) 550 return NULL; 551 552 s_symbol *tag = SX_AS_SYMBOL(list->subexpressions.get_head()); 553 if (tag == NULL) { 554 ir_read_error(expr, "expected rvalue tag"); 555 return NULL; 556 } 557 558 ir_rvalue *rvalue = read_dereference(list); 559 if (rvalue != NULL || state->error) 560 return rvalue; 561 else if (strcmp(tag->value(), "swiz") == 0) { 562 rvalue = read_swizzle(list); 563 } else if (strcmp(tag->value(), "expression") == 0) { 564 rvalue = read_expression(list); 565 } else if (strcmp(tag->value(), "constant") == 0) { 566 rvalue = read_constant(list); 567 } else { 568 rvalue = read_texture(list); 569 if (rvalue == NULL && !state->error) 570 ir_read_error(expr, "unrecognized rvalue tag: %s", tag->value()); 571 } 572 573 return rvalue; 574 } 575 576 ir_assignment * 577 ir_reader::read_assignment(s_expression *expr) 578 { 579 s_expression *cond_expr = NULL; 580 s_expression *lhs_expr, *rhs_expr; 581 s_list *mask_list; 582 583 s_pattern pat4[] = { "assign", mask_list, lhs_expr, rhs_expr }; 584 s_pattern pat5[] = { "assign", cond_expr, mask_list, lhs_expr, rhs_expr }; 585 if (!MATCH(expr, pat4) && !MATCH(expr, pat5)) { 586 ir_read_error(expr, "expected (assign [<condition>] (<write mask>) " 587 "<lhs> <rhs>)"); 588 return NULL; 589 } 590 591 ir_rvalue *condition = NULL; 592 if (cond_expr != NULL) { 593 condition = read_rvalue(cond_expr); 594 if (condition == NULL) { 595 ir_read_error(NULL, "when reading condition of assignment"); 596 return NULL; 597 } 598 } 599 600 unsigned mask = 0; 601 602 s_symbol *mask_symbol; 603 s_pattern mask_pat[] = { mask_symbol }; 604 if (MATCH(mask_list, mask_pat)) { 605 const char *mask_str = mask_symbol->value(); 606 unsigned mask_length = strlen(mask_str); 607 if (mask_length > 4) { 608 ir_read_error(expr, "invalid write mask: %s", mask_str); 609 return NULL; 610 } 611 612 const unsigned idx_map[] = { 3, 0, 1, 2 }; /* w=bit 3, x=0, y=1, z=2 */ 613 614 for (unsigned i = 0; i < mask_length; i++) { 615 if (mask_str[i] < 'w' || mask_str[i] > 'z') { 616 ir_read_error(expr, "write mask contains invalid character: %c", 617 mask_str[i]); 618 return NULL; 619 } 620 mask |= 1 << idx_map[mask_str[i] - 'w']; 621 } 622 } else if (!mask_list->subexpressions.is_empty()) { 623 ir_read_error(mask_list, "expected () or (<write mask>)"); 624 return NULL; 625 } 626 627 ir_dereference *lhs = read_dereference(lhs_expr); 628 if (lhs == NULL) { 629 ir_read_error(NULL, "when reading left-hand side of assignment"); 630 return NULL; 631 } 632 633 ir_rvalue *rhs = read_rvalue(rhs_expr); 634 if (rhs == NULL) { 635 ir_read_error(NULL, "when reading right-hand side of assignment"); 636 return NULL; 637 } 638 639 if (mask == 0 && (lhs->type->is_vector() || lhs->type->is_scalar())) { 640 ir_read_error(expr, "non-zero write mask required."); 641 return NULL; 642 } 643 644 return new(mem_ctx) ir_assignment(lhs, rhs, condition, mask); 645 } 646 647 ir_call * 648 ir_reader::read_call(s_expression *expr) 649 { 650 s_symbol *name; 651 s_list *params; 652 s_list *s_return = NULL; 653 654 ir_dereference_variable *return_deref = NULL; 655 656 s_pattern void_pat[] = { "call", name, params }; 657 s_pattern non_void_pat[] = { "call", name, s_return, params }; 658 if (MATCH(expr, non_void_pat)) { 659 return_deref = read_var_ref(s_return); 660 if (return_deref == NULL) { 661 ir_read_error(s_return, "when reading a call's return storage"); 662 return NULL; 663 } 664 } else if (!MATCH(expr, void_pat)) { 665 ir_read_error(expr, "expected (call <name> [<deref>] (<param> ...))"); 666 return NULL; 667 } 668 669 exec_list parameters; 670 671 foreach_in_list(s_expression, e, ¶ms->subexpressions) { 672 ir_rvalue *param = read_rvalue(e); 673 if (param == NULL) { 674 ir_read_error(e, "when reading parameter to function call"); 675 return NULL; 676 } 677 parameters.push_tail(param); 678 } 679 680 ir_function *f = state->symbols->get_function(name->value()); 681 if (f == NULL) { 682 ir_read_error(expr, "found call to undefined function %s", 683 name->value()); 684 return NULL; 685 } 686 687 ir_function_signature *callee = 688 f->matching_signature(state, ¶meters, true); 689 if (callee == NULL) { 690 ir_read_error(expr, "couldn't find matching signature for function " 691 "%s", name->value()); 692 return NULL; 693 } 694 695 if (callee->return_type == glsl_type::void_type && return_deref) { 696 ir_read_error(expr, "call has return value storage but void type"); 697 return NULL; 698 } else if (callee->return_type != glsl_type::void_type && !return_deref) { 699 ir_read_error(expr, "call has non-void type but no return value storage"); 700 return NULL; 701 } 702 703 return new(mem_ctx) ir_call(callee, return_deref, ¶meters); 704 } 705 706 ir_expression * 707 ir_reader::read_expression(s_expression *expr) 708 { 709 s_expression *s_type; 710 s_symbol *s_op; 711 s_expression *s_arg[4] = {NULL}; 712 713 s_pattern pat[] = { "expression", s_type, s_op, s_arg[0] }; 714 if (!PARTIAL_MATCH(expr, pat)) { 715 ir_read_error(expr, "expected (expression <type> <operator> " 716 "<operand> [<operand>] [<operand>] [<operand>])"); 717 return NULL; 718 } 719 s_arg[1] = (s_expression *) s_arg[0]->next; // may be tail sentinel 720 s_arg[2] = (s_expression *) s_arg[1]->next; // may be tail sentinel or NULL 721 if (s_arg[2]) 722 s_arg[3] = (s_expression *) s_arg[2]->next; // may be tail sentinel or NULL 723 724 const glsl_type *type = read_type(s_type); 725 if (type == NULL) 726 return NULL; 727 728 /* Read the operator */ 729 ir_expression_operation op = ir_expression::get_operator(s_op->value()); 730 if (op == (ir_expression_operation) -1) { 731 ir_read_error(expr, "invalid operator: %s", s_op->value()); 732 return NULL; 733 } 734 735 /* Skip "expression" <type> <operation> by subtracting 3. */ 736 int num_operands = (int) ((s_list *) expr)->subexpressions.length() - 3; 737 738 int expected_operands = ir_expression::get_num_operands(op); 739 if (num_operands != expected_operands) { 740 ir_read_error(expr, "found %d expression operands, expected %d", 741 num_operands, expected_operands); 742 return NULL; 743 } 744 745 ir_rvalue *arg[4] = {NULL}; 746 for (int i = 0; i < num_operands; i++) { 747 arg[i] = read_rvalue(s_arg[i]); 748 if (arg[i] == NULL) { 749 ir_read_error(NULL, "when reading operand #%d of %s", i, s_op->value()); 750 return NULL; 751 } 752 } 753 754 return new(mem_ctx) ir_expression(op, type, arg[0], arg[1], arg[2], arg[3]); 755 } 756 757 ir_swizzle * 758 ir_reader::read_swizzle(s_expression *expr) 759 { 760 s_symbol *swiz; 761 s_expression *sub; 762 763 s_pattern pat[] = { "swiz", swiz, sub }; 764 if (!MATCH(expr, pat)) { 765 ir_read_error(expr, "expected (swiz <swizzle> <rvalue>)"); 766 return NULL; 767 } 768 769 if (strlen(swiz->value()) > 4) { 770 ir_read_error(expr, "expected a valid swizzle; found %s", swiz->value()); 771 return NULL; 772 } 773 774 ir_rvalue *rvalue = read_rvalue(sub); 775 if (rvalue == NULL) 776 return NULL; 777 778 ir_swizzle *ir = ir_swizzle::create(rvalue, swiz->value(), 779 rvalue->type->vector_elements); 780 if (ir == NULL) 781 ir_read_error(expr, "invalid swizzle"); 782 783 return ir; 784 } 785 786 ir_constant * 787 ir_reader::read_constant(s_expression *expr) 788 { 789 s_expression *type_expr; 790 s_list *values; 791 792 s_pattern pat[] = { "constant", type_expr, values }; 793 if (!MATCH(expr, pat)) { 794 ir_read_error(expr, "expected (constant <type> (...))"); 795 return NULL; 796 } 797 798 const glsl_type *type = read_type(type_expr); 799 if (type == NULL) 800 return NULL; 801 802 if (values == NULL) { 803 ir_read_error(expr, "expected (constant <type> (...))"); 804 return NULL; 805 } 806 807 if (type->is_array()) { 808 unsigned elements_supplied = 0; 809 exec_list elements; 810 foreach_in_list(s_expression, elt, &values->subexpressions) { 811 ir_constant *ir_elt = read_constant(elt); 812 if (ir_elt == NULL) 813 return NULL; 814 elements.push_tail(ir_elt); 815 elements_supplied++; 816 } 817 818 if (elements_supplied != type->length) { 819 ir_read_error(values, "expected exactly %u array elements, " 820 "given %u", type->length, elements_supplied); 821 return NULL; 822 } 823 return new(mem_ctx) ir_constant(type, &elements); 824 } 825 826 ir_constant_data data = { { 0 } }; 827 828 // Read in list of values (at most 16). 829 unsigned k = 0; 830 foreach_in_list(s_expression, expr, &values->subexpressions) { 831 if (k >= 16) { 832 ir_read_error(values, "expected at most 16 numbers"); 833 return NULL; 834 } 835 836 if (type->base_type == GLSL_TYPE_FLOAT) { 837 s_number *value = SX_AS_NUMBER(expr); 838 if (value == NULL) { 839 ir_read_error(values, "expected numbers"); 840 return NULL; 841 } 842 data.f[k] = value->fvalue(); 843 } else { 844 s_int *value = SX_AS_INT(expr); 845 if (value == NULL) { 846 ir_read_error(values, "expected integers"); 847 return NULL; 848 } 849 850 switch (type->base_type) { 851 case GLSL_TYPE_UINT: { 852 data.u[k] = value->value(); 853 break; 854 } 855 case GLSL_TYPE_INT: { 856 data.i[k] = value->value(); 857 break; 858 } 859 case GLSL_TYPE_BOOL: { 860 data.b[k] = value->value(); 861 break; 862 } 863 default: 864 ir_read_error(values, "unsupported constant type"); 865 return NULL; 866 } 867 } 868 ++k; 869 } 870 if (k != type->components()) { 871 ir_read_error(values, "expected %u constant values, found %u", 872 type->components(), k); 873 return NULL; 874 } 875 876 return new(mem_ctx) ir_constant(type, &data); 877 } 878 879 ir_dereference_variable * 880 ir_reader::read_var_ref(s_expression *expr) 881 { 882 s_symbol *s_var; 883 s_pattern var_pat[] = { "var_ref", s_var }; 884 885 if (MATCH(expr, var_pat)) { 886 ir_variable *var = state->symbols->get_variable(s_var->value()); 887 if (var == NULL) { 888 ir_read_error(expr, "undeclared variable: %s", s_var->value()); 889 return NULL; 890 } 891 return new(mem_ctx) ir_dereference_variable(var); 892 } 893 return NULL; 894 } 895 896 ir_dereference * 897 ir_reader::read_dereference(s_expression *expr) 898 { 899 s_expression *s_subject; 900 s_expression *s_index; 901 s_symbol *s_field; 902 903 s_pattern array_pat[] = { "array_ref", s_subject, s_index }; 904 s_pattern record_pat[] = { "record_ref", s_subject, s_field }; 905 906 ir_dereference_variable *var_ref = read_var_ref(expr); 907 if (var_ref != NULL) { 908 return var_ref; 909 } else if (MATCH(expr, array_pat)) { 910 ir_rvalue *subject = read_rvalue(s_subject); 911 if (subject == NULL) { 912 ir_read_error(NULL, "when reading the subject of an array_ref"); 913 return NULL; 914 } 915 916 ir_rvalue *idx = read_rvalue(s_index); 917 if (idx == NULL) { 918 ir_read_error(NULL, "when reading the index of an array_ref"); 919 return NULL; 920 } 921 return new(mem_ctx) ir_dereference_array(subject, idx); 922 } else if (MATCH(expr, record_pat)) { 923 ir_rvalue *subject = read_rvalue(s_subject); 924 if (subject == NULL) { 925 ir_read_error(NULL, "when reading the subject of a record_ref"); 926 return NULL; 927 } 928 return new(mem_ctx) ir_dereference_record(subject, s_field->value()); 929 } 930 return NULL; 931 } 932 933 ir_texture * 934 ir_reader::read_texture(s_expression *expr) 935 { 936 s_symbol *tag = NULL; 937 s_expression *s_type = NULL; 938 s_expression *s_sampler = NULL; 939 s_expression *s_coord = NULL; 940 s_expression *s_offset = NULL; 941 s_expression *s_proj = NULL; 942 s_list *s_shadow = NULL; 943 s_expression *s_lod = NULL; 944 s_expression *s_sample_index = NULL; 945 s_expression *s_component = NULL; 946 947 ir_texture_opcode op = ir_tex; /* silence warning */ 948 949 s_pattern tex_pattern[] = 950 { "tex", s_type, s_sampler, s_coord, s_offset, s_proj, s_shadow }; 951 s_pattern lod_pattern[] = 952 { "lod", s_type, s_sampler, s_coord }; 953 s_pattern txf_pattern[] = 954 { "txf", s_type, s_sampler, s_coord, s_offset, s_lod }; 955 s_pattern txf_ms_pattern[] = 956 { "txf_ms", s_type, s_sampler, s_coord, s_sample_index }; 957 s_pattern txs_pattern[] = 958 { "txs", s_type, s_sampler, s_lod }; 959 s_pattern tg4_pattern[] = 960 { "tg4", s_type, s_sampler, s_coord, s_offset, s_component }; 961 s_pattern query_levels_pattern[] = 962 { "query_levels", s_type, s_sampler }; 963 s_pattern texture_samples_pattern[] = 964 { "samples", s_type, s_sampler }; 965 s_pattern other_pattern[] = 966 { tag, s_type, s_sampler, s_coord, s_offset, s_proj, s_shadow, s_lod }; 967 968 if (MATCH(expr, lod_pattern)) { 969 op = ir_lod; 970 } else if (MATCH(expr, tex_pattern)) { 971 op = ir_tex; 972 } else if (MATCH(expr, txf_pattern)) { 973 op = ir_txf; 974 } else if (MATCH(expr, txf_ms_pattern)) { 975 op = ir_txf_ms; 976 } else if (MATCH(expr, txs_pattern)) { 977 op = ir_txs; 978 } else if (MATCH(expr, tg4_pattern)) { 979 op = ir_tg4; 980 } else if (MATCH(expr, query_levels_pattern)) { 981 op = ir_query_levels; 982 } else if (MATCH(expr, texture_samples_pattern)) { 983 op = ir_texture_samples; 984 } else if (MATCH(expr, other_pattern)) { 985 op = ir_texture::get_opcode(tag->value()); 986 if (op == (ir_texture_opcode) -1) 987 return NULL; 988 } else { 989 ir_read_error(NULL, "unexpected texture pattern %s", tag->value()); 990 return NULL; 991 } 992 993 ir_texture *tex = new(mem_ctx) ir_texture(op); 994 995 // Read return type 996 const glsl_type *type = read_type(s_type); 997 if (type == NULL) { 998 ir_read_error(NULL, "when reading type in (%s ...)", 999 tex->opcode_string()); 1000 return NULL; 1001 } 1002 1003 // Read sampler (must be a deref) 1004 ir_dereference *sampler = read_dereference(s_sampler); 1005 if (sampler == NULL) { 1006 ir_read_error(NULL, "when reading sampler in (%s ...)", 1007 tex->opcode_string()); 1008 return NULL; 1009 } 1010 tex->set_sampler(sampler, type); 1011 1012 if (op != ir_txs) { 1013 // Read coordinate (any rvalue) 1014 tex->coordinate = read_rvalue(s_coord); 1015 if (tex->coordinate == NULL) { 1016 ir_read_error(NULL, "when reading coordinate in (%s ...)", 1017 tex->opcode_string()); 1018 return NULL; 1019 } 1020 1021 if (op != ir_txf_ms && op != ir_lod) { 1022 // Read texel offset - either 0 or an rvalue. 1023 s_int *si_offset = SX_AS_INT(s_offset); 1024 if (si_offset == NULL || si_offset->value() != 0) { 1025 tex->offset = read_rvalue(s_offset); 1026 if (tex->offset == NULL) { 1027 ir_read_error(s_offset, "expected 0 or an expression"); 1028 return NULL; 1029 } 1030 } 1031 } 1032 } 1033 1034 if (op != ir_txf && op != ir_txf_ms && 1035 op != ir_txs && op != ir_lod && op != ir_tg4 && 1036 op != ir_query_levels && op != ir_texture_samples) { 1037 s_int *proj_as_int = SX_AS_INT(s_proj); 1038 if (proj_as_int && proj_as_int->value() == 1) { 1039 tex->projector = NULL; 1040 } else { 1041 tex->projector = read_rvalue(s_proj); 1042 if (tex->projector == NULL) { 1043 ir_read_error(NULL, "when reading projective divide in (%s ..)", 1044 tex->opcode_string()); 1045 return NULL; 1046 } 1047 } 1048 1049 if (s_shadow->subexpressions.is_empty()) { 1050 tex->shadow_comparator = NULL; 1051 } else { 1052 tex->shadow_comparator = read_rvalue(s_shadow); 1053 if (tex->shadow_comparator == NULL) { 1054 ir_read_error(NULL, "when reading shadow comparator in (%s ..)", 1055 tex->opcode_string()); 1056 return NULL; 1057 } 1058 } 1059 } 1060 1061 switch (op) { 1062 case ir_txb: 1063 tex->lod_info.bias = read_rvalue(s_lod); 1064 if (tex->lod_info.bias == NULL) { 1065 ir_read_error(NULL, "when reading LOD bias in (txb ...)"); 1066 return NULL; 1067 } 1068 break; 1069 case ir_txl: 1070 case ir_txf: 1071 case ir_txs: 1072 tex->lod_info.lod = read_rvalue(s_lod); 1073 if (tex->lod_info.lod == NULL) { 1074 ir_read_error(NULL, "when reading LOD in (%s ...)", 1075 tex->opcode_string()); 1076 return NULL; 1077 } 1078 break; 1079 case ir_txf_ms: 1080 tex->lod_info.sample_index = read_rvalue(s_sample_index); 1081 if (tex->lod_info.sample_index == NULL) { 1082 ir_read_error(NULL, "when reading sample_index in (txf_ms ...)"); 1083 return NULL; 1084 } 1085 break; 1086 case ir_txd: { 1087 s_expression *s_dx, *s_dy; 1088 s_pattern dxdy_pat[] = { s_dx, s_dy }; 1089 if (!MATCH(s_lod, dxdy_pat)) { 1090 ir_read_error(s_lod, "expected (dPdx dPdy) in (txd ...)"); 1091 return NULL; 1092 } 1093 tex->lod_info.grad.dPdx = read_rvalue(s_dx); 1094 if (tex->lod_info.grad.dPdx == NULL) { 1095 ir_read_error(NULL, "when reading dPdx in (txd ...)"); 1096 return NULL; 1097 } 1098 tex->lod_info.grad.dPdy = read_rvalue(s_dy); 1099 if (tex->lod_info.grad.dPdy == NULL) { 1100 ir_read_error(NULL, "when reading dPdy in (txd ...)"); 1101 return NULL; 1102 } 1103 break; 1104 } 1105 case ir_tg4: 1106 tex->lod_info.component = read_rvalue(s_component); 1107 if (tex->lod_info.component == NULL) { 1108 ir_read_error(NULL, "when reading component in (tg4 ...)"); 1109 return NULL; 1110 } 1111 break; 1112 default: 1113 // tex and lod don't have any extra parameters. 1114 break; 1115 }; 1116 return tex; 1117 } 1118 1119 ir_emit_vertex * 1120 ir_reader::read_emit_vertex(s_expression *expr) 1121 { 1122 s_expression *s_stream = NULL; 1123 1124 s_pattern pat[] = { "emit-vertex", s_stream }; 1125 1126 if (MATCH(expr, pat)) { 1127 ir_rvalue *stream = read_dereference(s_stream); 1128 if (stream == NULL) { 1129 ir_read_error(NULL, "when reading stream info in emit-vertex"); 1130 return NULL; 1131 } 1132 return new(mem_ctx) ir_emit_vertex(stream); 1133 } 1134 ir_read_error(NULL, "when reading emit-vertex"); 1135 return NULL; 1136 } 1137 1138 ir_end_primitive * 1139 ir_reader::read_end_primitive(s_expression *expr) 1140 { 1141 s_expression *s_stream = NULL; 1142 1143 s_pattern pat[] = { "end-primitive", s_stream }; 1144 1145 if (MATCH(expr, pat)) { 1146 ir_rvalue *stream = read_dereference(s_stream); 1147 if (stream == NULL) { 1148 ir_read_error(NULL, "when reading stream info in end-primitive"); 1149 return NULL; 1150 } 1151 return new(mem_ctx) ir_end_primitive(stream); 1152 } 1153 ir_read_error(NULL, "when reading end-primitive"); 1154 return NULL; 1155 } 1156 1157 ir_barrier * 1158 ir_reader::read_barrier(s_expression *expr) 1159 { 1160 s_pattern pat[] = { "barrier" }; 1161 1162 if (MATCH(expr, pat)) { 1163 return new(mem_ctx) ir_barrier(); 1164 } 1165 ir_read_error(NULL, "when reading barrier"); 1166 return NULL; 1167 } 1168