glcpp: Add static keyword to several functions in the parser.

This quiets warnings about missing declarations otherwise.

glcpp: Avoid warnings in generated flex code.

We define the YY_NO_INPUT macro to avoid one needless function being
generated.

for the other needless functions, (yyunput and yy_top_state), we add a
new UNREACHABLE start condition and call these functions from an
action there. This doesn't change functionality at all, (since we
never enter the UNREACHABLE start condition), but makes the compiler
stop complaining about these two functions being defined but not used.

glcpp-lex: Declare some generated functions to eliminate compiler warnings.

It's really a bug in flex that these functions are generated with neither
a declaration nor the 'static' keyword, but we can at least avoid the
warnings this way.

glcpp: Fix support for nested #ifdef and nested #ifndef

Previously, if the outer #ifdef/#ifndef evaluated to false, the inner
directive would not be parsed correctly, (the identifier as the subject
of the #ifdef/#ifndef would inadvertently be skipped along with the other
content correctly being skipped).

We fix this by setting the lexing_if state in each case here.

We also add a new test to the test suite to ensure that this case is tested.

glcpp: Support #if(expression) with no intervening space.

And add a test case to ensure that this works.

glcpp: Fix use-after-free error from #undef directive.

By taking advantage of the recently-added hash_table_remove function.

With this change, all existing tests are now valgrind-clean.

hash_table: Add new hash_table_remove function.

To allow for the removal of a single element from a hash table.

glcpp: Make test suite test for valgrind cleanliness.

As it turns out, 4 of our current tests are not valgrind clean,
(use after free errors or so), so this will be helpful for
investigating and fixing those.

glcpp: Make test suite report final count of passed/total tests.

And report PASS or FAIL for each test along the way as well.

Build a standalone glcpp binary.

This is convenient for testing the preprocessor independent of the rest of
mesa, (just run glcpp-test in the src/glsl/glcpp/tests).

glcpp: Delete copies of hash_table.c, hash_table.h, and other headers.

These were only ever intended to exist in the original, standalone
implementation of glcpp, (with the idea of dropping them as soon as
the code moved into mesa). The current build system wasn't compiling
this C file, but the presence of the header files could cause problems
if the two copies diverge in the future.

We head those problems off by deleting al of these redundant files.

glsl2: Fix handling of out values in function inlining.

The parameters[i] is our inlined variables representing the
parameters, so they are always ir_var_auto.  Walk the signature params
in handling "out" values like we do for "in" values to find the mode.

Fixes (with the previous 2 commits):
glsl1-function call with in, out params
glsl1-function call with inout params

glsl2: Don't mark a variable as constant if it was used as an out param.

glsl2: Always insert function calls into the instruction stream.

If they have a return value, this means putting it into a temporary
and making a deref of the temp be the rvalue, since we don't know if
the rvalue will be used or not.

glsl2: Add definitions of the builtin constants present in GLSL 1.10.

Fixes:
glsl1-built-in constants

glsl2: Fix asin() implementation.

I'd flipped around the order of two operations in paren-balancing
adventures, and left out the multiply by sign(x) required for negative x.

Fixes:
glsl1-acos(vec4) function
glsl1-asin(vec4) function
glsl1-atan(vec4) function

glsl2: notEqual() produces a boolean value, not the base type of the args.

Fixes:
glsl1-vector relational (bvec2 ==,!=)
glsl1-vector relational (vec4 !=)

glsl2: Constant-fold assignment conditions.

glsl2: Don't validate IR if there were compilation errors

ir_to_mesa: Fix swizzled writemasks with swapped component ordering.

I hadn't noticed you could do this, but glsl1 tests caught it.  Fixes:
glsl1-Swizzled writemask
glsl1-Swizzled writemask (2)
glsl1-Swizzled writemask (rgba)
glsl1-Swizzled writemask (stpq)

linker: Remove the FINISHME comment for intrastage linking

linker: Remove redundant check for 'main' in shaders

This is now handled in link_intrastage_shaders.

linker: Track and validate GLSL versions used in shaders

glsl2: Use Elements macro

linker: Recursively resolve function calls in imported functions

linker: look up function signatures during linking instead of using callee

Instead of using ir_call::callee, search for the signature in the
linked shader.  This will allow resolving calls from functions
imported from other shaders.  The ir_call::callee pointer in the
imported function will still reference a signature in the original shader.

linker: Pull find_matching_signature out of call_link_visitor

The list of shaders to search needs to be provided as an explicit
parameter to support coming changes.  At that point there is no reason
for it to be in the class.  Also, fix some of the 'const' decorators.

