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