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

compiler: Turn on program limit initialization

compiler: Turn off push constants for fragment shader

compiler: Print resulting data structs

compiler: Turn on URB handling and interstage I/O

Pass VS outputs to FS inputs
Tested with a couple of linear interpolated vec4s

compiler: Start using VS backend results

Consuming the results of VS backend, similar to FS.
Piping it back to XGL.  Should continue to work until more
inputs or outputs are added.
Changed the source GLSL to shrink and recolor triangle

compiler: Start adding new files for VS

compiler: Blue triangle

compiler: Start using fs compile results

compiler: C linkage for icd alloc and free

compiler: Disable standalone build for now

compiler: Turn off SIMD16 for bring up

compiler: Progagate compile results to xgl, don't use them yet

compiler:  Get enough turned on to generate ISA

compiler: Turn on enough to invoke front end during XGL execution

Remove glassy compile checks, fix more things to run glsl
Consume glsl in the stack, store resulting IR

Fix up things enough to invoke our shader compiler with glsl, via
the real XGL calls.  Store the result as a gl_shader_program which
contains the IR.

The test still consumes the ISA generated by hand, but it will
print out the IR generated by xglCreateShader.  It will continue
to use hand ISA until we implement xglCreateGraphicsPipeline, which
will lower the IR to ISA using NOS.

compiler:  enable SSO for standalone shader compile and link

Use llvm-config to get --cxxflags for llvm (and remove old hack hardcoding them in the cmakefile).
Add some basic error reporting if first call to llvm-config fails, perhaps because it's missing or some such.

Print an error if llvm-config fails when running cmake.

There's no non-glassy mode left, so _mesa_use_glass always returns true now.  This
lets xglCompiler standalone run successfully on a trivial test shader.

Fix link errors in the way of building xglCompiler.  Note that it still crashes if you
try to, let's say... use it in any way whatsoever.

compiler: Import Mesa compiler components

Merciliess removal of gl_context state
compiler: Bring glslang and LunarGLASS into CMake process
compiler: Progress (?) towards standalone xglCompiler

compiler:  Bring over select required files from alchemist-10.2.6+steamos-LunarG-1.1

compiler: Bring over glsl compiler from alchemist-10.2.6+steamos-LunarG-1.1

layers: Update object tracker to account for Memory alloc/free

layers: Verify that slot binding is compatible with shader mapping

Bug fixes and enhancements to draw_state.c

Layers: Change Basic layer to implement an extension  and wrap GetExtension

Loader: GPA fixes  and also properly insert wrapped gpu objs into chain

Loader wasn't properly inserting the wrapped gpu objects for activated layers
into  the chain of objects.  This was a problem for any calls that used
the wrapped gpu object chain after activation of layers.

Bug fixes for draw_state.c layer

Initial version of draw state layer

Prints out Descriptor Set state at the time of Draw.

Destroy device before calling 2nd initAndEnum...

Add xglDestroyDevice() call to test framework.

layers: update documentation

Loader: Fix Seg fault when layers not activated via env var