glsl2 main: Switch from realloc to talloc_realloc to construct program source.

This closes 1 leak in the glsl-orangebook-ch06-bump.frag test leaving
4 to go, (all of which are inside hash_table.c).

glsl_type: Add a talloc-based new

And hook it up at the two sites it's called.

Note that with this change we still don't use glsl_type* objects as
talloc contexts, (see things like get_array_instance that accept both
a talloc 'ctx' as well as a glsl_type*). The reason for this is that
the code is still using many instance of glsl_type objects not created
with new.

This closes 3 leaks in the glsl-orangebook-ch06-bump.frag test:

total heap usage: 55,623 allocs, 55,618

Leaving only 5 leaks to go.

Close memory leaks in glsl_type (constructor and get_array_instance)

Add a talloc ctx to both get_array_instance and the glsl_type
constructor in order to be able to call talloc_size instead of
malloc.

This fix now makes glsl-orangebook-ch06-bump.frag 99.99% leak free:

total heap usage: 55,623 allocs, 55,615

Only 8 missing frees now.

Close memory leak in lexer.

Simply call talloc_strdup rather than strdup, (using the talloc_parent
of our 'state' object, (known here as yyextra).

This fix now makes glsl-orangebook-ch06-bump.frag 99.97% leak free:

total heap usage: 55,623 allocs, 55,609 frees

Only 14 missing frees now.

main: Close memory leak of shader string from load_text_file.

Could have just added a call to free() to main, but since we're using
talloc everywhere else, we might as well just use it here too. So pass
a new 'ctx' argument to load_text_file.

This removes a single memory leak from all invocations of the
standalone glsl compiler.

s_symbol: Close memory leak of symbol name.

Easily done now that s_expression is allocated with talloc. Simply
switch from new to talloc_strdup and the job is done.

This closes the great majority (11263) of the remaining leaks in the
glsl-orangebook-ch06-bump.frag test:

total heap usage: 55,623 allocs, 55,546 frees
(was 44,283 frees)

This test is now 99.86% leak-free.

Close memory leak in ir_call::get_error_instruction.

By propagating a 'ctx' parameter through these calls.

This fix happens to have no impact on glsl-orangebook-ch06-bump.frag,
(since it doesn't trigger any errors).

Close memory leaks from generate_constructor_intro

By simply propagating a 'ctx' parameter through these function
calls. (We do this because these function are otherwise only receiving
an exec_list, which is not a valid talloc context.)

This closes 1611 leaks in the glsl-orangebook-ch06-bump.frag test:

total heap usage: 55,623 allocs, 44,283 frees
(was 42,672 frees)

exec_node: Add new talloc-based new()

And fix all callers to use the tallbac-based new for exec_node
construction. We make ready use of talloc_parent in order to get
valid, (and appropriate) talloc owners for everything we construct
without having to add new 'ctx' parameters up and down all the call
trees.

This closes the majority of the memory leaks in the
glsl-orangebook-ch06-bump.frag test:

total heap usage: 55,623 allocs, 42,672 frees
(was 14,533 frees)

Now 76.7% leak-free. Woo-hoo!

ast_node: Add new talloc-based new()

And use the talloc-based new for all of the ast objects created by the
parser.  This closes a lot of memory leaks, and will allow us to use
these ast objects as talloc parents in the future, (for things like
exec_nodes, etc.).

This closes 164 leaks in the glsl-orangebook-ch06-bump.frag test:

total heap usage: 55,623 allocs, 14,553 frees
(was 14,389 frees)

exec_node: Remove destructor from exec_node and all descendants.

Two of these destructors are non-empty, (s_symbol and s_list), so this
commit could potentially introduce memory leaks, (though, no additional
leaks are found in glsl-orangebook-ch06-bump.frag at least---perhaps
the current code is never calling delete on these classes?).

Going forward, we will switch to talloc for exec_node so we won't need
explicit destrcutors to free up any memory used.

glsl_symbol_table: Add new talloc-based new()

We take advantage of overloading of the new operator (with an
additional parameter!) to make this look as "C++ like" as possible.

This closes 507 memory leaks when compiling glsl-orangebook-ch06-bump.frag
when measured with:

valgrind ./glsl glsl-orangebook-ch06-bump.frag

as seen here:

total heap usage: 55,623 allocs, 14,389 frees
(was 13,882 frees before)

glsl2 main: Use talloc to allocate _mesa_glsl_parse_state

This is a short-lived object. It exists only for the duration of the
compile_shader() function, (as opposed to the shader and whole_program
which live longer).

The state is created with the same talloc parent as the shader, so
that other allocation can be done with talloc_parent(state) as the
owner in order to attach to a long-lived object.

glsl2 main: Use talloc to allocate whole_program struct.

This way, whole_program can be our top-level talloc context object,
allowing us to free the lot with a single talloc_free in the end.

ast_node: Remove empty destructor.

This wasn't serving any purpose. So delete it.

preprocessor: Initialize a potentially uninitialized variable.

My current reading of the relevant static functions suggests that last
is never used without being uninitialized, (we only use it if the
expansion function returned non-NULL and the expansion functions
always set it before returning non-NULL).

Apparently gcc isn't coming to the same conclusion. Initializing this
to NULL nicely quites gcc and will guarantee a nice, early segfault if
my anaylsis turns out to be wrong.

preprocessor: Remove dead code _token_list_length

As gcc noticed, this function is not currently being used. Good-bye.

preprocessor: Remove dead code _string_list_append_list

As gcc noticed, this function is not currently being used. Good-bye.

configure: Ensure that config.h can be safely included multiple times.

Use AH_TOP and AH_BOTTOM macros so that the standard include guard
mechanisms are emitted by autoheader into the generated config.h file.

configure: Remove some dead code.

This block of code is useless because a (nearly-equivalent) assignment
is made immediately after. The only difference is the omission of
-Wunreadchable-code in the assignment being used. Presumably, that was
intended to be -Wunreachable-code (without the first 'd'), but since
this hasn't been being used we just drop it.

Fix typos of "variable" as "varaible"

One of these was just in a comment. But ther other was in an enum
tag, (which is apparently not being used anywhere yet).

ir_variable: Add some missing initialization to the constructor.

Thanks to valgrind for noticing this problem.

Fix double usage of the post-inc/dec's temporary pre-inc/dec copy.

Fixes CorrectSwizzle3.frag.

Avoid using the RHS of an assignment twice.

This would fix double-evaluation of assignment RHS expressions,
including possible side effects.

get_lvalue_copy doesn't need all the checking of do_assignment().

ast_to_hir: Clone LHS derefs of assignment expressions.

ir_function_inlining: Allow inlining of loops and conditionals.

The new cloning code handles them.

Add a virtual clone() method to ir_instruction.

This will be used by function inlining, the linker, and avoiding double
usage of the LHS deref chains in ++, *=, and similar operations.

Avoid using the same ir_constant 0.0 multiple times in mat constructors.

glcpp: Support line continuations within preprocessor directives.

Fixes CorrectPreprocess5.frag.

glcpp: Make standalone binary use preprocess().

This prevents the two code paths from getting out of sync.  Also, future
work will need the shader source as a string anyway.

Unfortunately, this copies and pastes load_text_file from main.cpp, with
small changes (support for reading from stdin, talloc).

glcpp: Fix "dangerous trailing context" warning.

Flex couldn't be sure whether "def" and "ndef" were part of the #ifdef
and #ifndef patterns or the trailing context of the #if pattern.

Remove comment support from the main lexer.

Now handled by the preprocessor.

glcpp: Recognize plain "//" as a comment.

Found in glsl-orangebook-ch06-bump.(frag|vert).  This was resulting in
the comments getting passed through to the main compiler's lexer.

Generate errors for empty constructors instead of asserting

This causes the following tests to pass:

     glslparsertest/glsl2/constructor-10.vert

linker: Update some comments, remove a couple FINISHMEs

linker: Use InfoLog in assign_attribute_locations

Since the program is now passed in, refactor the parameter list to the
function as well.

linker: Refactor parameters to cross_validate_uniforms

linker: Write errors to info log instead of stdout

linker: Initial implementation of varying slot allocation

linker: Limit attribute allocation to MAX_VERTEX_ATTRIBS

linker: Support matrix and array vertex inputs

linker: Initial implementation of attribute slot allocation

Import some bits Mesa's mtypes.h

Import gl_program_parameter and gl_program_parameter_list types from Mesa

linker: Store the par-linked per-stage shaders in the glsl_program

linker: Initial implementation of uniform slot allocation

Import gl_uniform and gl_uniform_list types from Mesa

ir_variable: Add query to get number of slots used by a variable

glsl_type: Add method to get number of slots used by a type

linker: Document what remains to be done

ir_variable: Set locations for shader built-in variables

ir_variable: Track the location of uniforms, varings, attributes, etc.

linker: Initial implementation of interstage input / output validation

ir_variable: Add method to get string representing interpolation qualifier

linker: Initial implementation of interstage uniform validation

ir_constant: Add method to determine if two constants have the same value

Fix multiple usage of an rvalue in constructor component splitting.

Store the thing in a variable and deref it for each swizzle if we have to.

Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>

ir_validate: Use callback functionality in ir_hierarchical_visitor

ir_hierarchical_visitor: Add generic callback functionality

ir_validate: New pass for checking our invariants.

ir: Give ir_instruction a print visitor helper.

This avoids spamming each file with includes of ir_print_visitor.h
because someone was doing debugging at some point, and is less typing
when doing debugging.

Hook up texturing in the hierarchical visitor.

Include stdio.h and stdlib.h everywhere, and don't cook our own #define NULL.

Add missing build products to gitignore

glcpp: Initialize error state.

glcpp: Accept #elif without an expression if the expression doesn't matter.

Issue a warning.  nVidia's compiler seems to accept this; apparently
GCC < 4.4 did as well: http://gcc.gnu.org/gcc-4.4/porting_to.html

glcpp: Print to the main compiler's infolog, not stdout.

Use yy_scan_string and stop caring about shader->SourceLen.

We had to call strlen on the preprocessed source, which seemed a bit
pointless; also, we updated shader->SourceLen but not shader->Source,
which was even more confusing.  Just leave both untouched.

glcpp: Rework handling of "defined" operator.

It's now done in the grammar, and as a result, can easily handle
parenthesis.  defined ( identifier ) is now supported.

Fixes glcpp/tests/065-if-defined-parens.c.

glcpp/tests: Add a test for #if defined (identifier)

Previously we only tested #if defined identifier (without parenthesis).

glcpp: Ignore junk tokens at end of #ifdef/#ifndef (with warning)

Both nVidia's compiler and GCC accept this.
Fixes CorrectPreprocess11.frag.

glcpp: Add glcpp_warning for printing warnings to the info log.

glcpp: Add boolean 'error' flag.

We used to check if the info log is non-empty, but when we print
warnings, this will no longer be valid.

glcpp: Rename "errors" to "info_log."

Eventually, we'll want to be be able to print out warnings as well.

glcpp: Don't include newlines as part of #version-passthrough.

Fixes glcpp/tests/064-version.c.

glcpp/tests: Add a test for #version followed by #define.

This isn't really a C file, but...that's probably okay.

glcpp: Fix line and column numbering.

Lines were off by one, and column numbering was completely daft.

glcpp: Remove calls to exit().

Calling exit() would be really bad once integrated into mesa.  Even in
the standalone binary, we want to print the error log first.

Since each case already flags an error, compilation will still fail,
but it may go on (with something fudged) and generate more errors.

glcpp: Add line locations to "Unterminated #if" error message.

glcpp: Add line locations to various mismatched #if error messages.

glcpp: Add line locations to "reserved name" error messages.

glcpp: Print locations in error messages where possible.

glcpp: Introduce new glcpp_error function.

glcpp: Set locations on tokens.

glcpp: Set line locations in the lexer.

glcpp: Add plumbing to support line locations.

glcpp: Add %error-verbose.

glcpp: Actually support #ifdef and #ifndef.

Strangely, the lexer never created these tokens, even though the parser
already had code to handle them.

glcpp: Build a reentrant parser.

glcpp: Print errors on stdout instead of stderr (non-standalone version).

Otherwise, piglit marks tests as "warn" when the shader was (correctly)
failing.

glcpp/tests: Add extra newline at the end of expected output.

This newline at EOF is harmless and generated by the previous commit.

glcpp: Handle missing newline at EOF.

Fixes CorrectFuncOverload.vert.

glcpp: Complain about unrecognized directives.

glcpp: Pass #version, #extension, and #pragma directives through unchanged.

Let the main compiler's lexer/parser handle them.

Make the main compiler call the preprocessor.

By using a single function, the main compiler doesn't need to include
glcpp.h, which currently has a lot of details about the preprocessor
internals.  In particular, this prevents the two yacc grammars from
seeing each other, which would be rather messy to sort out.

Complain and exit if the given shader file doesn't exist.

glcpp: Add support for lexing from a string.

The standalone binary still reads from stdin, however.

glcpp: Output to a buffer and error log rather than directly printing.

In the standalone case, simply print the buffers when done.

glcpp: Fix a case of == where = probably ought to be.

Caught by a GCC warning.