standalone.cpp revision 7e102996 
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
48class dead_variable_visitor : public ir_hierarchical_visitor {
49public:
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
96private:
97   set *variables;
98};
99
100static void
101init_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
108static struct gl_program *
109new_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
129static const struct standalone_options *options;
130
131static void
132initialize_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. */
347static char *
348load_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
390static void
391compile_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
407extern "C" struct gl_shader_program *
408standalone_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
598fail:
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
608extern "C" void
609standalone_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}
624