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

Call glsl_type::get_instance correctly: the number of rows must be at least 1

This causes the following tests to pass:

    shaders/glsl-tex-mvp.vert

Eat whitespace while in the PP state

Partially fix comment handling in preprocessor directives.

Multi-line /* */ comments are still broken.  I think this will wait to
be fixed until we have a real preprocessor.

Add support for bool to ir_equal and ir_nequal constant handling

Add gl_ClipDistance in fragment shader

Generate correct IR for do-while loops

Previously the same code was generated for a while loop and a do-while
loop.  This pulls the code that generates the conditional break into a
separate method.  This method is called either at the beginning or the
end depending on the loop type.

Reported-by: Kenneth Graunke <kenneth@whitecape.org>

Process ast_jump_statement into ir_loop_jump

Specifically, handle 'break' and 'continue' inside loops.

This causes the following tests to pass:

    glslparsertest/shaders/break.frag
    glslparsertest/shaders/continue.frag

Add dynamic cast for ir_loop

Begin tracking the nesting of loops and switch-statements

Use switch based on mode in ast_jump_statement::hir

Add some newlines when printing ir_loop instructions

Process ast_iteration_statement into ir_loop

This causes the following tests to pass:
     glslparsertest/shaders/dowhile.frag
     glslparsertest/shaders/while.frag
     glslparsertest/shaders/while1.frag
     glslparsertest/shaders/while2.frag

Add ir_loop_jump to represent 'break' and 'continue' in loops

Add ir_loop to represent loops

This touches a lot of files because everything derived from ir_visitor
has to be updated.  This is the primary disadvantage of the visitor pattern.

Add some linebreaks in the ir_print_visitor of if statement bodies.

Make constant folding descend into if statements.

Descend down the tree in more locations in constant folding.

Perform constant folding on array indices.

Replaces a constant var deref with a constant value in CorrectParse1.frag.

Add float/int conversion to ir_constant_expression.cpp.

Gives CorrectParse2.frag one more constant folding.

Handle constant expressions using derefs of const values.

Fixes CorrectParse1.frag and makes for a ton of folding in
CorrectParse2.frag.

Fold constant expressions in if conditionals.

Fixes up 3 more expressions in CorrectParse2.frag.

Add support for =, != to ir_constant_expresion.cpp

This results in constant folding of one more expression in CorrectParse2.frag.

Add ir_constant_expression.cpp support for <, >, <=, >=.

This results in folding one more constant expression in CorrectParse2.frag.

Add a constant folding optimization pass.

Add definition of gl_ClipDistance[]

Set lower bound on size implied by whole-array assignment

When an unsized array is accessed with a constant extension index this
sets a lower bound on the allowable sizes.  When the unsized array
gets a size set due to a whole-array assignment, this size must be at
least as large as the implied lower bound.

This causes the following tests to pass:

    glslparsertest/glsl2/array-16.vert

Allow dereference of vectors and matrices with []

This causes the following tests to pass:
     glslparsertest/glsl2/matrix-11.vert
     glslparsertest/glsl2/matrix-12.vert
     glslparsertest/shaders/CorrectParse2.vert
     glslparsertest/shaders/CorrectSwizzle2.frag

Set correct type for ir_dereference of a matrix or a vector

Propagate sizes when assigning a whole array to an unsized array

Track whether whole-arrays are assignable

In GLSL 1.10 this was not allowed, but in GLSL 1.20 and later it is.

This causes the following tests to pass:

    glslparsertest/glsl2/array-09.vert
    glslparsertest/glsl2/array-13.vert

Whole structures are assignable

Whole arrays are assignable in GLSL 1.20 and later, but it's not clear
how to handle that within the IR because the IR is supposed to be
shading language version agnostic.

Use glsl_type::element_type to get the type of array elements

Ensure that 'in' and 'inout' formal parameters are valid lvalues

This causes the following tests to pass:

    glslparsertest/shaders/function10.frag

Additional void parameter checks

If there is a void parameter it must not have a name, and it must be
the only parameter.

Require that function formal parameters have names

Make built-in gl_TexCoord available in vertex and fragment shaders

Fix matching of integer function parameters

This causes the following tests to pass:

    glslparsertest/shaders/function10.frag

Add bool/int conversion as IR operations.

Fixes constructor-09.glsl and CorrectParse2.frag.

Add conversion of bool to float as an IR operation to match int to float.

Add PASS / FAIL annotations to tests missing them.

This tricked my import of the tests into piglit.

Test that invalid quailfiers aren't used on variables in GLSL 1.10.

Allow array dereferences to be considered as lvalues.

Fixes glsl-vs-arrays.vert and glsl-vs-mov-after-deref.vert.
Regresses parser3.frag which was failing for the wrong reason.

Test for the type being different in parameter_lists_match.

Fixes CorrectFuncOverload.frag.

Add some more operations to ir_constant_expression.cpp.

Make ir_constant_expression.cpp support multi-component types.

Simplify ir_constant_expression.cpp by factoring operand computation out.

Reject non-float varyings.

Fixes varying2.frag.

Remove fake ir_binop_logic_not.  I think you meant ir_unop_logic_not.

Handle logic not in constant expression evaluation.