added BIL_MixTriangle test. This tests support for location on varyings
through BIL.

Add MixTriangle test which tests explicit locations on varyings.

Add the starting user varying slot number (24) to any explicit location
passed by user on varying.

compiler_render_tests: Add a simple VS texturing test

compiler: Allow sampler index to be looked up, although bindings not present yet

compiler: Allow sampler unit bindings to propagate in backend

compiler: Remove most of the contents of uniforms.c and add to build

compiler: Add clean copy of uniforms.c

demos: Convert shader to GLSL

demos/tri: enable FF vertex fetch

demos/tri: allocate depth buffer

And enable depth test with XGL_COMPARE_GREATER.

demos/tri: allocate vertex buffer

demos/tri: allocate textures

demos: Add gen7 ISA to tri demo

demos: add tri

tests: Start using XGL blit

tests: Start adding spinning cube test

test-framework: make color and depth binding info accessible

test-framework: Make ReadFile available to tests

test-framework: minor whitespace cleanup

compiler: Set some better defaults for gl_context constants

compiler_render_tests: Clean up single texture test a bit

compiler_render_tests:  Turn on VS and FS uniform block tests

render_test: Bring over constant buffer stride fix from base_render_test

compiler: Bump up some const values to allow UBO

compiler: Print out link errors from CreateShader

compiler_render_tests: Turn on textured triangle test, with just t0 and s0

compiler_render_tests: Turn on the compiler_render_tests build

compiler_render_tests: Fork the render_tests file for quick compiler test turn on

tools: utility script to create and update external sources

tests: draw multiple triangles to a buffer

Clean up some more non-glassy code from instruction scheduler.

compiler: Turn off all the compiler spew by default

compiler: Clean up backend some more

compiler: Remove some (not nearly all) dead files from frontend

compiler: Clean up front end changes a bit

Remove some unneeded non-glassy FS TD scheduler code.

Remove some unneeded non-glassy code from brw register allocator.

Cleanup some code that's no longer needed with logical IO.

Bring across logical IO changes from Mesa branch.  Note: some further cleanup
can follow, now that physical IO is no longer needed.

tests: Remove CreateShader test

Removed CreateShader test that was not really testing
the driver with a real shader. Instead let the render tests,
which do use real shaders, do the testing.

render_tests: fix constant buffer setup

glm::mat4 has 64 bytes yet we copied 256 bytes from it.  Fix memory view range
and stride.  It worked because

    (OWord Dual Block Read/Write)
    the surface pitch is ignored, the surface is treated as a 1-dimensional
    surface. An element size (pitch) of 16 bytes is used to determine the size
    of the buffer for out-of-bounds checking if using the surface state model.
    [DevSNB+]

intel: use intel_gpu to set up the compiler context

Instead of hardcoding Haswell.  The tests now pass on my SandyBridge.

intel: remove unused INTEL_EXT_COMPILE_GLSL

intel: make intel_ir opaque

It is just gl_shader_program in the end, and we want gl_shader_program to be
opaque.  This also forces the driver to correctly use intel_pipeline_shader
instead of intel_ir.

With the change, xglCreateShader() now asks the compiler to compile BIL into
intel_ir.  Later when the pipeline is created, the intel_ir is passed to the
compiler again to generate the binary kernel as well as metadata.

tests: Add matrix library (libglm-dev) and test

Update draw with uniform to take the uniform (matrix) as a
parameter and can now rotate the test triangle.

tests: Rename tests to be shorter and more descriptive

render_test: Clean up VS uniform test, draw rotated triangle

compiler: Turn off uniform loads via sampler for vec4 for now

render_test: Start turning on simplified VS uniform test

compiler: Propagate VS binding table size

compiler: Turn off push constants for vec4 shaders

intel: Support GLSL compiling in less intrusive way

Removed all the extension semantics. Support for compiling GLSL in the
driver is intended to be a tempory feature and these changes minimize
the impact on the driver and make it easier to remove in the future.

tests: Add test to explicitly use GLSL to BIL module

Connect thin vertical BIL path.

tests: Draw two triangles from mesh

render_test: Turn all tests back on, easier to debug with just one

render_test: Render a triangle using compiler and vertex fetch

render_tests: Turn on FS with two uniforms

tests: Add another test triangle for compiler

tests: Clean up shader code, unused functions.

tests: Remove app specific code out of framework

tests: Remove ISA byte code now that we can compile

intel: Only destroy object if it exists

intel: Turn on BIL in driver

intel: record size of incoming shader source

tests: Add -use-BIL option

intel: disable BIL for now

tests: Now have two triangle tests using different shaders

tests: migrate render test to render framework

tests: Make simple test with everything needed

base_render_test does everything needed to render a triangle.
Have in single function to aid understanding what it does.

tests: Add another class to help implementing tests

tests: Use global SetUp/TearDown for compiler setup

The GLSL compiler requires some one-time per process setup and
teardown to operate properly. Using gtest global environment to
manage those functions.

tests: Add additional shaders for testing

tests: Add utility function to compile GLSL to BIL

This requires glslang + BIL to be in a peer folder (glslang) to XGL.

triangle: Hook up a uniform read in fragment shader

Add a constant buffer and descriptor set to render_test
Read the uniform in fragment shader, add it to existing color
Triangle colors should remain, but be whiter

Refactor test code to pull common section into functions

render_test: Restore use of %

render_test: refactor image/sampler setup, render textured triangle

Conflicts:
icd/intel/compiler/shader/compiler_interface.cpp

Undo changes to driver that mirror what Olv cooked up

render_test: Populate the texture more correctly, render purple triangle

Conflicts:
icd/intel/compiler/shader/compiler_interface.cpp

render_test: Start turning on sampler and texture setup

compiler: Changes in the direction of textures and samplers

compiler: Use pipeline shader rather than info shader for state update

compiler: Start dumping vertex shader data

Checkpoint getting LogicalIO working by backing shader off to 130
instead of 430 (which would drag in output blocks).  This change
uses the simpler of the two frag shaders in render_tests.cpp,
since that doesn't use more advanced features like layout qualifiers
which may not be present in the BIL->TopIR path yet.

Logical IO is now enabled, as well as a glsl->BIL path.  When
BIL is supplied in the shader, we can trim out the glsl bits.

Conflicts:
icd/intel/compiler/shader/compiler_interface.cpp

Checkpoint some work on useLogicalIO mode for converter, and going through a BIL
conversion in the compile method.  That'll change soon to consume BIL directly
instead of converting it from glsl.

This is disabled for the moment pending figuring out the varying output count
problem.

Conflicts:
icd/intel/CMakeLists.txt
icd/intel/compiler/shader/compiler_interface.cpp

tests: Add additional shaders for testing

intel: complete plumbing to add GLSL compile extension

intel: Add shader structure for GLSL compile extension

intel: Prepare CreateShader to accept BIL and GLSL

intel: Fix use of wrong extension name

checkpoint: Adding GLSL compiler extension

cmake: Lift common glslang definitions up to main CMakeLists

tests: Add utility function to compile GLSL to BIL

This requires glslang + BIL to be in a peer folder (glslang) to XGL.

triangle: Hook up a uniform read in fragment shader

Add a constant buffer and descriptor set to render_test
Read the uniform in fragment shader, add it to existing color
Triangle colors should remain, but be whiter

compiler: Print out more push/pull param info

Fix integer mod.

compiler: Don't use samplers for uniform loads yet

compiler: Swap FS and VS ordering in pipeline compiler interface