1/* 2 * Copyright © 2008, 2009 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#include <getopt.h> 24 25/** @file standalone.cpp 26 * 27 * Standalone compiler helper lib. Used by standalone glsl_compiler and 28 * also available to drivers to implement their own standalone compiler 29 * with driver backend. 30 */ 31 32#include "ast.h" 33#include "glsl_parser_extras.h" 34#include "ir_optimization.h" 35#include "program.h" 36#include "loop_analysis.h" 37#include "standalone_scaffolding.h" 38#include "standalone.h" 39#include "util/string_to_uint_map.h" 40#include "util/set.h" 41#include "linker.h" 42#include "glsl_parser_extras.h" 43#include "ir_builder_print_visitor.h" 44#include "opt_add_neg_to_sub.h" 45 46class dead_variable_visitor : public ir_hierarchical_visitor { 47public: 48 dead_variable_visitor() 49 { 50 variables = _mesa_set_create(NULL, 51 _mesa_hash_pointer, 52 _mesa_key_pointer_equal); 53 } 54 55 virtual ~dead_variable_visitor() 56 { 57 _mesa_set_destroy(variables, NULL); 58 } 59 60 virtual ir_visitor_status visit(ir_variable *ir) 61 { 62 /* If the variable is auto or temp, add it to the set of variables that 63 * are candidates for removal. 64 */ 65 if (ir->data.mode != ir_var_auto && ir->data.mode != ir_var_temporary) 66 return visit_continue; 67 68 _mesa_set_add(variables, ir); 69 70 return visit_continue; 71 } 72 73 virtual ir_visitor_status visit(ir_dereference_variable *ir) 74 { 75 struct set_entry *entry = _mesa_set_search(variables, ir->var); 76 77 /* If a variable is dereferenced at all, remove it from the set of 78 * variables that are candidates for removal. 79 */ 80 if (entry != NULL) 81 _mesa_set_remove(variables, entry); 82 83 return visit_continue; 84 } 85 86 void remove_dead_variables() 87 { 88 struct set_entry *entry; 89 90 set_foreach(variables, entry) { 91 ir_variable *ir = (ir_variable *) entry->key; 92 93 assert(ir->ir_type == ir_type_variable); 94 ir->remove(); 95 } 96 } 97 98private: 99 set *variables; 100}; 101 102void 103init_gl_program(struct gl_program *prog, GLenum target, bool is_arb_asm) 104{ 105 mtx_init(&prog->Mutex, mtx_plain); 106 107 prog->RefCount = 1; 108 prog->Format = GL_PROGRAM_FORMAT_ASCII_ARB; 109 prog->is_arb_asm = is_arb_asm; 110} 111 112struct gl_program * 113new_program(struct gl_context *ctx, GLenum target, GLuint id, bool is_arb_asm) 114{ 115 switch (target) { 116 case GL_VERTEX_PROGRAM_ARB: /* == GL_VERTEX_PROGRAM_NV */ 117 case GL_GEOMETRY_PROGRAM_NV: 118 case GL_TESS_CONTROL_PROGRAM_NV: 119 case GL_TESS_EVALUATION_PROGRAM_NV: 120 case GL_FRAGMENT_PROGRAM_ARB: 121 case GL_COMPUTE_PROGRAM_NV: { 122 struct gl_program *prog = rzalloc(NULL, struct gl_program); 123 init_gl_program(prog, target, is_arb_asm); 124 return prog; 125 } 126 default: 127 printf("bad target in new_program\n"); 128 return NULL; 129 } 130} 131 132static const struct standalone_options *options; 133 134static void 135initialize_context(struct gl_context *ctx, gl_api api) 136{ 137 initialize_context_to_defaults(ctx, api); 138 139 /* The standalone compiler needs to claim support for almost 140 * everything in order to compile the built-in functions. 141 */ 142 ctx->Const.GLSLVersion = options->glsl_version; 143 ctx->Extensions.ARB_ES3_compatibility = true; 144 ctx->Const.MaxComputeWorkGroupCount[0] = 65535; 145 ctx->Const.MaxComputeWorkGroupCount[1] = 65535; 146 ctx->Const.MaxComputeWorkGroupCount[2] = 65535; 147 ctx->Const.MaxComputeWorkGroupSize[0] = 1024; 148 ctx->Const.MaxComputeWorkGroupSize[1] = 1024; 149 ctx->Const.MaxComputeWorkGroupSize[2] = 64; 150 ctx->Const.MaxComputeWorkGroupInvocations = 1024; 151 ctx->Const.MaxComputeSharedMemorySize = 32768; 152 ctx->Const.MaxComputeVariableGroupSize[0] = 512; 153 ctx->Const.MaxComputeVariableGroupSize[1] = 512; 154 ctx->Const.MaxComputeVariableGroupSize[2] = 64; 155 ctx->Const.MaxComputeVariableGroupInvocations = 512; 156 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits = 16; 157 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxUniformComponents = 1024; 158 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxCombinedUniformComponents = 1024; 159 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxInputComponents = 0; /* not used */ 160 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxOutputComponents = 0; /* not used */ 161 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxAtomicBuffers = 8; 162 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxAtomicCounters = 8; 163 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxImageUniforms = 8; 164 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxUniformBlocks = 12; 165 166 switch (ctx->Const.GLSLVersion) { 167 case 100: 168 ctx->Const.MaxClipPlanes = 0; 169 ctx->Const.MaxCombinedTextureImageUnits = 8; 170 ctx->Const.MaxDrawBuffers = 2; 171 ctx->Const.MinProgramTexelOffset = 0; 172 ctx->Const.MaxProgramTexelOffset = 0; 173 ctx->Const.MaxLights = 0; 174 ctx->Const.MaxTextureCoordUnits = 0; 175 ctx->Const.MaxTextureUnits = 8; 176 177 ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 8; 178 ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 0; 179 ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 128 * 4; 180 ctx->Const.Program[MESA_SHADER_VERTEX].MaxCombinedUniformComponents = 128 * 4; 181 ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */ 182 ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 32; 183 184 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 185 ctx->Const.MaxCombinedTextureImageUnits; 186 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 16 * 4; 187 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxCombinedUniformComponents = 16 * 4; 188 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 189 ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents; 190 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */ 191 192 ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4; 193 break; 194 case 110: 195 case 120: 196 ctx->Const.MaxClipPlanes = 6; 197 ctx->Const.MaxCombinedTextureImageUnits = 2; 198 ctx->Const.MaxDrawBuffers = 1; 199 ctx->Const.MinProgramTexelOffset = 0; 200 ctx->Const.MaxProgramTexelOffset = 0; 201 ctx->Const.MaxLights = 8; 202 ctx->Const.MaxTextureCoordUnits = 2; 203 ctx->Const.MaxTextureUnits = 2; 204 205 ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16; 206 ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 0; 207 ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 512; 208 ctx->Const.Program[MESA_SHADER_VERTEX].MaxCombinedUniformComponents = 512; 209 ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */ 210 ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 32; 211 212 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 213 ctx->Const.MaxCombinedTextureImageUnits; 214 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 64; 215 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxCombinedUniformComponents = 64; 216 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 217 ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents; 218 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */ 219 220 ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4; 221 break; 222 case 130: 223 case 140: 224 ctx->Const.MaxClipPlanes = 8; 225 ctx->Const.MaxCombinedTextureImageUnits = 16; 226 ctx->Const.MaxDrawBuffers = 8; 227 ctx->Const.MinProgramTexelOffset = -8; 228 ctx->Const.MaxProgramTexelOffset = 7; 229 ctx->Const.MaxLights = 8; 230 ctx->Const.MaxTextureCoordUnits = 8; 231 ctx->Const.MaxTextureUnits = 2; 232 233 ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16; 234 ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 16; 235 ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 1024; 236 ctx->Const.Program[MESA_SHADER_VERTEX].MaxCombinedUniformComponents = 1024; 237 ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */ 238 ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 64; 239 240 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 16; 241 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 1024; 242 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxCombinedUniformComponents = 1024; 243 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 244 ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents; 245 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */ 246 247 ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4; 248 break; 249 case 150: 250 case 330: 251 case 400: 252 case 410: 253 case 420: 254 case 430: 255 case 440: 256 case 450: 257 ctx->Const.MaxClipPlanes = 8; 258 ctx->Const.MaxDrawBuffers = 8; 259 ctx->Const.MinProgramTexelOffset = -8; 260 ctx->Const.MaxProgramTexelOffset = 7; 261 ctx->Const.MaxLights = 8; 262 ctx->Const.MaxTextureCoordUnits = 8; 263 ctx->Const.MaxTextureUnits = 2; 264 265 ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16; 266 ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 16; 267 ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 1024; 268 ctx->Const.Program[MESA_SHADER_VERTEX].MaxCombinedUniformComponents = 1024; 269 ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */ 270 ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 64; 271 272 ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = 16; 273 ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxUniformComponents = 1024; 274 ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxCombinedUniformComponents = 1024; 275 ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxInputComponents = 276 ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents; 277 ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxOutputComponents = 128; 278 279 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 16; 280 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 1024; 281 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxCombinedUniformComponents = 1024; 282 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 283 ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxOutputComponents; 284 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */ 285 286 ctx->Const.MaxCombinedTextureImageUnits = 287 ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits 288 + ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits 289 + ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits; 290 291 ctx->Const.MaxGeometryOutputVertices = 256; 292 ctx->Const.MaxGeometryTotalOutputComponents = 1024; 293 294 ctx->Const.MaxVarying = 60 / 4; 295 break; 296 case 300: 297 ctx->Const.MaxClipPlanes = 8; 298 ctx->Const.MaxCombinedTextureImageUnits = 32; 299 ctx->Const.MaxDrawBuffers = 4; 300 ctx->Const.MinProgramTexelOffset = -8; 301 ctx->Const.MaxProgramTexelOffset = 7; 302 ctx->Const.MaxLights = 0; 303 ctx->Const.MaxTextureCoordUnits = 0; 304 ctx->Const.MaxTextureUnits = 0; 305 306 ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16; 307 ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 16; 308 ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 1024; 309 ctx->Const.Program[MESA_SHADER_VERTEX].MaxCombinedUniformComponents = 1024; 310 ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */ 311 ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 16 * 4; 312 313 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 16; 314 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 224; 315 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxCombinedUniformComponents = 224; 316 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 15 * 4; 317 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */ 318 319 ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents / 4; 320 break; 321 } 322 323 ctx->Const.GenerateTemporaryNames = true; 324 ctx->Const.MaxPatchVertices = 32; 325 326 /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */ 327 ctx->Const.MaxUserAssignableUniformLocations = 328 4 * MESA_SHADER_STAGES * MAX_UNIFORMS; 329 330 ctx->Driver.NewProgram = new_program; 331} 332 333/* Returned string will have 'ctx' as its ralloc owner. */ 334static char * 335load_text_file(void *ctx, const char *file_name) 336{ 337 char *text = NULL; 338 size_t size; 339 size_t total_read = 0; 340 FILE *fp = fopen(file_name, "rb"); 341 342 if (!fp) { 343 return NULL; 344 } 345 346 fseek(fp, 0L, SEEK_END); 347 size = ftell(fp); 348 fseek(fp, 0L, SEEK_SET); 349 350 text = (char *) ralloc_size(ctx, size + 1); 351 if (text != NULL) { 352 do { 353 size_t bytes = fread(text + total_read, 354 1, size - total_read, fp); 355 if (bytes < size - total_read) { 356 free(text); 357 text = NULL; 358 goto error; 359 } 360 361 if (bytes == 0) { 362 break; 363 } 364 365 total_read += bytes; 366 } while (total_read < size); 367 368 text[total_read] = '\0'; 369 error:; 370 } 371 372 fclose(fp); 373 374 return text; 375} 376 377void 378compile_shader(struct gl_context *ctx, struct gl_shader *shader) 379{ 380 struct _mesa_glsl_parse_state *state = 381 new(shader) _mesa_glsl_parse_state(ctx, shader->Stage, shader); 382 383 _mesa_glsl_compile_shader(ctx, shader, options->dump_ast, options->dump_hir); 384 385 /* Print out the resulting IR */ 386 if (!state->error && options->dump_lir) { 387 _mesa_print_ir(stdout, shader->ir, state); 388 } 389 390 return; 391} 392 393extern "C" struct gl_shader_program * 394standalone_compile_shader(const struct standalone_options *_options, 395 unsigned num_files, char* const* files) 396{ 397 int status = EXIT_SUCCESS; 398 static struct gl_context local_ctx; 399 struct gl_context *ctx = &local_ctx; 400 bool glsl_es = false; 401 402 options = _options; 403 404 switch (options->glsl_version) { 405 case 100: 406 case 300: 407 glsl_es = true; 408 break; 409 case 110: 410 case 120: 411 case 130: 412 case 140: 413 case 150: 414 case 330: 415 case 400: 416 case 410: 417 case 420: 418 case 430: 419 case 440: 420 case 450: 421 glsl_es = false; 422 break; 423 default: 424 fprintf(stderr, "Unrecognized GLSL version `%d'\n", options->glsl_version); 425 return NULL; 426 } 427 428 if (glsl_es) { 429 initialize_context(ctx, API_OPENGLES2); 430 } else { 431 initialize_context(ctx, options->glsl_version > 130 ? API_OPENGL_CORE : API_OPENGL_COMPAT); 432 } 433 434 struct gl_shader_program *whole_program; 435 436 whole_program = rzalloc (NULL, struct gl_shader_program); 437 assert(whole_program != NULL); 438 whole_program->data = rzalloc(whole_program, struct gl_shader_program_data); 439 assert(whole_program->data != NULL); 440 whole_program->data->InfoLog = ralloc_strdup(whole_program->data, ""); 441 442 /* Created just to avoid segmentation faults */ 443 whole_program->AttributeBindings = new string_to_uint_map; 444 whole_program->FragDataBindings = new string_to_uint_map; 445 whole_program->FragDataIndexBindings = new string_to_uint_map; 446 447 for (unsigned i = 0; i < num_files; i++) { 448 whole_program->Shaders = 449 reralloc(whole_program, whole_program->Shaders, 450 struct gl_shader *, whole_program->NumShaders + 1); 451 assert(whole_program->Shaders != NULL); 452 453 struct gl_shader *shader = rzalloc(whole_program, gl_shader); 454 455 whole_program->Shaders[whole_program->NumShaders] = shader; 456 whole_program->NumShaders++; 457 458 const unsigned len = strlen(files[i]); 459 if (len < 6) 460 goto fail; 461 462 const char *const ext = & files[i][len - 5]; 463 /* TODO add support to read a .shader_test */ 464 if (strncmp(".vert", ext, 5) == 0 || strncmp(".glsl", ext, 5) == 0) 465 shader->Type = GL_VERTEX_SHADER; 466 else if (strncmp(".tesc", ext, 5) == 0) 467 shader->Type = GL_TESS_CONTROL_SHADER; 468 else if (strncmp(".tese", ext, 5) == 0) 469 shader->Type = GL_TESS_EVALUATION_SHADER; 470 else if (strncmp(".geom", ext, 5) == 0) 471 shader->Type = GL_GEOMETRY_SHADER; 472 else if (strncmp(".frag", ext, 5) == 0) 473 shader->Type = GL_FRAGMENT_SHADER; 474 else if (strncmp(".comp", ext, 5) == 0) 475 shader->Type = GL_COMPUTE_SHADER; 476 else 477 goto fail; 478 shader->Stage = _mesa_shader_enum_to_shader_stage(shader->Type); 479 480 shader->Source = load_text_file(whole_program, files[i]); 481 if (shader->Source == NULL) { 482 printf("File \"%s\" does not exist.\n", files[i]); 483 exit(EXIT_FAILURE); 484 } 485 486 compile_shader(ctx, shader); 487 488 if (strlen(shader->InfoLog) > 0) { 489 if (!options->just_log) 490 printf("Info log for %s:\n", files[i]); 491 492 printf("%s", shader->InfoLog); 493 if (!options->just_log) 494 printf("\n"); 495 } 496 497 if (!shader->CompileStatus) { 498 status = EXIT_FAILURE; 499 break; 500 } 501 } 502 503 if (status == EXIT_SUCCESS) { 504 _mesa_clear_shader_program_data(ctx, whole_program); 505 506 if (options->do_link) { 507 link_shaders(ctx, whole_program); 508 } else { 509 const gl_shader_stage stage = whole_program->Shaders[0]->Stage; 510 511 whole_program->data->LinkStatus = GL_TRUE; 512 whole_program->_LinkedShaders[stage] = 513 link_intrastage_shaders(whole_program /* mem_ctx */, 514 ctx, 515 whole_program, 516 whole_program->Shaders, 517 1, 518 true); 519 520 /* Par-linking can fail, for example, if there are undefined external 521 * references. 522 */ 523 if (whole_program->_LinkedShaders[stage] != NULL) { 524 assert(whole_program->data->LinkStatus); 525 526 struct gl_shader_compiler_options *const compiler_options = 527 &ctx->Const.ShaderCompilerOptions[stage]; 528 529 exec_list *const ir = 530 whole_program->_LinkedShaders[stage]->ir; 531 532 bool progress; 533 do { 534 progress = do_function_inlining(ir); 535 536 progress = do_common_optimization(ir, 537 false, 538 false, 539 compiler_options, 540 true) 541 && progress; 542 } while(progress); 543 } 544 } 545 546 status = (whole_program->data->LinkStatus) ? EXIT_SUCCESS : EXIT_FAILURE; 547 548 if (strlen(whole_program->data->InfoLog) > 0) { 549 printf("\n"); 550 if (!options->just_log) 551 printf("Info log for linking:\n"); 552 printf("%s", whole_program->data->InfoLog); 553 if (!options->just_log) 554 printf("\n"); 555 } 556 557 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 558 struct gl_linked_shader *shader = whole_program->_LinkedShaders[i]; 559 560 if (!shader) 561 continue; 562 563 add_neg_to_sub_visitor v; 564 visit_list_elements(&v, shader->ir); 565 566 dead_variable_visitor dv; 567 visit_list_elements(&dv, shader->ir); 568 dv.remove_dead_variables(); 569 } 570 571 if (options->dump_builder) { 572 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 573 struct gl_linked_shader *shader = whole_program->_LinkedShaders[i]; 574 575 if (!shader) 576 continue; 577 578 _mesa_print_builder_for_ir(stdout, shader->ir); 579 } 580 } 581 } 582 583 return whole_program; 584 585fail: 586 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 587 if (whole_program->_LinkedShaders[i]) 588 ralloc_free(whole_program->_LinkedShaders[i]->Program); 589 } 590 591 ralloc_free(whole_program); 592 return NULL; 593} 594 595extern "C" void 596standalone_compiler_cleanup(struct gl_shader_program *whole_program) 597{ 598 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 599 if (whole_program->_LinkedShaders[i]) 600 ralloc_free(whole_program->_LinkedShaders[i]->Program); 601 } 602 603 delete whole_program->AttributeBindings; 604 delete whole_program->FragDataBindings; 605 delete whole_program->FragDataIndexBindings; 606 607 ralloc_free(whole_program); 608 _mesa_glsl_release_types(); 609 _mesa_glsl_release_builtin_functions(); 610} 611