X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Fmain.cpp;h=096da93dcef7480e1ccaaff6dba8635be9c8698f;hb=cbcb84fccf0e7a9450a10bc1daf3572ab9a4955c;hp=b32e2ad3dbc6c3cb9b91e7595a2fca34f3c38dd9;hpb=bda27424cf04c0d2ec2b49c56f562d5b2d2f0bff;p=mesa.git

diff --git a/src/glsl/main.cpp b/src/glsl/main.cpp
index b32e2ad3dbc..096da93dcef 100644
--- a/src/glsl/main.cpp
+++ b/src/glsl/main.cpp
@@ -20,112 +20,177 @@
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  */
-#include <cstdlib>
-#include <cstdio>
 #include <getopt.h>
 
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-
 #include "ast.h"
 #include "glsl_parser_extras.h"
 #include "glsl_parser.h"
 #include "ir_optimization.h"
 #include "ir_print_visitor.h"
 #include "program.h"
+#include "loop_analysis.h"
+
+extern "C" struct gl_shader *
+_mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type);
+
+extern "C" void
+_mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
+                       struct gl_shader *sh);
+
+/* Copied from shader_api.c for the stand-alone compiler.
+ */
+void
+_mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
+                       struct gl_shader *sh)
+{
+   *ptr = sh;
+}
+
+struct gl_shader *
+_mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type)
+{
+   struct gl_shader *shader;
 
-/* Returned string will have 'ctx' as its talloc owner. */
+   (void) ctx;
+
+   assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER);
+   shader = rzalloc(NULL, struct gl_shader);
+   if (shader) {
+      shader->Type = type;
+      shader->Name = name;
+      shader->RefCount = 1;
+   }
+   return shader;
+}
+
+static void
+initialize_context(struct gl_context *ctx, gl_api api)
+{
+   memset(ctx, 0, sizeof(*ctx));
+
+   ctx->API = api;
+
+   ctx->Extensions.ARB_ES2_compatibility = GL_TRUE;
+   ctx->Extensions.ARB_draw_buffers = GL_TRUE;
+   ctx->Extensions.ARB_draw_instanced = GL_TRUE;
+   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
+   ctx->Extensions.EXT_texture_array = GL_TRUE;
+   ctx->Extensions.NV_texture_rectangle = GL_TRUE;
+
+   /* GLSL 1.30 isn't fully supported, but we need to advertise 1.30 so that
+    * the built-in functions for 1.30 can be built.
+    */
+   ctx->Const.GLSLVersion = 130;
+
+   /* 1.10 minimums. */
+   ctx->Const.MaxLights = 8;
+   ctx->Const.MaxClipPlanes = 8;
+   ctx->Const.MaxTextureUnits = 2;
+
+   /* More than the 1.10 minimum to appease parser tests taken from
+    * apps that (hopefully) already checked the number of coords.
+    */
+   ctx->Const.MaxTextureCoordUnits = 4;
+
+   ctx->Const.VertexProgram.MaxAttribs = 16;
+   ctx->Const.VertexProgram.MaxUniformComponents = 512;
+   ctx->Const.MaxVarying = 8;
+   ctx->Const.MaxVertexTextureImageUnits = 0;
+   ctx->Const.MaxCombinedTextureImageUnits = 2;
+   ctx->Const.MaxTextureImageUnits = 2;
+   ctx->Const.FragmentProgram.MaxUniformComponents = 64;
+
+   ctx->Const.MaxDrawBuffers = 2;
+
+   ctx->Driver.NewShader = _mesa_new_shader;
+}
+
+/* Returned string will have 'ctx' as its ralloc owner. */
 static char *
