Rev 4358 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4358 | Serge | 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 |
||
24 | |||
25 | /** @file main.cpp |
||
26 | * |
||
27 | * This file is the main() routine and scaffolding for producing |
||
28 | * builtin_compiler (which doesn't include builtins itself and is used |
||
29 | * to generate the profile information for builtin_function.cpp), and |
||
30 | * for glsl_compiler (which does include builtins and can be used to |
||
31 | * offline compile GLSL code and examine the resulting GLSL IR. |
||
32 | */ |
||
33 | |||
34 | #include "ast.h" |
||
35 | #include "glsl_parser_extras.h" |
||
36 | #include "ir_optimization.h" |
||
37 | #include "program.h" |
||
38 | #include "loop_analysis.h" |
||
39 | #include "standalone_scaffolding.h" |
||
40 | |||
41 | static void |
||
42 | initialize_context(struct gl_context *ctx, gl_api api) |
||
43 | { |
||
44 | initialize_context_to_defaults(ctx, api); |
||
45 | |||
46 | /* The standalone compiler needs to claim support for almost |
||
47 | * everything in order to compile the built-in functions. |
||
48 | */ |
||
49 | ctx->Const.GLSLVersion = 150; |
||
50 | ctx->Extensions.ARB_ES3_compatibility = true; |
||
51 | |||
52 | ctx->Const.MaxClipPlanes = 8; |
||
53 | ctx->Const.MaxDrawBuffers = 2; |
||
54 | |||
55 | /* More than the 1.10 minimum to appease parser tests taken from |
||
56 | * apps that (hopefully) already checked the number of coords. |
||
57 | */ |
||
58 | ctx->Const.MaxTextureCoordUnits = 4; |
||
59 | |||
60 | ctx->Driver.NewShader = _mesa_new_shader; |
||
61 | } |
||
62 | |||
63 | /* Returned string will have 'ctx' as its ralloc owner. */ |
||
64 | static char * |
||
65 | load_text_file(void *ctx, const char *file_name) |
||
66 | { |
||
67 | char *text = NULL; |
||
68 | size_t size; |
||
69 | size_t total_read = 0; |
||
70 | FILE *fp = fopen(file_name, "rb"); |
||
71 | |||
72 | if (!fp) { |
||
73 | return NULL; |
||
74 | } |
||
75 | |||
76 | fseek(fp, 0L, SEEK_END); |
||
77 | size = ftell(fp); |
||
78 | fseek(fp, 0L, SEEK_SET); |
||
79 | |||
80 | text = (char *) ralloc_size(ctx, size + 1); |
||
81 | if (text != NULL) { |
||
82 | do { |
||
83 | size_t bytes = fread(text + total_read, |
||
84 | 1, size - total_read, fp); |
||
85 | if (bytes < size - total_read) { |
||
86 | free(text); |
||
87 | text = NULL; |
||
88 | break; |
||
89 | } |
||
90 | |||
91 | if (bytes == 0) { |
||
92 | break; |
||
93 | } |
||
94 | |||
95 | total_read += bytes; |
||
96 | } while (total_read < size); |
||
97 | |||
98 | text[total_read] = '\0'; |
||
99 | } |
||
100 | |||
101 | fclose(fp); |
||
102 | |||
103 | return text; |
||
104 | } |
||
105 | |||
106 | int glsl_es = 0; |
||
4518 | Serge | 107 | int dump_ast = 1; |
108 | int dump_hir = 1; |
||
109 | int dump_lir = 1; |
||
110 | int do_link = 1; |
||
4358 | Serge | 111 | |
112 | const struct option compiler_opts[] = { |
||
113 | { "glsl-es", 0, &glsl_es, 1 }, |
||
114 | { "dump-ast", 0, &dump_ast, 1 }, |
||
115 | { "dump-hir", 0, &dump_hir, 1 }, |
||
116 | { "dump-lir", 0, &dump_lir, 1 }, |
||
117 | { "link", 0, &do_link, 1 }, |
||
118 | { NULL, 0, NULL, 0 } |
||
119 | }; |
||
120 | |||
121 | /** |
||
122 | * \brief Print proper usage and exit with failure. |
||
123 | */ |
||
124 | void |
||
125 | usage_fail(const char *name) |
||
126 | { |
||
127 | |||
128 | const char *header = |
||
129 | "usage: %s [options] |
||
130 | "\n" |
||
131 | "Possible options are:\n"; |
||
132 | printf(header, name, name); |
||
133 | for (const struct option *o = compiler_opts; o->name != 0; ++o) { |
||
134 | printf(" --%s\n", o->name); |
||
135 | } |
||
136 | exit(EXIT_FAILURE); |
||
137 | } |
||
138 | |||
139 | |||
140 | void |
||
141 | compile_shader(struct gl_context *ctx, struct gl_shader *shader) |
||
142 | { |
||
143 | struct _mesa_glsl_parse_state *state = |
||
144 | new(shader) _mesa_glsl_parse_state(ctx, shader->Type, shader); |
||
145 | |||
146 | _mesa_glsl_compile_shader(ctx, shader, dump_ast, dump_hir); |
||
147 | |||
148 | /* Print out the resulting IR */ |
||
149 | if (!state->error && dump_lir) { |
||
150 | _mesa_print_ir(shader->ir, state); |
||
151 | } |
||
152 | |||
153 | return; |
||
154 | } |
||
155 | |||
156 | int |
||
157 | main(int argc, char **argv) |
||
158 | { |
||
159 | int status = EXIT_SUCCESS; |
||
160 | struct gl_context local_ctx; |
||
161 | struct gl_context *ctx = &local_ctx; |
||
162 | |||
163 | int c; |
||
4518 | Serge | 164 | int idx = 0; |
165 | int optind =1; |
||
166 | // while ((c = getopt_long(argc, argv, "", compiler_opts, &idx)) != -1) |
||
167 | // /* empty */ ; |
||
4358 | Serge | 168 | |
169 | |||
4518 | Serge | 170 | // if (argc <= optind) |
171 | // usage_fail(argv[0]); |
||
4358 | Serge | 172 | |
173 | initialize_context(ctx, (glsl_es) ? API_OPENGLES2 : API_OPENGL_COMPAT); |
||
174 | |||
175 | struct gl_shader_program *whole_program; |
||
176 | |||
177 | whole_program = rzalloc (NULL, struct gl_shader_program); |
||
178 | assert(whole_program != NULL); |
||
179 | whole_program->InfoLog = ralloc_strdup(whole_program, ""); |
||
180 | |||
181 | for (/* empty */; argc > optind; optind++) { |
||
182 | whole_program->Shaders = |
||
183 | reralloc(whole_program, whole_program->Shaders, |
||
184 | struct gl_shader *, whole_program->NumShaders + 1); |
||
185 | assert(whole_program->Shaders != NULL); |
||
186 | |||
187 | struct gl_shader *shader = rzalloc(whole_program, gl_shader); |
||
188 | |||
189 | whole_program->Shaders[whole_program->NumShaders] = shader; |
||
190 | whole_program->NumShaders++; |
||
191 | |||
192 | const unsigned len = strlen(argv[optind]); |
||
193 | if (len < 6) |
||
194 | usage_fail(argv[0]); |
||
195 | |||
196 | const char *const ext = & argv[optind][len - 5]; |
||
197 | if (strncmp(".vert", ext, 5) == 0 || strncmp(".glsl", ext, 5) == 0) |
||
198 | shader->Type = GL_VERTEX_SHADER; |
||
199 | else if (strncmp(".geom", ext, 5) == 0) |
||
200 | shader->Type = GL_GEOMETRY_SHADER; |
||
201 | else if (strncmp(".frag", ext, 5) == 0) |
||
202 | shader->Type = GL_FRAGMENT_SHADER; |
||
203 | else |
||
204 | usage_fail(argv[0]); |
||
205 | |||
206 | shader->Source = load_text_file(whole_program, argv[optind]); |
||
207 | if (shader->Source == NULL) { |
||
208 | printf("File \"%s\" does not exist.\n", argv[optind]); |
||
209 | exit(EXIT_FAILURE); |
||
210 | } |
||
211 | |||
212 | compile_shader(ctx, shader); |
||
213 | |||
214 | if (!shader->CompileStatus) { |
||
215 | printf("Info log for %s:\n%s\n", argv[optind], shader->InfoLog); |
||
216 | status = EXIT_FAILURE; |
||
217 | break; |
||
218 | } |
||
219 | } |
||
220 | |||
221 | if ((status == EXIT_SUCCESS) && do_link) { |
||
222 | link_shaders(ctx, whole_program); |
||
223 | status = (whole_program->LinkStatus) ? EXIT_SUCCESS : EXIT_FAILURE; |
||
224 | |||
225 | if (strlen(whole_program->InfoLog) > 0) |
||
226 | printf("Info log for linking:\n%s\n", whole_program->InfoLog); |
||
227 | } |
||
228 | |||
229 | for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) |
||
230 | ralloc_free(whole_program->_LinkedShaders[i]); |
||
231 | |||
232 | ralloc_free(whole_program); |
||
233 | _mesa_glsl_release_types(); |
||
234 | _mesa_glsl_release_functions(); |
||
235 | |||
236 | return status; |
||
237 | }>>=>>> |