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

layers : Updates to layers README

More formated struct printing for API Dump

Fix memory leaks in loader  related to layers.

Make layer activation via CreateDevice struct or env variable

Also finish making all activated layers per icd and per gpu.

Better memory management in api_dump layer and struct print helper

Loader: fix dispatch table initialization to handle  multiple layers

Improved API Dump and OBJ Track layers

Added generator script just for layers that generates API Dump and Object Tracker layers.  Improved output of API Dump layer.

Initial layer to dump api calls

Added object_track.c layer and include cmake step to build libXGLLayerObjectTrack.so

Change GetProcAddr  function signature to use XGL types.

Fix bug in GPA for basic_plugin.c .

Make layer activation per icd in loader  and gets deactivated.

Fixes issue where multiple xglInitAndEnumerate were causing the layer
activation to fail  and dispatch table setup in loader to fail.

Add function to set an icd's dispatch table for subsequently created objects.

With layers the loaders dispatch table is used instead of the drivers dispatch
table.  The gpu objects were reflecting this change but not subsequent objects.
Tell the icd driver about the loader's dispatch table so it will use it on
object creation rather than the default  driver dispatch table.

Add xglEnumerateLayers function including support in layers.

Also add this call to xglbase (init.cpp) test.

Fixes to Basic and Generic layers to work singly with LD_PRELOAD

Layers initial prototype.

Includes  an auto generated layer (GenericLayer) that wraps  all api calls.
Includes a basic handwritten layer (basicLayer)  that wraps a few apis.
Adds xglGetProcAddr as a new api, which is used to chain layers together.
All layers and loader implement  a dispatch table.

loader: initialize memory

uninitialized use from by valgrind

intel: add INTEL_DEBUG=nocache

INTEL_DEBUG=nocache flushes all caches after each draw call.  We may start
running into render corruptions as we feed more test cases to the driver.
This option allows us to know if the corruption is cache-related quickly.

intel: always emit DEPTH_STENCIL_STATE for meta

DEPTH_STENCIL_STATE is always referenced by the hardware.

intel: add a missing WA in the meta path

A scoreboard stall needs to be emitted prior to any change to "Maximum Number
of Threads" of 3DSTATE_PS.  If the normal draw path and the meta path
programmed the same value for the field, we probably could skip this WA.  But
let's play safe.

intel: fix clears with mipLevels > 1

meta->dst.layer should be reset to range->baseArraySlice for each mip level.
Otherwise, we may render out-of-bound and cause screen corruptions.

intel: improve blob decoding

The last few dwords were skipped if the total number of dwords was not a
multiple of 4.  Change the formatting for better readability.

intel: disable PS for depth/stencil clears

We can set the Z coordinate of the clear rectangle to depth clear value and
set stencil reference value to stencil clear value.  Neither requires PS to be
enabled.

intel: create intel_ds_state for depth/stencil clears

It controls whether depth, stencil, or both are cleared.

intel: use helper funtions in gen6_meta_depth_buffer()

There are helper functions to emit depth-related hardware states.  Use them.

intel: allow depthWriteEnable to be independently enabled

When depthTestEnable is false, the hardware works as if the depth test always
passes and depthWriteEnable can still be honored.  It is unclear what the API
intends to do, but let's follow the hardware for now.

intel: fix an assertion in create info copying

XGL_VIEWPORT_STATE_CREATE_INFO has no header and we should not assert
info.header->next to be NULL.

intel: implement cmd_draw_meta()

It emits the necessary hardware states for a meta op.  Copying with
depth/stencil or multisample source is not supported yet.  Clearing
depth/stencil destination is also unsupported.

intel: convert resource operations to meta ops

Convert xgl{Copy,Clear,Resolve}* to meta ops, and call cmd_draw_meta() to
execute them.

cmd_draw_meta() is no-op and will be fixed by the following commit.

intel: define meta ops

Meta ops include copy, clear, and resolve.  We need a meta shader for each of
the meta ops, and the shaders should be created with intel_dev to avoid
recompilation and locking.

This commit creates only dummy meta shaders.  They should be replaced by real
ones when the compiler or assembler is ready.

intel: allow a writer to be a reloc target

This allows us to handle STATE_BASE_ADDRESS more elegantly while making reloc
processing slower because of a libdrm_intel limitation.  It is justified
though because

 - we have to move away from libdrm_intel at some point and
 - in xglCmdUpdateMemory, we want to stream the data to the dynamic state
   writer and make the dynamic state writer a reloc target.

icd: add icd_format_is_equal()

It returns true when the formats are equal.

intel: clean up cmd shader cache

Mainly to remove intel_cmd_shader.  There were intel_shader,
intel_pipeline_shader, and intel_cmd_shader.  When we saw a variable named,
say, fs, we could not relate it to its type immediately.  Getting rid of
intel_cmd_shader makes that easier.

This also gives us a nicer API.  The cache is now transparent and never fails
cmd building.

intel: emit everything at draw time

