Add ir_dereference constructor for structure field dereferences

Add glsl_type::field_type

Query the type of a structure field

Begin converting structure definitions to IR

Use IDENTIFIER instead of TYPE_NAME for structure names

Since there is no track of which names are structure names during parsing,
TYPE_NAME cannot be produced by the lexer.  Use IDENTIFIER and let the AST
processor sort it out.

ir_reader: Slightly better error message when failing to read swizzles.

ir_reader: Don't print out the S-Expression.

It's no longer useful for debugging.

ir_reader: Read function calls.

ir_reader: Replace function prototypes with the definition.

Previously, we just created a new one, which was wrong.

ir_reader: Fix incorrect error message for expressions.

Make ir_read_error print out the given S-Expression, for context.

ir_reader: Fix for swizzles.

ir_reader: Preliminary work toward reading functions.

ir_reader: Perform a preliminary pass to scan for function prototypes.

ir_reader: Don't initialize globals, builtins, or constructors.

All of these are currently emitted as part of the IR, so by initializing
them, we actually end up with two copies.  For constructors, we may
eventually wish to avoid emitting them as part of the IR output.

Make ir_read_error set state->error.

ir_reader: Add support for "break" and "continue" in loops.

Includes threading the ir_loop * context through various functions.

ir_reader: Add initial loop support; doesn't yet support break/continue.

ir_reader: Add support for reading (var_ref ...) and (array_ref ...)

ir_reader: rvalues are instructions too!

ir_reader: Add support for reading conditionals: (if ...)

ir_reader: Add support for reading array types.

Also, constify glsl_type pointers; this was necessary to use
glsl_type::get_array_instance.

ir_reader: Add support for reading (return ...)

ir_reader: Add support for reading variable declarations.

It also now reads a list of instructions, as it should, rather than a
single rvalue.

Partial IR reader.

Currently reads assignments, constants, expressions, and swizzles.

Set language_version to 130 (the max currently supported) when reading IR.

This is necessary so _mesa_glsl_initialize_types can create appropriate
glsl_types and add them to the symbol table.

In the future, we'll want to set it to the max GLSL version supported by
the current driver.

Add stub ir_reader and new 'i' mode for reading IR rather than GLSL.

Add a simple S-Expression reader and printer.

Use "neg" when printing/reading unary negation rather than "-".

"-" is now only used for binary subtraction.

Move array of operator strings out of ir_print_visitor.cpp.

Also implement a reverse-lookup function for use in the IR reader.

Factor out parameter list replacement for later reuse.

Factor out parameter list matching from ast_function::hir for later reuse.

Unfortunately, we still have two kinds of matching - one, with implicit
conversions (for use in calls) and another without them (for finding a
prototype to overwrite when processing a function body).  This commit
does not attempt to coalesce the two.

Factor out qualifier checking code for later reuse.

ir_print_visitor: Re-parenthesize ir_call output.

ir_print_visitor: Print return type of ir_function_signatures.

ir_print_visitor: Print (constant bool (1)) instead of "true"

It might be better to simply handle "true" in the reader, but since
booleans normally aren't printed as "true" or "false", we may as well go
for consistency.

ir_print_visitor: Remove unnecessary parens around expression operands.

ir_print_visitor: Remove unnecessary parens around array size in types.