glsl2: Explicitly walk lists in ir_function::parameter_lists_match

Give ir_function::parameter_lists_match_exist similar treatment.  Make
the parameters const, and propogate the constness as far as it will
trivially go.

linker: Add comment about bug in initializer handling

linker: First bits of intrastage, intershader function linking

This handles the easy case of linking a function in a different
compilation unit that doesn't call any functions or reference any
global variables.

ir_function_signature: Make actual_parameters public

linker: Remove some unnecessary includes

exec_list: Fix foreach_list_safe.

It now works correctly when nodes are removed, as it was originally
intended to do; it no longer processes nodes added to the list before
the current node, nor those added immediately after the current node.

This matches the behavior of Linux's list_for_each_safe.

linker: Use foreach_list_safe in move_non_declarations

The node being processed may be removed from the list and put in a
different list.  Not using the safe version caused list processing to
change streams after moving a node.

linker: Move global instructions from the linked shader first

For the shader containing 'main', use the linked shader (i.e., the
clone of the original shader that contained main) as the source for
global instructions to move into main.

glsl2: Fix lexing of octal values, including "0".

When faced with a constructor like 'ivec4(0, 2, 0, 0)', we would
manage to get a value of 2 instead of 0 for the first "0".  Usually 2
characters past "0" would point at some junk and lex as 0 anyway.

Fixes glsl-octal and glsl-unused-varyings.

glsl2: Fix the expression type for atan's pi * sign(y).

Fixes CorrectFunction.vert.

i915: Ask the compiler to flatten out all the if statements that it can.

glsl2: Add a pass for converting if statements to conditional assignment.

This will be used on 915 and similar hardware of that generation.

glsl2: Give IR nodes a type field.