-load_text_file(void *ctx, const char *file_name, size_t *size)
+load_text_file(void *ctx, const char *file_name)
 {
 	char *text = NULL;
-	struct stat st;
-	ssize_t total_read = 0;
-	int fd = open(file_name, O_RDONLY);
+	size_t size;
+	size_t total_read = 0;
+	FILE *fp = fopen(file_name, "rb");
 
-	*size = 0;
-	if (fd < 0) {
+	if (!fp) {
 		return NULL;
 	}
 
-	if (fstat(fd, & st) == 0) {
-	   text = (char *) talloc_size(ctx, st.st_size + 1);
-		if (text != NULL) {
-			do {
-				ssize_t bytes = read(fd, text + total_read,
-						     st.st_size - total_read);
-				if (bytes < 0) {
-					free(text);
-					text = NULL;
-					break;
-				}
-
-				if (bytes == 0) {
-					break;
-				}
-
-				total_read += bytes;
-			} while (total_read < st.st_size);
-
-			text[total_read] = '\0';
-			*size = total_read;
-		}
+	fseek(fp, 0L, SEEK_END);
+	size = ftell(fp);
+	fseek(fp, 0L, SEEK_SET);
+
+	text = (char *) ralloc_size(ctx, size + 1);
+	if (text != NULL) {
+		do {
+			size_t bytes = fread(text + total_read,
+					     1, size - total_read, fp);
+			if (bytes < size - total_read) {
+				free(text);
+				text = NULL;
+				break;
+			}
+
+			if (bytes == 0) {
+				break;
+			}
+
+			total_read += bytes;
+		} while (total_read < size);
+
+		text[total_read] = '\0';
 	}
 
-	close(fd);
+	fclose(fp);
 
 	return text;
 }
 
-
-void
-usage_fail(const char *name)
-{
-      printf("%s <filename.frag|filename.vert>\n", name);
-      exit(EXIT_FAILURE);
-}
-
-
+int glsl_es = 0;
 int dump_ast = 0;
+int dump_hir = 0;
 int dump_lir = 0;
 int do_link = 0;
 
 const struct option compiler_opts[] = {
+   { "glsl-es",  0, &glsl_es,  1 },
    { "dump-ast", 0, &dump_ast, 1 },
+   { "dump-hir", 0, &dump_hir, 1 },
    { "dump-lir", 0, &dump_lir, 1 },
    { "link",     0, &do_link,  1 },
    { NULL, 0, NULL, 0 }
 };
 
+/**
+ * \brief Print proper usage and exit with failure.
+ */
 void
-compile_shader(struct glsl_shader *shader)
+usage_fail(const char *name)
 {
-   struct _mesa_glsl_parse_state *state;
-
-   state = talloc_zero(talloc_parent(shader), struct _mesa_glsl_parse_state);
 
-   switch (shader->Type) {
-   case GL_VERTEX_SHADER:   state->target = vertex_shader; break;
-   case GL_FRAGMENT_SHADER: state->target = fragment_shader; break;
-   case GL_GEOMETRY_SHADER: state->target = geometry_shader; break;
+   const char *header =
+      "usage: %s [options] <file.vert | file.geom | file.frag>\n"
+      "\n"
+      "Possible options are:\n";
+   printf(header, name, name);
+   for (const struct option *o = compiler_opts; o->name != 0; ++o) {
+      printf("    --%s\n", o->name);
    }
+   exit(EXIT_FAILURE);
+}
+
+
+void
+compile_shader(struct gl_context *ctx, struct gl_shader *shader)
+{
+   struct _mesa_glsl_parse_state *state =
+      new(shader) _mesa_glsl_parse_state(ctx, shader->Type, shader);
 
-   state->scanner = NULL;
-   state->translation_unit.make_empty();
-   state->symbols = new(shader) glsl_symbol_table;
-   state->info_log = talloc_strdup(shader, "");
-   state->error = false;
-   state->temp_index = 0;
-   state->loop_or_switch_nesting = NULL;
-   state->ARB_texture_rectangle_enable = true;
-
-   /* Create a new context for the preprocessor output.  Ultimately, this
-    * should probably be the parser context, but there isn't one yet.
-   */
    const char *source = shader->Source;
-   state->error = preprocess(shader, &source, &state->info_log);
+   state->error = preprocess(state, &source, &state->info_log,
+			     state->extensions, ctx->API) != 0;
 
    if (!state->error) {
       _mesa_glsl_lexer_ctor(state, source);
@@ -141,46 +206,48 @@ compile_shader(struct glsl_shader *shader)
       printf("\n\n");
    }
 
-   shader->ir.make_empty();
+   shader->ir = new(shader) exec_list;
    if (!state->error && !state->translation_unit.is_empty())
-      _mesa_ast_to_hir(&shader->ir, state);
+      _mesa_ast_to_hir(shader->ir, state);
 
-   validate_ir_tree(&shader->ir);
+   /* Print out the unoptimized IR. */
+   if (!state->error && dump_hir) {
+      validate_ir_tree(shader->ir);
+      _mesa_print_ir(shader->ir, state);
+   }
 
    /* Optimization passes */
-   if (!state->error && !shader->ir.is_empty()) {
+   if (!state->error && !shader->ir->is_empty()) {
       bool progress;
       do {
-	 progress = false;
-
-	 progress = do_function_inlining(&shader->ir) || progress;
-	 progress = do_if_simplification(&shader->ir) || progress;
-	 progress = do_copy_propagation(&shader->ir) || progress;
-	 progress = do_dead_code_local(&shader->ir) || progress;
-	 progress = do_dead_code_unlinked(state, &shader->ir) || progress;
-	 progress = do_constant_variable_unlinked(&shader->ir) || progress;
-	 progress = do_constant_folding(&shader->ir) || progress;
-	 progress = do_vec_index_to_swizzle(&shader->ir) || progress;
-	 progress = do_swizzle_swizzle(&shader->ir) || progress;
+	 progress = do_common_optimization(shader->ir, false, 32);
       } while (progress);
+
+      validate_ir_tree(shader->ir);
    }
 
-   validate_ir_tree(&shader->ir);
 
    /* Print out the resulting IR */
    if (!state->error && dump_lir) {
-      _mesa_print_ir(&shader->ir, state);
+      _mesa_print_ir(shader->ir, state);
    }
 
    shader->symbols = state->symbols;
    shader->CompileStatus = !state->error;
+   shader->Version = state->language_version;
+   memcpy(shader->builtins_to_link, state->builtins_to_link,
+	  sizeof(shader->builtins_to_link[0]) * state->num_builtins_to_link);
+   shader->num_builtins_to_link = state->num_builtins_to_link;
 
    if (shader->InfoLog)
-      talloc_free(shader->InfoLog);
+      ralloc_free(shader->InfoLog);
 
    shader->InfoLog = state->info_log;
 
-   talloc_free(state);
+   /* Retain any live IR, but trash the rest. */
+   reparent_ir(shader->ir, shader);
+
+   ralloc_free(state);
 
    return;
 }
@@ -189,6 +256,8 @@ int
 main(int argc, char **argv)
 {
    int status = EXIT_SUCCESS;
+   struct gl_context local_ctx;
+   struct gl_context *ctx = &local_ctx;
 
    int c;
    int idx = 0;
@@ -199,18 +268,20 @@ main(int argc, char **argv)
    if (argc <= optind)
       usage_fail(argv[0]);
 
-   struct glsl_program *whole_program;
+   initialize_context(ctx, (glsl_es) ? API_OPENGLES2 : API_OPENGL);
+
+   struct gl_shader_program *whole_program;
 
-   whole_program = talloc_zero (NULL, struct glsl_program);
+   whole_program = rzalloc (NULL, struct gl_shader_program);
    assert(whole_program != NULL);
 
    for (/* empty */; argc > optind; optind++) {
-      whole_program->Shaders = (struct glsl_shader **)
-	 talloc_realloc(whole_program, whole_program->Shaders,
-			struct glsl_shader *, whole_program->NumShaders + 1);
+      whole_program->Shaders =
+	 reralloc(whole_program, whole_program->Shaders,
+		  struct gl_shader *, whole_program->NumShaders + 1);
       assert(whole_program->Shaders != NULL);
 
-      struct glsl_shader *shader = talloc_zero(whole_program, glsl_shader);
+      struct gl_shader *shader = rzalloc(whole_program, gl_shader);
 
       whole_program->Shaders[whole_program->NumShaders] = shader;
       whole_program->NumShaders++;
@@ -229,14 +300,13 @@ main(int argc, char **argv)
       else
 	 usage_fail(argv[0]);
 
-      shader->Source = load_text_file(whole_program,
-				      argv[optind], &shader->SourceLen);
+      shader->Source = load_text_file(whole_program, argv[optind]);
       if (shader->Source == NULL) {
 	 printf("File \"%s\" does not exist.\n", argv[optind]);
 	 exit(EXIT_FAILURE);
       }
 
-      compile_shader(shader);
+      compile_shader(ctx, shader);
 
       if (!shader->CompileStatus) {
 	 printf("Info log for %s:\n%s\n", argv[optind], shader->InfoLog);
@@ -246,11 +316,19 @@ main(int argc, char **argv)
    }
 
    if ((status == EXIT_SUCCESS) && do_link)  {
-      link_shaders(whole_program);
+      link_shaders(ctx, whole_program);
       status = (whole_program->LinkStatus) ? EXIT_SUCCESS : EXIT_FAILURE;
+
+      if (strlen(whole_program->InfoLog) > 0)
+	 printf("Info log for linking:\n%s\n", whole_program->InfoLog);
    }
 
-   talloc_free(whole_program);
+   for (unsigned i = 0; i < MESA_SHADER_TYPES; i++)
+      ralloc_free(whole_program->_LinkedShaders[i]);
+
+   ralloc_free(whole_program);
+   _mesa_glsl_release_types();
+   _mesa_glsl_release_functions();
 
    return status;
 }