ir_print_visitor: Fix unclosed parenthesis in (call...

ir_print_visitor: Fix unclosed parenthesis in (assign ...

Also remove useless parens around subexpressions.

Add parens around printed IR so it's an official list of instructions.

ir_print_visitor: Remove unnecessary parenthesis around variable names.

Refactor ir_expression::get_num_operands.

A new static version takes an ir_expression_operation enum, and the
original non-static version now uses it.  This will make it easier to
read operations (where the ir_expression doesn't yet exist).

ir_print_visitor: print the type of expressions.

This can be useful for debugging - it allows us to see that the inferred
type is what we think it should be.  Furthermore, it will allow the IR
reader to avoid complex, operator-specific type inference.

ir_print_visitor: Remove unnecessary parenthesis around type names.

Parenthesis should only be present for compound types (i.e. arrays
or structures).  For atomic types, simply print the symbol.

Print full type for ir_constant instead of base and component count.

vec4 and mat2x2 have the same base type and number of components;
printing the full type allows us to distinguish the two.

Implement gl_TextureMatrix built-in uniform

Make private glsl_type singletons public

Initial implementation of #line

Does not handle comments in #line or line continuation characters, but
it should be good enough for now.

builtin_functions: Clean up compiler warning about unused name, instructions.

De-obfuscate some of builtin_types.h.

ir_function_inlining: Implement inlining in many more cases.

We still don't inline for control flow in the inlined function, and we
don't have any limits on what we will inline.

Put static pointers to vec[234]_types along with the static float_type.

Otherwise you have to type a lot of get_instance.

Replace builtin_types.h generation with the generated output.

The script to generate it was longer and more obfuscated than the output.

Fix the swizzling of vector constructors from scalars.

A refactor turned 'i' into '1', meaning everything writemasked into
the y component.

ir_function_inlining: Avoid NULL dereference on assignment conditions.

Zero-out the entire parser state structure at initialization

Among other things, this ensures that all of the extension flags are
initially disabled.

This causes the following tests to pass:

    glslparsertest/glsl2/draw_buffers-02.frag

Add missing 'else's to fix extension processing

The missing else-statements caused all of the extensions execpt
GL_ARB_texture_rectangle to be unsupported.

This causes the following tests to pass:

     glslparsertest/glsl2/draw_buffers-04.frag

Fix illegal (var_ref (array_ref ...)) in matrix constructors.

Actually emit temp declaration in vector comparison builtins.

Fix ir_dead_code for function refactoring.

Emit body for constructors in the right place.

Previously, the body of some vector constructors were added to the wrong
function signature, and the body of matrix constructors were just being
dumped in the main instruction stream.

Remove ir_label since it is no longer used.

Refactor IR function representation.

Now, ir_function is emitted as part of the IR instructions, rather than
simply existing in the symbol table.  Individual ir_function_signatures
are not emitted themselves, but only as part of ir_function.

Use ir_function_signature::function_name() rather than direct access.

Ensure that both parameter lists are the same length in function overloading.

Fixes new test function-05.glsl, where the second function has matching
parameter types, but less of them.

Add missing break statement

Remove dead code assignments and variable declarations.

This pass only works on assignments where the variable is never
referenced.  There is no code flow analysis, so it can't do a better
job of avoiding redundant assignments.

For now, the optimizer only does do_dead_code_unlinked(), so it won't
trim the builtin variable list or initializers outside of the scope of
functions.  This is because we don't have the visibility into other
functions that might get linked in in order to eliminate work on
global variables.

Mark some variables as having usage beyond the shader's scope.

This will be important to optimization passes.  We don't want to
dead-code eliminate writes to out varyings, or propagate uninitialized
values of uniforms.

While-loops also start a new scope.

Avoid generating ir_if for &&, || short-circuiting with constant LHS.

It was breaking constant expression detection for constant
initializers, i.e. CorrectParse2.frag, CorrectParse2.vert.

Add support for inlining calls done inside of expressions.

Make && and || only evaluate the RHS when the LHS requires it.

Add an ir_if simplification pass.

This is relatively simple at the moment, recognizing only constant
values, and not (for example) values that are restricted to a range
that make the branching constant.  However, it does remove 59 lines
from the printout of CorrectParse2.vert.

Check that the return type of function definition matches its prototype.

Doesn't fix any testcases, but fixes a FINISHME.

Check that function definition parameter qualifiers match proto qualifiers.

Fixes function9.frag.

Return the rvalue of a variable decl to fix while (bool b = condition) {}

Fix the type of gl_FogFragCoord.

Add an implementation of gentype-only clamp().

Add builtin implementations of vector comparison functions.

Fixes CorrectFunction1.vert, glsl-fs-notequal.frag.

Add support for builtin gentype mix(gentype a, gentype b)

Fixes glsl-fs-mix.frag, glsl-fs-mix-constant.frag.

Add buitlin functions for any(), all(), not().

Add builtin normalize() functions.

Fixes CorrectSqizzle2.vert.

Repeat the optimization passes until we stop making progress.

Add inlining support for array dereferences.

Inline functions consisting of a return of an expression.

Remove extraneous base-class constructor calls

Make function bodies rely on the parameter variable declarations.

Previously, generating inlined function bodies was going to be
difficult, as there was no mapping between the body's declaration of
variables where parameter values were supposed to live and the
parameter variables that a caller would use in paramater setup.
Presumably this also have been a problem for actual codegen.

Make dot() take the right number of args.

Fix the returns of builtin functions to actually return.

Put function bodies under function signatures, instead of flat in the parent.

This will let us know the length of function bodies for the purpose of
inlining (among other uses).

Clarify the types of various exec_list in ir.h

Treat texture rectangles as an extension that is enabled be default

Add support for GL_ARB_draw_buffers extension

Clean up error reporting in _mesa_glsl_process_extension

Add tracking for extension based warnings

Using '#extension foo: warn' instructs the compiler to generate a
warning when some feature of the extension 'foo' is used.  This patch
adds some infrastructure needed to support that for variables.

Similar changes will be needed for types and built-in functions.

Emit a warning when an unknown extension is used with #extension

Add _mesa_glsl_warning to emit warnings to the shader log

Begin processing #extension directive

Nowhere near complete.  It just parses correctly at this point.

Use _mesa_glsl_shader_target_name

Add utility function to get the name of a shader target