We do not perform any optimization on the command buffer yet.  Emit everything
at draw time makes things easier when we add meta ops (such as image copy).
Once we are more feature complete, we will revisit how command buffer
optimization should be done.

intel: fix color/depth attachments size mismatch

The drawing rectangle should be the intersection of all color attachments and
the depth attachment.  Merge cmd_bind_rt() and cmd_bind_ds() into
cmd_bind_attachments() so that we can do that.

Move state emission to emit_rt() and emit_ds().

intel: handle XGL_LAST_MIP_OR_SLICE

The miplevel or slice count of XGL_IMAGE_SUBRESOURCE_RANGE can have the
special value XGL_LAST_MIP_OR_SLICE.

intel: fix 8x sample pattern

Use sample patterns defined by the spec and convert them to hardware patterns.
This fixes 8x sample pattern.

intel: Clear pointer after unmapping buffer

tests: Fix issue in tests where descriptor set mapping array not initialized

intel: Only check string if length > 0

strncmp will return 0 (match) when given two different strings
and a length of 0. Changed code to only do the compare if
length > 0. Now properly handles empty environment variable or
one that has multiple commas in a row.

intel: Need to save copy of create_info

Valgrind found that base_dbg_copy_create_info was leaking
the copy of the create_info structure.

intel: Fix memory leak found by valgrind

intel: Reset pointer after freeing memory

intel: fix memory leak spotted by valgrind

icd: Fix incorrect return type

intel: fix devid override

intel: emit BINDING_TABLE_STATE for all stages

We had emit_ps_binding_table() for PS.  It turned out it was generic enough to
do all stages.

intel: emit SAMPLER_STATE for all stages

We had emit_ps_samplers() for PS.  It turned out it was generic enough to do
all stages.

intel: fix for a semantic change in libdrm 2.4.57 and later

When a client does

  xglInitAndEnumerateGpus();
  xglCreateDevice();
  // do something

  // reinitialize without xglDestroyDevice() first!
  xglInitAndEnumerateGpus();
  xglCreateDevice();
  // do something else

the driver will

  open()
  close()
  open()
  close()

on the DRM device.  The problem is that the two open()s may return the same
value and confuse libdrm since 2.4.57 (specifically, commit 743af59669).
Making intel_winsys intel_gpu-owned allows the driver to do this instead

  open()
  intel_winsys_create_for_fd()
  intel_winsys_destroy()
  close()
  open()
  intel_winsys_create_for_fd()
  intel_winsys_destroy()
  close()

kmd: fix intel_bo_wait() on kernel 3.17

Kernel 3.17 (commit 5ed0bdf21a specifically) introduced an ABI breakage.

Fix loader icd_scan to Null terminate strings

Refactor test code to pull common section into functions

intel: add support for FF vertex fetch

shaderEntityIndex is used to index pVertexBindingDescriptions instead of
pVertexAttributeDescriptions.  Not really sure how that works.

https://cvs.khronos.org/bugzilla/show_bug.cgi?id=12774#c26

include: update xgl.h with FF vertex fetch

https://cvs.khronos.org/svn/repos/oglc/trunk/nextgen/proposals/IMG/xgl_vertex_input_description2_img.h

intel: fix untyped memory views on GEN6

icd: add icd_format_get_channel_count

intel: disable PCB

XGL_LINK_CONST_BUFFER should be consumed by the compiler rather than blindly
pushed.

intel: disable HiZ

We are not quite there yet.

intel: emit samplers and image/memory views

Emit SAMPLER_STATE and SURFACE_STATE for texturing.

Added graphiviz dot and png files to visualize some API details

Fix size as input/output parameter for various xglGet calls.

Fix size parameter for xglGetFormatInfo test utilities.

Fix size as input parameter to xglGetGpuInfo() for test utilities

intel: check for xcb too

intel: do not require render node

We can use the primary node for GPUs with an X display associated.

intel: add support for XGL_WSI_X11

add stubs for XGL_WSI_X11

include: add preliminary XGL_WSI_X11 proposal

It is built around DRI3 and Present.

intel: remove intel_fence_get_status()

It is equivalent to intel_fence_wait() with timeout set to 0.

tidy up the build system a bit

delete GitSHA1.c generation

It is unused.  Could be revived anytime if found useful.

intel: set tiling before exporting

The remote gets the tiling of the bo from DRM_IOCTL_I915_GEM_GET_TILING.

intel: add intel_obj_bind_mem()

Make intelBindObjectMemory() a wrapper to it.

intel: teach layout about scanout

intel: prepare for primary node support

We will be able to support primary nodes once we know how to talk to an X
server.

intel: use the common DRM subsystem scanner

icd: add an API to scan Linux DRM subsystem

It differs from the scanner in intel ICD in that both legacy (primary) nodes
and render nodes are supported.  And it does not open() any of them.

xgl-generate: do not hardcode #include's

Add core_headers to xgl.py and use it to generate #include's

remove XGLConfig.h.in

Unused.