builtins: Add support for reflect().

Fixes glsl-orangebook-ch06.frag parsing.

builtins: Add ftransform().

Fixes glsl-orangebook-ch06-bump.vert.

Allow arrays of floats as varyings.

The comment just above the code said arrays were OK, then it didn't
handle arrays.  Whoops.  Partially fixes CorrectUnsizedArray.frat.

gl_Normal is a vec3 not a vec4.

Fixes CorrectSwizzle1.vert.

builtins: Add the mix(gentype, gentype, float) variant.

The broken-in-mesa Regnum Online shader now parses, except for its
preprocessor usage.

Handle GLSL 1.20 implicit type conversions.

We were nicely constructing a new expression for the implicit type
conversion, but then checking that the previous types matched instead
of the new expression's type.  Fixes errors in Regnum Online shaders.

builtins: Add atan().

builtins: Add asin().

ir_constant_expression: Handle several floating point unops.

Cleans up a bunch of pointless operations in a GStreamer fragment shader.

ir_constant_variable: New pass to mark constant-assigned variables constant.

This removes a bunch of gratuitous moving around of constant values
from constructors.  Makes a shader ir I was looking at for structure
handling almost readable.

ir_constant_folding: Look at instructions in functions.

This was broken in the ir_label -> ir_function rework.

ir_swizzle_swizzle: Reduce swizzle chains to a single swizzle.

ir_vec_index_to_swizzle: Pass to convert indexing of vectors to swizzles.

This should remove the burden of handling constant vector indexing
well from backend codegen, and could help with swizzle optimizations.

ir_expression_flattening: Handle flattening values out of swizzles, too.

Fixes an uninlined normalize() in CorrectSwizzle2.vert.

ir_expression_flattening: Fix breakage from hierarchichal visitor.

