src/compiler/glsl/standalone.cpp

   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 "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 "builtin_functions.h"
  45 #include "opt_add_neg_to_sub.h"
  46 #include "main/mtypes.h"
  47
  48 class dead_variable_visitor : public ir_hierarchical_visitor {
  49 public:
  50    dead_variable_visitor()
  51    {
  52       variables = _mesa_pointer_set_create(NULL);
  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       set_foreach(variables, entry) {
  89          ir_variable *ir = (ir_variable *) entry->key;
  90
  91          assert(ir->ir_type == ir_type_variable);
  92          ir->remove();
  93       }
  94    }
  95
  96 private:
  97    set *variables;
  98 };
  99
 100 static void
 101 init_gl_program(struct gl_program *prog, bool is_arb_asm)
 102 {
 103    prog->RefCount = 1;
 104    prog->Format = GL_PROGRAM_FORMAT_ASCII_ARB;
 105    prog->is_arb_asm = is_arb_asm;
 106 }
 107
 108 static struct gl_program *
 109 new_program(UNUSED struct gl_context *ctx, GLenum target,
 110             UNUSED GLuint id, bool is_arb_asm)
 111 {
 112    switch (target) {
 113    case GL_VERTEX_PROGRAM_ARB: /* == GL_VERTEX_PROGRAM_NV */
 114    case GL_GEOMETRY_PROGRAM_NV:
 115    case GL_TESS_CONTROL_PROGRAM_NV:
 116    case GL_TESS_EVALUATION_PROGRAM_NV:
 117    case GL_FRAGMENT_PROGRAM_ARB:
 118    case GL_COMPUTE_PROGRAM_NV: {
 119       struct gl_program *prog = rzalloc(NULL, struct gl_program);
 120       init_gl_program(prog, is_arb_asm);
 121       return prog;
 122    }
 123    default:
 124       printf("bad target in new_program\n");
 125       return NULL;
 126    }
 127 }
 128
 129 static const struct standalone_options *options;
 130
 131 static void
 132 initialize_context(struct gl_context *ctx, gl_api api)
 133 {
 134    initialize_context_to_defaults(ctx, api);
 135    glsl_type_singleton_init_or_ref();
 136
 137    /* The standalone compiler needs to claim support for almost
 138     * everything in order to compile the built-in functions.
 139     */
 140    ctx->Const.GLSLVersion = options->glsl_version;
 141    ctx->Extensions.ARB_ES3_compatibility = true;
 142    ctx->Extensions.ARB_ES3_1_compatibility = true;
 143    ctx->Extensions.ARB_ES3_2_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       ctx->Const.MaxUniformBufferBindings = 84;
 233       ctx->Const.MaxVertexStreams = 4;
 234       ctx->Const.MaxTransformFeedbackBuffers = 4;
 235
 236       ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16;
 237       ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 16;
 238       ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 1024;
 239       ctx->Const.Program[MESA_SHADER_VERTEX].MaxCombinedUniformComponents = 1024;
 240       ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */
 241       ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 64;
 242
 243       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 16;
 244       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 1024;
 245       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxCombinedUniformComponents = 1024;
 246       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents =
 247          ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents;
 248       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */
 249
 250       ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4;
 251       break;
 252    case 150:
 253    case 330:
 254    case 400:
 255    case 410:
 256    case 420:
 257    case 430:
 258    case 440:
 259    case 450:
 260    case 460:
 261       ctx->Const.MaxClipPlanes = 8;
 262       ctx->Const.MaxDrawBuffers = 8;
 263       ctx->Const.MinProgramTexelOffset = -8;
 264       ctx->Const.MaxProgramTexelOffset = 7;
 265       ctx->Const.MaxLights = 8;
 266       ctx->Const.MaxTextureCoordUnits = 8;
 267       ctx->Const.MaxTextureUnits = 2;
 268       ctx->Const.MaxUniformBufferBindings = 84;
 269       ctx->Const.MaxVertexStreams = 4;
 270       ctx->Const.MaxTransformFeedbackBuffers = 4;
 271       ctx->Const.MaxShaderStorageBufferBindings = 4;
 272       ctx->Const.MaxShaderStorageBlockSize = 4096;
 273       ctx->Const.MaxAtomicBufferBindings = 4;
 274
 275       ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16;
 276       ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 16;
 277       ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 1024;
 278       ctx->Const.Program[MESA_SHADER_VERTEX].MaxCombinedUniformComponents = 1024;
 279       ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */
 280       ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 64;
 281
 282       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = 16;
 283       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxUniformComponents = 1024;
 284       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxCombinedUniformComponents = 1024;
 285       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxInputComponents =
 286          ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents;
 287       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxOutputComponents = 128;
 288
 289       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 16;
 290       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 1024;
 291       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxCombinedUniformComponents = 1024;
 292       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents =
 293          ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxOutputComponents;
 294       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */
 295
 296       ctx->Const.MaxCombinedTextureImageUnits =
 297          ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits
 298          + ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits
 299          + ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits;
 300
 301       ctx->Const.MaxGeometryOutputVertices = 256;
 302       ctx->Const.MaxGeometryTotalOutputComponents = 1024;
 303
 304       ctx->Const.MaxVarying = 60 / 4;
 305       break;
 306    case 300:
 307       ctx->Const.MaxClipPlanes = 8;
 308       ctx->Const.MaxCombinedTextureImageUnits = 32;
 309       ctx->Const.MaxDrawBuffers = 4;
 310       ctx->Const.MinProgramTexelOffset = -8;
 311       ctx->Const.MaxProgramTexelOffset = 7;
 312       ctx->Const.MaxLights = 0;
 313       ctx->Const.MaxTextureCoordUnits = 0;
 314       ctx->Const.MaxTextureUnits = 0;
 315       ctx->Const.MaxUniformBufferBindings = 84;
 316       ctx->Const.MaxVertexStreams = 4;
 317       ctx->Const.MaxTransformFeedbackBuffers = 4;
 318
 319       ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16;
 320       ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 16;
 321       ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 1024;
 322       ctx->Const.Program[MESA_SHADER_VERTEX].MaxCombinedUniformComponents = 1024;
 323       ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */
 324       ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 16 * 4;
 325
 326       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 16;
 327       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 224;
 328       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxCombinedUniformComponents = 224;
 329       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 15 * 4;
 330       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */
 331
 332       ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents / 4;
 333       break;
 334    }
 335
 336    ctx->Const.GenerateTemporaryNames = true;
 337    ctx->Const.MaxPatchVertices = 32;
 338
 339    /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
 340    ctx->Const.MaxUserAssignableUniformLocations =
 341       4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
 342
 343    ctx->Driver.NewProgram = new_program;
 344 }
 345
 346 /* Returned string will have 'ctx' as its ralloc owner. */
 347 static char *
 348 load_text_file(void *ctx, const char *file_name)
 349 {
 350    char *text = NULL;
 351    size_t size;
 352    size_t total_read = 0;
 353    FILE *fp = fopen(file_name, "rb");
 354
 355    if (!fp) {
 356       return NULL;
 357    }
 358
 359    fseek(fp, 0L, SEEK_END);
 360    size = ftell(fp);
 361    fseek(fp, 0L, SEEK_SET);
 362
 363    text = (char *) ralloc_size(ctx, size + 1);
 364    if (text != NULL) {
 365       do {
 366          size_t bytes = fread(text + total_read,
 367                1, size - total_read, fp);
 368          if (bytes < size - total_read) {
 369             free(text);
 370             text = NULL;
 371             goto error;
 372          }
 373
 374          if (bytes == 0) {
 375             break;
 376          }
 377
 378          total_read += bytes;
 379       } while (total_read < size);
 380
 381       text[total_read] = '\0';
 382       error:;
 383    }
 384
 385    fclose(fp);
 386
 387    return text;
 388 }
 389
 390 static void
 391 compile_shader(struct gl_context *ctx, struct gl_shader *shader)
 392 {
 393    struct _mesa_glsl_parse_state *state =
 394       new(shader) _mesa_glsl_parse_state(ctx, shader->Stage, shader);
 395
 396    _mesa_glsl_compile_shader(ctx, shader, options->dump_ast,
 397                              options->dump_hir, true);
 398
 399    /* Print out the resulting IR */
 400    if (!state->error && options->dump_lir) {
 401       _mesa_print_ir(stdout, shader->ir, state);
 402    }
 403
 404    return;
 405 }
 406
 407 extern "C" struct gl_shader_program *
 408 standalone_compile_shader(const struct standalone_options *_options,
 409       unsigned num_files, char* const* files, struct gl_context *ctx)
 410 {
 411    int status = EXIT_SUCCESS;
 412    bool glsl_es = false;
 413
 414    options = _options;
 415
 416    switch (options->glsl_version) {
 417    case 100:
 418    case 300:
 419       glsl_es = true;
 420       break;
 421    case 110:
 422    case 120:
 423    case 130:
 424    case 140:
 425    case 150:
 426    case 330:
 427    case 400:
 428    case 410:
 429    case 420:
 430    case 430:
 431    case 440:
 432    case 450:
 433    case 460:
 434       glsl_es = false;
 435       break;
 436    default:
 437       fprintf(stderr, "Unrecognized GLSL version `%d'\n", options->glsl_version);
 438       return NULL;
 439    }
 440
 441    if (glsl_es) {
 442       initialize_context(ctx, API_OPENGLES2);
 443    } else {
 444       initialize_context(ctx, options->glsl_version > 130 ? API_OPENGL_CORE : API_OPENGL_COMPAT);
 445    }
 446
 447    struct gl_shader_program *whole_program;
 448
 449    whole_program = rzalloc (NULL, struct gl_shader_program);
 450    assert(whole_program != NULL);
 451    whole_program->data = rzalloc(whole_program, struct gl_shader_program_data);
 452    assert(whole_program->data != NULL);
 453    whole_program->data->InfoLog = ralloc_strdup(whole_program->data, "");
 454
 455    /* Created just to avoid segmentation faults */
 456    whole_program->AttributeBindings = new string_to_uint_map;
 457    whole_program->FragDataBindings = new string_to_uint_map;
 458    whole_program->FragDataIndexBindings = new string_to_uint_map;
 459
 460    for (unsigned i = 0; i < num_files; i++) {
 461       whole_program->Shaders =
 462             reralloc(whole_program, whole_program->Shaders,
 463                   struct gl_shader *, whole_program->NumShaders + 1);
 464       assert(whole_program->Shaders != NULL);
 465
 466       struct gl_shader *shader = rzalloc(whole_program, gl_shader);
 467
 468       whole_program->Shaders[whole_program->NumShaders] = shader;
 469       whole_program->NumShaders++;
 470
 471       const unsigned len = strlen(files[i]);
 472       if (len < 6)
 473          goto fail;
 474
 475       const char *const ext = & files[i][len - 5];
 476       /* TODO add support to read a .shader_test */
 477       if (strncmp(".vert", ext, 5) == 0 || strncmp(".glsl", ext, 5) == 0)
 478          shader->Type = GL_VERTEX_SHADER;
 479       else if (strncmp(".tesc", ext, 5) == 0)
 480          shader->Type = GL_TESS_CONTROL_SHADER;
 481       else if (strncmp(".tese", ext, 5) == 0)
 482          shader->Type = GL_TESS_EVALUATION_SHADER;
 483       else if (strncmp(".geom", ext, 5) == 0)
 484          shader->Type = GL_GEOMETRY_SHADER;
 485       else if (strncmp(".frag", ext, 5) == 0)
 486          shader->Type = GL_FRAGMENT_SHADER;
 487       else if (strncmp(".comp", ext, 5) == 0)
 488          shader->Type = GL_COMPUTE_SHADER;
 489       else
 490          goto fail;
 491       shader->Stage = _mesa_shader_enum_to_shader_stage(shader->Type);
 492
 493       shader->Source = load_text_file(whole_program, files[i]);
 494       if (shader->Source == NULL) {
 495          printf("File \"%s\" does not exist.\n", files[i]);
 496          exit(EXIT_FAILURE);
 497       }
 498
 499       compile_shader(ctx, shader);
 500
 501       if (strlen(shader->InfoLog) > 0) {
 502          if (!options->just_log)
 503             printf("Info log for %s:\n", files[i]);
 504
 505          printf("%s", shader->InfoLog);
 506          if (!options->just_log)
 507             printf("\n");
 508       }
 509
 510       if (!shader->CompileStatus) {
 511          status = EXIT_FAILURE;
 512          break;
 513       }
 514    }
 515
 516    if (status == EXIT_SUCCESS) {
 517       _mesa_clear_shader_program_data(ctx, whole_program);
 518
 519       if (options->do_link)  {
 520          link_shaders(ctx, whole_program);
 521       } else {
 522          const gl_shader_stage stage = whole_program->Shaders[0]->Stage;
 523
 524          whole_program->data->LinkStatus = LINKING_SUCCESS;
 525          whole_program->_LinkedShaders[stage] =
 526             link_intrastage_shaders(whole_program /* mem_ctx */,
 527                                     ctx,
 528                                     whole_program,
 529                                     whole_program->Shaders,
 530                                     1,
 531                                     true);
 532
 533          /* Par-linking can fail, for example, if there are undefined external
 534           * references.
 535           */
 536          if (whole_program->_LinkedShaders[stage] != NULL) {
 537             assert(whole_program->data->LinkStatus);
 538
 539             struct gl_shader_compiler_options *const compiler_options =
 540                &ctx->Const.ShaderCompilerOptions[stage];
 541
 542             exec_list *const ir =
 543                whole_program->_LinkedShaders[stage]->ir;
 544
 545             bool progress;
 546             do {
 547                progress = do_function_inlining(ir);
 548
 549                progress = do_common_optimization(ir,
 550                                                  false,
 551                                                  false,
 552                                                  compiler_options,
 553                                                  true)
 554                   && progress;
 555             } while(progress);
 556          }
 557       }
 558
 559       status = (whole_program->data->LinkStatus) ? EXIT_SUCCESS : EXIT_FAILURE;
 560
 561       if (strlen(whole_program->data->InfoLog) > 0) {
 562          printf("\n");
 563          if (!options->just_log)
 564             printf("Info log for linking:\n");
 565          printf("%s", whole_program->data->InfoLog);
 566          if (!options->just_log)
 567             printf("\n");
 568       }
 569
 570       for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
 571          struct gl_linked_shader *shader = whole_program->_LinkedShaders[i];
 572
 573          if (!shader)
 574             continue;
 575
 576          add_neg_to_sub_visitor v;
 577          visit_list_elements(&v, shader->ir);
 578
 579          dead_variable_visitor dv;
 580          visit_list_elements(&dv, shader->ir);
 581          dv.remove_dead_variables();
 582       }
 583
 584       if (options->dump_builder) {
 585          for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
 586             struct gl_linked_shader *shader = whole_program->_LinkedShaders[i];
 587
 588             if (!shader)
 589                continue;
 590
 591             _mesa_print_builder_for_ir(stdout, shader->ir);
 592          }
 593       }
 594    }
 595
 596    return whole_program;
 597
 598 fail:
 599    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
 600       if (whole_program->_LinkedShaders[i])
 601          ralloc_free(whole_program->_LinkedShaders[i]->Program);
 602    }
 603
 604    ralloc_free(whole_program);
 605    return NULL;
 606 }
 607
 608 extern "C" void
 609 standalone_compiler_cleanup(struct gl_shader_program *whole_program)
 610 {
 611    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
 612       if (whole_program->_LinkedShaders[i])
 613          ralloc_free(whole_program->_LinkedShaders[i]->Program);
 614    }
 615
 616    delete whole_program->AttributeBindings;
 617    delete whole_program->FragDataBindings;
 618    delete whole_program->FragDataIndexBindings;
 619
 620    ralloc_free(whole_program);
 621    glsl_type_singleton_decref();
 622    _mesa_glsl_release_builtin_functions();
 623 }