glsl2: Use bison command line option to set prefix

Bison version 2.3 doesn't seem to support %name-prefix in the source.

This should fix bugzilla #29207.

glsl2: Commit generated files changed by previous commit

glsl2: Emit error from lexer when illegal reserved word is encountered

Without this, the parser will generate obtuse, useless error
diagnostics when reservered word that are not used by the grammar are
encountered in a shader.

Fixes bugzilla #29519.

glsl2: Don't declare a variable called sig that shadows the other one

Accidentally having a variable called 'sig' within an if-statement
cause the higher scope 'sig' to always be NULL.  As a result a new
function signature was created for a function definition even when one
already existed from a prototype declaration.

Fixes piglit test case glsl-function-prototype (bugzilla #29520).

glcpp: Fix "unterminated if" diagnostic.

This was previously being appended to the output string *after* a copy
of the supposedly final string was made and handed to the caller. So
the diagnostic was never actually visible to the user.

We fix this by moving the check for an unterminated #if from
glcpp_parser_destroy to the calling function, preprocess.

This fixes the test case 083-unterminated-if.c.

glccp: Regenerate glcpp-parse.c

Due to a recent change to glcpp-parse.y.

glcpp: Add an explicit diagnostic for #if with no expression.

This is more clear than the previously-generated diagnostic which was
something confusing like "enexpected newline".

This change makse test 080-if-witout-expression.c now pass.

glcpp: Reword diagnostic for #elif with no expression

Rather than telling the user what to fix, the standard convention is to
describe what the detected problem is. With this change, test
081-elif-without-expression now passes.

glcpp: Add several tests for diagnostics.

Which are proving to be useful since some of these tests are not yet
acting as desired, (in particular, the unterminated if test is not
generating any diagnostic).

glcpp: Regenerate glcpp-lex.c

After a recent change to glcpp-lex.l

glcpp: Initialize line and column numbers to 1, not 0.

Error messages make more sense this way since the convention is for
the first line of a file to be numbered from 1, rather than 0.

glcpp-test: Capture the stderr output of the preprocessor.

This allows writing tests that verify diagnostics from the preprocessor.

configs: added -ltalloc to config files

osmesa: link with new libglsl.a lib

glsl2: added casts to silence warnings

glsl2: remove stray semicolon

glsl2: added casts to silence warnings

glsl2: add cast to silence warning

glsl2: remove stray semicolon

glsl2: move declarations before code

glsl2: remove trailing comma to silence warning

glcpp: Clean up intermediate file when test suite is interrupted.

The glcpp-test script was leaving around bogus *.valgrind-errors files if
a valgrind test was interrupted.

glcpp: Regenerate glcpp-parse.c

After a recent change to glcpp-parse.y

glcpp: Additional fixes for not evaluating skipped #if/#elif expressions.

This adds a couple of test cases to expand our coverage of invalid #if and
being skipped, (either by being nested inside an #if/#elif that evaluates to
zero or by being after an #if/#elif that evaluates to non-zero).

glcpp/tests: Commit forgotten file 074-elif-undef.c.expected.

texture_builtins.py: Remove useless comments.

glcpp: Discard output of cmp when running the test suite.

We're already using the return-value of cmp to print either PASS or
FAIL and in the case of failure, we're subsequently running and
showing the output of diff. So any warnings/errors from cmp itself are
not actually needed, and can be quite confusing.

glcpp: Fix expected result for the 064-version.c test.

Commit d4a04f315560704bf1103df0b93723e468725df7 caused this test case
to produce an additional blank line, which is otherwise harmless, but
does need to be reflected in the .expected file for the test to pass.

glcpp: Regnerate glcpp-parse.c and glcpp-parse.h

After making a minor change to the .y file.

glcpp: Initialize location structure at beginning of parse.

Since we have a custom structure for YYLTYPE locations, we need to use
an %initial-action directive to avoid triggering use of uninitialized
memory when, for example, printing error messages.

We apparently don't yet have a test case that allowed valgrind to find
this bug for us, but valgrind found a similar problem in the other
parser, so we fix this one as well.

glsl2: Regenerate glsl_parser.cpp and glsl_parser.h

After making a minor change to the .y file.

glsl2: Initialize location structure at beginning of parse.

Since we have a custom structure for YYLTYPE locations, we need to use
an %initial-action directive to avoid triggering use of uninitialized
memory when, for example, printing error messages.

Thanks to valgrind for noticing this bug.

glsl2: Make ir_algebraic reassociate add/mul operands for constant folding.

It's rather easy to produce two constant multiplies separated by other
multiplies while writing a BRDF shader, and non-obvious enough in the
resulting codegen that I didn't catch it in my demo code until just
recently.  Cuts 3 965 instructions from my demo (<1%), and 20 from
glsl-fs-raytrace (1.3%).

glsl2: Add a pass to transform ir_binop_sub to add(op0, neg(op1))

All the current HW backends transform subtract to adding the negation,
so I haven't bothered peepholing it back out in Mesa IR.  This allows
some subtract of subtract to get removed in ir_algebraic.

glsl2: Add constant propagation.

Whereas constant folding evaluates constant expressions at rvalue
nodes, constant propagation tracks constant components of vectors
across execution to replace (possibly swizzled) variable dereferences
with constant values, triggering possible constant folding or reduced
variable liveness.

i965: More s/stderr/stdout/ for program debug.

glsl2: Teach copy propagation about "if" and "loop" instructions.

This lets us track copies across basic block boundaries.  The loop
doesn't get a filled out list of available copies into it yet, though.

glsl-fs-raytrace drops from 585 to 535 Mesa IR instructions out of the
compiler, and it appears that Yo Frankie's largest shaders decrease in
Mesa IR count by about 10% as well.

glsl2: Refresh autogenerated file builtin_function.cpp.

texture_builtins.py: Fix cut and paste errors in function names.

Some signatures were being generated with the wrong function name.

glsl2: Use gl_DepthRange's proper name.

It was being incorrectly added as gl_DepthRangeParameters, which is the
type name, not the variable name.

ir_algebraic: Support other comparisons in ir_unop_logic_not

ir_algebraic: Convert ir_unop_logic_not handler to use a switch statement

Currently only ir_binop_equal and ir_binop_nequal are supported, but
soon all of the relational operators will be added.  Making this
change now will simplify those commits.

glsl2: do not use __retval name; two underscores is reserved word according to GLSL spec (and Win7 ATI drivers do complain about that)

glsl: fix missing return in ir_structure_splitting

glsl2: Handle plain variable copies in struct splitting.

glsl-fs-raytrace goes from 620 Mesa IR instructions out of the
compiler to 585.

glsl2: Add the 1.30 reserved keywords.

ir_function_inlining: Fix missing iter.next() in inlining sampler params.

Fixes glsl-fs-function-samplers.

copy_propagation: do propagation into non-out call params

glsl2: Move gl_program->InputsRead/OutputsWritten setting to an ir pass.

This lets us handle arrays much better than trying to work backwards
from assembly.

Fixes fbo-drawbuffers-maxtargets on swrast (i965 needs loop unrolling)

ir_to_mesa: Add support for sampler arrays.

Support for samplers in general is still incomplete -- anything in a
uniform struct will still be broken.  But that doesn't appear to be
any different from master.

Fixes:
glsl-fs-uniform-sampler-array.shader_test

glsl2: Fix inlining with sampler array or struct dereferences as arguments.

Previously, we'd replace an argument of mysampler[2] with a plain
reference to mysampler by using the cloning hash table.  Instead, use
a visitor to clone whatever complicated sampler dereference into the
sampler parameter derefs in the inlined function body.

glsl2: Don't assert in a couple of places when encountering sampler arrays.

Fixes glean shaderAPI.

ir_to_mesa: Give the expected size for _mesa_add_attribute().

Fixes a failure in glean shaderAPI.

ir_to_mesa: Handle texture-array samplers

Fixes piglit test array_texture.

glsl2: Enable all supported extensions in stand-alone compiler

glsl_type: Don't have two versions of a type with the same name

Previously some sampler types were duplicated in GLSL 1.30 and
GL_EXT_texture_array.  This resulted in not being able to find the
built-in sampler functions when the extension was used.  When the
built-in functions were compiled, they bound to the 1.30 version.
This caused a type mismatch when trying to find the function.  It also
resulted in a confusing error message:

0:0(0): error: no matching function for call to `texture2DArray(sampler2DArray, vec3)'
0:0(0): error: candidates are: vec4 texture2DArray(sampler2DArray, vec3)

0:0(0): error:                 vec4 texture2DArray(sampler2DArray, vec3, float)

glsl2: Log a better error message when a matching function cannot be found

glsl2: Add a pass to convert exp and log to exp2 and log2.

Fixes ir_to_mesa handling of unop_log, which used the weird ARB_vp LOG
opcode that doesn't do what we want.  This also lets the multiplication
coefficients in there get constant-folded, possibly.

Fixes:
glsl-fs-log

glsl2: Insert global declarations at the top of the instruction stream.

Fixes use-before-decl in glslparsertest shaders.

Fixes:
CorrectFull.frag
CorrectModule.frag

ir_structure_splitting: Massive fixing to this.

I'd missed putting in the actual "find structures to split" part, so
most of the code didn't do anything.  I was running on too large of an
app and assuming the lack of progress was elsewhere.

glsl2: Make the HV actually call ir_texture's visit_leave.

ir_structure_splitting: New pass to chop structures into their components.

This doesn't do anything if your structure goes through an uninlined
function call or if whole-structure assignment occurs.  As such, the
impact is limited, at least until we do some global copy propagation
to reduce whole-structure assignment.

glsl2: Fix the dereferences_variable check in ir_tree_grafting.

The HV doesn't descend into ir_variable, which is generally a good
thing (allowing one to distinguish between variable declarations and
refs), but here we never saw tree grafting opportunities killed
because we were looking for the ir_variable child of a dereference to
get visited.

Fixes:
glsl1-function call with inout params

glsl2: Don't tree-grafting out assignment to an out variable.

Fixes:
glsl-deadcode-varying.

glsl2: Don't dead-code eliminate a call where the return value is unused.

This showed up since the disabling of inlining at compile time, which
I apparently didn't regenerate piglit summary for.

Fixes:
glsl-deadcode-call.

glsl2: Add some easy-to-enable debug printfs to ir_dead_code.cpp.

ir_to_mesa: Don't do function inlining until linking.

Optimizations at compile time should generally be done with the goal
of reducing instruction count so that other work, particularly
linking, is less time-consuming if the shader is used multiple times.
However, function inlining increases instruction count for the inlined
function bodies without removing the original function body, since we
don't know if it will be used at link time or not.

Reduces the runtime of linking and executing a Yo Frankie fragment
shader from 0.9 seconds to 0.5 seconds (-45.9%, +/- 2.2%, n=5).

glsl2: Add a pass for removing unused functions.

For a shader involving many small functions, this avoids running
optimization across all of them after they've been inlined
post-linking.

Reduces the runtime of linking and running a fragment shader from Yo
Frankie from 1.6 seconds to 0.9 seconds (-44.9%, +/- 3.3%).

glsl2: Catch pointless copies in copy propagation.

We wouldn't want to go rewriting dereferences to variables to point at
the same variable it did before.  While I didn't find a way to trigger
that, a shader in Yo Frankie managed to produce a self-assignment by
passing a constant to a function doing self assignment like this.

Cleans up the IR for glsl-deadcode-self-assign.shader_test

glsl2: Don't try to dump GLSL IR for a shader that didn't compile.

ir_to_mesa: Remove debug force-enablement of EmitNoIfs.

glcpp: Ignore #if and #elif expressions when skipping.

Fixes glcpp test cases 073 and 074, as well as piglit test
xonotic-vs-generic-diffuse.vert.

glcpp/tests: Add a corollary to testcase 073 for testing #elif.

glcpp/tests: Fix 073-if-in-ifdef.c to use #ifdef, not #if.

The original intention was to use #ifdef.

glcpp: Refactor HASH_IF and HASH_ELIF expansion to reuse code.

glsl2: Remove the shader_in/shader_out tracking separate from var->mode.

I introduced this for ir_dead_code to distinguish function parameter
outvals from varying outputs.  Only, since ast_to_hir's
current_function is unset when setting up function parameters (they're
needed for making the function signature in the first place), all
function parameter outvals were marked as shader outputs anyway.  This
meant that an inlined function's cloned outval was marked as a shader
output and couldn't be dead-code eliminated.  Instead, since
ir_dead_code doesn't even look at function parameters, just use
var->mode.

The longest Mesa IR coming out of ir_to_mesa for Yo Frankie drops from
725 instructions to 636.

glsl2: Remove a dead cut and paste member from ir_variable_refcount_visitor.

i965: Settle on printing our program debug to stdout.

Mixing stderr (_mesa_print_program, _mesa_print_instruction,
_mesa_print_alu) with stdout means that when writing both to a file,
there isn't a consistent ordering between the two.

ir_to_mesa: Print shader source and compiled IR under MESA_GLSL=dump.

While the Mesa IR dumping includes some corresponding GLSL IR for
correlating Mesa IR to GLSL IR, it doesn't completely express it.
This printing includes things like variable declarations and control
flow structure that is hard to read otherwise.

glsl2: Use linked ir_constant_variable after linking, instead of unlinked.

glsl2: Return progress from ir_vec_index_to_swizzle.

glsl2: Generate masked assignments in some expanded matrix operations

glsl2: Generate masked assignments in vector and matrix constructors

Previously the in-line matrix and vector constructors would generate
swizzles in the LHS.  The code is actually more clear if it just
generates the masked assignments instead of relying on the
ir_assignment constructor to convert the swizzles to write masks.

glsl2: Additional validation of write masks

glsl2: Add ir_assignment::write_mask and associated methods

Replace swizzles on the LHS with additional swizzles on the RHS and a
write mask in the assignment instruction.  As part of this add
ir_assignment::set_lhs.  Ideally we'd make ir_assignment::lhs private
to prevent erroneous writes, but that would require a lot of code
butchery at this point.

Add ir_assignment constructor that takes an explicit write mask.  This
is required for ir_assignment::clone, but it can also be used in other
places.  Without this, ir_assignment clones lose their write masks,
and incorrect IR is generated in optimization passes.

Add ir_assignment::whole_variable_written method.  This method gets
the variable on the LHS if the whole variable is written or NULL
otherwise.  This is different from
ir->lhs->whole_variable_referenced() because the latter has no
knowledge of the write mask stored in the ir_assignment.

Gut all code from ir_to_mesa that handled swizzles on the LHS of
assignments.  There is probably some other refactoring that could be
done here, but that can be left for another day.

glsl2: Don't try to construct an ir_assignment with an invalid LHS

glsl2: Constant fold the children of many more ir_instruction types.

glsl2: Return a real progress value from constant folding.

glsl2: Refactor constant folding of rvalues to a function.

glcpp: Refresh autogenerated lexer and parser.

glcpp: Remove xtalloc wrappers in favor of plain talloc.

Calling exit() on a memory failure probably made sense for the
standalone preprocessor, but doesn't seem too appealing as part of
the GL library.  Also, we don't use it in the main compiler.

glsl2: Remove uses of deprecated TALLOC_CTX type.

glsl2: add gl_LightModel built-in uniform.

glsl2: Don't try to assign locations for samplers during linking.

Mesa will do the mapping at _mesa_add_sampler() time.  Fixes assertion
failures in debug builds, which might have caught real problems with
multiple samplers linked in a row.

ir_to_mesa: Clean up the mapping of samplers to Mesa's sampler uniforms.

Instead of using a linker-assigned location (since samplers don't
actually take up uniform space, being a link-time choice), use the
sampler's varaible pointer as a hash key.

mesa: Don't null deref looking for Mesa IR code at compile time.

The new compiler doesn't generate Mesa IR at compile time, and that
compile time code previously wouldn't have reflected the link time
code that actually got used.  But do dump the info log of the compile
regardless.

glsl2: Skip talloc_parent in constant_expression of non-constant arrays.

glsl2: Make the clone() method take a talloc context.

In most cases, we needed to be reparenting the cloned IR to a
different context (for example, to the linked shader instead of the
unlinked shader), or optimization before the reparent would cause
memory usage of the original object to grow and grow.

glsl2: Set ir_discard::ir_type when cloning it

Fixes unset ir_type after inlining.

glsl2: Fix ir_validate validating null variable names.

An unnamed variable in a prototype will have a NULL ->name, so don't
worry about storage then.

Fixes:
CorrectFunction1.vert
CorrectParse1.frag