Similar to other situations where the visitor pattern doesn't fit, in
this case we need the pointer to the base instruction in the
instruction stream for where to insert any new instructions we
generate (not the instruction in the tree we're looking at).  By
removing the code for setting the base_ir, flattened expressions would
end up, for example, before the function definition where they had appeared.

Reimplement ir_function_inlining_visitor using ir_hierarchical_vistor

Reimplement ir_copy_propagation_visitor using ir_hierarchical_vistor

Reimplement ir_expression_flattening_visitor using ir_hierarchical_vistor

ir_reader: Read record_refs.

Also changes the print visitor to not emit extraneous parenthesis.

ir_reader: Fix reading of array deferences and correct error messages.

Previously, the syntax was (array_ref <variable name> <index>), but the
subject is now a general rvalue (not a name).  In particular, it might
be a (var_ref ...).

Also, remove "expected ... or (swiz)" from error messages; swiz is not
allowed inside a var_ref.

Fix setting the maximum accessed array element

Array dereferences now point to variable dereferences instead of
pointing directly to variables.  This necessitated some changes to the
way the variable is accessed when setting the maximum index array element.

ir_dereference::mode is no longer used, kill with fire

Refactor whole-variable assigment checking into member function

Refactor ir_dereference data fields to subclasses

Replace open coded deref navigation with hierarchical visitors

Refactor ir_dereference support for ir_visitor

Move the accept method for visitors from ir_dereference to the derived
classes.

Refactor ir_dereference support for ir_hierarchical_visitor

Move the accept method for hierarchical visitors from ir_dereference
to the derived classes.  This was mostly straight-forward, but I
suspect that ir_dead_code_local may be broken now.

Begin refactoring ir_dereference

Create separate subclasses of ir_dereference for variable, array, and
record dereferences.  As a side effect, array and record dereferences
no longer point to ir_variable objects directly.  Instead they each
point to an ir_dereference_variable object.

This is the first of several steps in the refactoring process.  The
intention is that ir_dereference will eventually become an abstract
base class.

Use ir_rvalue::variable_referenced instead of open coding it

ir_visit_tree is no longer used, remove ir_visit_tree.{cpp,h}

Reimplement kill_for_derefs using ir_hierarchical_vistor

The output of all test cases was verified to be the same using diff.

Reimplement has_call_callback using ir_hierarchical_vistor

This has the added advantage that it will stop traversing the tree as
soon as the first call is found.

The output of all test cases was verified to be the same using diff.

Reimplement ir_if_simplicifation_visitor using ir_hierarchical_vistor

The output of all test cases was verified to be the same using diff.

Make visit_list_elements safe against node removals

Reimplement ir_function_can_inline_visitor using ir_hierarchical_vistor

The output of all test cases was verified to be the same using diff.

Reimplement ir_dead_code_visitor using ir_hierarchical_vistor

The output of all test cases was verified to be the same using diff.

Add ir_hierarchical_visitor base class and associated infrastructure

This type of visitor should eventually replace all or almost all
current uses of ir_visitor.

Replace find_dead_code with visit_exec_list

find_dead_code appears to be an open-coded version of visit_exec_list
that was implemented first.

Use ir_rvalue::variable_referenced instead of open-coding it

Add ir_rvalue::variable_referenced

Refresh autogenerated builtin_function.cpp.

Implement "tan" builtin.

Implement "sin" and "cos" builtins via new expression operators.

Implement "cross" builtin.

Implement "fract" builtin.

Implement "sign" builtin via a new expression operator.

Implement "smoothstep" builtin.

Implement "step" builtin.

Integrate generate_builtins.pl into the build process.

make will now regenerate builtin_function.cpp whenever you
change/add/remove files in the builtins/* folders.

Replace old builtin_function.cpp with new autogenerated one.

Add a perl script to generate builtin_function.cpp.

Usage: ./builtins/tools/generate_builtins.pl > builtin_function.cpp

Fix bogus expression typing in various builtins.

Initial commit of IR for builtins.

These were all generated by Eric's existing builtin_functions.cpp; I split
the uvec* signatures out of 110 into the 130 folder.

ir_reader: Set function signatures as defined.

FS gl_FragCoord and and gl_FrontFacing are FS ins, not outs.

Fix function call parameter printer to omit extraneous leading comma

The output of all test cases was verified to be the same using diff.

Replace many uses of foreach_list with foreach_list_typed

exec_list: Add foreach_list_typed and foreach_list_typed_const

These variations are parameterized by the type of the nodes in the
list.  This enables skipping the explicit usage of exec_node_data in
the loop body.

Convert ast_node use of simple_node to exec_list and exec_node

exec_list: Add simpler exec_list for-each macros

exec_list: Add macros to get ptr to structure containing a node

This has some ugly hackery to work-around C++ fail.  I have
emperically determined that it works in all the cases that matter.

Loop bodies, then-statements, and else-statements are not lists

The statement making up a loop body, a then-statement, or an
else-statement are single nodes.  If the statement is a block, the
single node will be an ast_compound_statement.  There is no need to
loop at the top level when processing these statements.

Remove unnecessary include of simple_list.h

Store AST function call parameters in expressions

Previously the list of function call parameters was stored as a
circular list in ast_expression::subexpressions[1].  They are now
stored as a regular list in ast_expression::expressions.

Move optimization pass prototypes to a single header.

ir_dead_code_local: Remove redundant assignments within basic blocks.

This cleans up a bunch of junk code in some of the GLSL parser tests,
and could potentially help real-world too (particularly after copy
propagation has happened).

ir_visit_tree: Make sure we visit dereference targets, too.

Found this with the local dead code pass, which never saw variable
dereferences occurring.

ir_copy_propagation: Fix up the doxygen about the file.

ir_copy_propagation: Return true if we optimized out any assignments.

This may trigger other optimization phases to make more progress themselves.

ir_copy_propagation: Handle swizzles and array derefs on LHS of assign.

This improves the ACP to not get cleared when more complicated assignments
occur, cleaning up more redundant copies in programs.

ir_copy_propagation: New pass to rewrite dereferences to avoid copies.

This is pretty basic.  Right now it only handles pure assignments --
same type on each side, no swizzling, and only within basic blocks.

ir_to_mesa.cpp: Fix missing types on some ir_swizzles.

Debugging this took forever as I only looked at constructors in ir.cpp
to find who wasn't setting up ->type.  I dislike hiding code (as
opposed to prototypes and definitions) in C++ header files, but in
this case I have only myself to blame.

Remove the pedantic C junk.

Mesa doesn't use pedantic ANSI C89, so I have no idea why we would.

Store warnings and errors in a parser state infolog.

Cleans up compile warning about unused state in _mesa_glsl_warning.  We
would want infolog handling roughly like this anyway.

Quiet warnings about ir_shader not being handled in places it's not needed.

Use the AM_SILENT_RULES when available.

glsl_lexer: Quiet warning about unused unput().

Merge branch 'fixes'

Use %p rather than %08x when printing pointers to fix compile.

Fix ir_return cloning to actually use the cloned subexpression.

This caused a nasty bug where the function inliner would create new
variables for each of the formal parameters, but the body would still
reference the old copies.

This was highly visible since the dead code eliminator (rightly) removed
the new declarations, leading to printed IR that referenced non-existent
variable names.

Fix incorrect comments in function inliner.

ir_dead_code: Fix segfault on handling a return statement with no value.

Track and print user defined structure types

IR print visitor: Move logic for printing the whole program to _mesa_print_ir

IR print visitor: Just print the name of structures

Treat structure types like other non-array types.  We'll have to print
the structure defintion elsewhere.

ir_function_inlining: Handle inlining of structure dereferences.

Correctly handle remapping of array dereferences if ->var is a variable.

Begin handling some varieties of invalid declarations

Reject conflicting struct declarations, generate struct constructor

glsl_type::generate_constructor_prototype now generates the function too

Also, change the name of the method to generate_constructor.

Always return a value from ast_type_specifier::hir

Support structures in glsl_type::generate_constructor_prototype

Implement structures and arrays in ir_dereference::is_lvalue

Ensure that structure fields have non-NULL types

Ensure that anonymous structures have non-NULL names

Convert structure field dereferences to HIR

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.