This is a big deal for debugging if nothing else ("what class is this
ir_instruction, really?"), but is also nice for avoiding building a
whole visitor or an if (node->as_whatever() || node->as_other_thing())
chain.

ir_to_mesa: Do validation on the IR tree.

ir_to_mesa: Don't do lowering passes on an errored-out shader.

ir_to_mesa: Rename struct temp_entry, which is used for all variables now.

ir_to_mesa: Add support for function calls.

Unlike the previous compiler, in this case we emit only one copy of
the function regardless of how many times it's called.

glsl2: Remove the const disease from function signature's callee.

glsl2: Make cross() be an expression operation.

ARB_fp, ARB_vp, Mesa IR, and the 965 vertex shader all have
instructions for cross.  Shaves 12 Mesa instructions off of a
66-instruction shader I have.

glsl2: Fix warning from always-false assert not being known to not return.

ast_function: Actually do type conversion on function arguments.

exec_list: Add a new replace_with method.

Refresh autogenerated file builtin_function.cpp.

glsl2/builtins: Rework clamp to use scalar/vector combinations.

glsl2/builtins: Rework min/max to use scalar/vector combinations.

ir_constant_expression: Add support for ir_binop_mod.

ir_constant_expression: Add support for ir_binop_min and ir_binop_max.

These now work on scalar/vector combos. Semantically, if a is a scalar,
min(a, vec2(x,y)) == vec2(min(a,x), min(a,y))

ir_constant_expression: Add support for ir_binop_pow.

ir_constant_expression: Add support for ir_unop_cos.

ir_constant_expression: Add support for ir_unop_sin.

ir_constant_expression: Add support for ir_unop_floor.

ir_constant_expression: Add support for ir_unop_ceil.

ir_constant_expression: Add support for ir_unop_trunc.

This uses a C99 function.

ir_constant_expression: Add support for ir_unop_log2.

This uses a C99 function.

ir_constant_expression: Add support for ir_unop_exp2.

This uses a C99 function.

ir_constant_expression: Add support for ir_unop_sign.

ir_constant_expression: Remove bogus assert in ir_unop_abs case.

abs is defined for integral types; it's even implemented.

glsl2: Remove ir_program bong hits.

ir_to_mesa: Add convenience function for opcodes with no src/dst reg.

Most of flow control is like this.

glsl2: When linking makes a variable not a varying output, make it ir_var_auto.

This almost fixes glsl-unused-varying, except that the used varying
gets assigned to the first varying slot (position).

ir_to_mesa: Add support for variable array indexing of builtin varyings.

That is to say, gl_TexCoord[i] now works, fixing glsl-texcoord-array
on swrast.

ir_to_mesa: Add support for array dereferences on the LHS of assignments.

The big change is to delay address reg setup until the instruction
that needs the deref.  It was hard to use the deref chain support for
the LHS because it does the copy of the dereffed value to a temporary
(to avoid problems when two src regs are array derefs), so we wouldn't
haev a pointer to actual storage in the end.

Fixes glsl-vs-arrays on swrast.

glsl2: Remove unnecessary casts of clone return values

ir_to_mesa: Rely on ir_mat_op_to_vec for matrix multiplication support.

glsl2: Add matrix multiplication to ir_mat_op_to_vec.

ir_to_mesa: Emit OPCODE_MAD when we find an ADD of a MUL.

Bug #27914.

glsl2: Flatten expression that appear as the parameters of ir_call as well.

glsl2: Flatten expressions that appear as the children of ir_return as well.

linker: Merge global-scope instructions into main

Find instructions in all shaders that are not contained in a function
(i.e., initializers for global variables).  "Move" these instructions
to the top of the main function in the linked shader.  As a
side-effect, many global variables will also be copied into the linked
shader.

linker: Detect the shader that contains "main" during intrastage linking

ir_function: Make matching_signature not return const

The linker needs to use this function to get specific function signatures, but
it also needs to modify the returned signature.  Since this method isn't itself
const (i.e., const this pointer), there is no value in making a const and
non-const version.

linker: Implement first bits of intrastage linking

This currently involves an ugly hack so that every link doesn't result
in all the built-in functions showing up as multiply defined.  As soon
as the built-in functions are stored in a separate compilation unit,
ir_function_signature::is_built_in can be removed.

linker: Refactor cross_validate_uniforms into cross_validate_globals

The later, more generic function will be used in the intra-stage linker.

glsl2: Use a better talloc context for ir_expression_flattening.

The instruction can be hung off of any other in the tree, even if the
other one will be deleted, since it'll get stolen to the shader's
context later if it's still live.

glsl2: Add support for variable vector indexing on the LHS of assignments.

Fixes glsl-vs-vec4-indexing-3.

glsl2: Fix copy propagation in the presence of derefs in array indexes.

We would clear the in_lhs flag early, avoiding copy propagation on the
array index variable (oops) and then copy propagating on the array
variable (ouch).  Just avoid all copy propagation on the LHS instead.

ir_to_mesa: Add support for dereferencing matrices from arrays.

ir_validate: Also perform usual checks on ir_dereference_variable nodes

ir_validate: Validate that varibles are declared before used in IR

linker: Stub-out intrastage linker

Make shader_api.h be C++ friendly

ir_validate: Additional function related invariant checks

Add two invariant checks related to functions and function signatures:

1. Ensure that function definitions (ir_function) are not nested.

2. Ensure that the ir_function pointed to by an ir_function_signature
is the one that contains it in its signatures list.

ir_function_signature: Add method to get the function owning a signature

There is no setter function, the getter returns a constant pointer,
and ir_function_signature::_function is private for a reason.  The
only way to make a connection between a function and function
signature is via ir_function::add_signature.  This helps ensure that
certain invariants (i.e., a function signature is in the list of
signatures for its _function) are met.

glsl2: Add utility function clone_ir_list

ir_call: Add method to set the function signature being called

glsl2: Implement ir_function::clone and ir_function_signature::clone

glsl2: Move temp declaration to correct side of if-statement in IR

glsl2: Add missing fields in ir_variable::clone

glsl2: Add declarations for temporaries to instruction stream

Temporary variables added for &&, ||, and ?: were not being added to
the instruction stream.  This resulted in either test failures or
Valgrind being angry after the original IR tree was destroyed by
talloc_free.  The talloc_free caused the ir_variables to be destroyed
even though they were still referenced.

glsl2: Store the gl_type of the array's element type in the array.

Fixes glsl-fs-uniform-array-1, glsl-vs-uniform-array-1, and the -2
tests on software.

Revert "ir_to_mesa: Add support for adding/subtracting matrices."

This reverts commit b4d0c0e0ee983ee614b047799c3e01221a353c98.
Now that ir_mat_op_to_vec is landed, this change is no longer needed.

glsl2: Add a new pass at the IR level to break down matrix ops to vector ops.

This will be used by the Mesa IR and likely most HW backends, as it
allows other optimizations to occur that might not otherwise.

Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.

glsl2: Flatten out expressions that are the child of an assignment rhs.

This feels a little odd, but it will be useful for ir_mat_to_vec,
where I want to see a plain assignment of the expression to a
variable, not to a writemasked array dereference with a call as the
array index.