Update XGL_FORMAT.

xgl:  Add begin/end_range to all enums

Cosmetic change to xgl header for rev# 37, bug# 13244.

xgl:  Rename XGL_WAIT_EVENT enum in header

For svn rev# 29226, generalized an XGL_WAIT_EVENT enum.

xgl: Bump rev for Command Atomic update

Bug #: 12997
Alpha header revision: r29249

xgl: Remove xglCmdAtomics

Implement changes for alpha header version 0.35.
Bug #12998.

xgl:  Rename semaphore enums

Cosmetic xgl header change for xgl.h revision #40.

memory alloc: Remove last heaps from  memory alloc  and requirements

Also reorder memory_alloc_info struct as memPriority added back in as last
member in struct.

Conflicts:
demos/cube.c
demos/tri.c
icd/intel/buf.c
icd/intel/event.c
icd/intel/img.c
icd/intel/mem.c
icd/intel/pipeline.c
icd/intel/query.c
include/xgl.h
tests/image_tests.cpp
tests/init.cpp
tests/render_tests.cpp
tests/xgltestbinding.cpp
tests/xgltestbinding.h

memory alloc: Remove alignment from alloc_info structure

Conflicts:
icd/intel/mem.c

memory alloc: Remove MEMORY_ALLOC_FLAGS  add MEMORY_TYPE

memory alloc:  Remove memory_heap flags replace with memory_property flags

Conflicts:
include/xgl.h
tests/image_tests.cpp
tests/init.cpp
tests/xgltestbinding.h

memory alloc: Add IMAGE and BUFFER alloc info structures

For images have the tests fill in the IMAGE_ALLOC structures.  For buffers
this is not yet done.

Conflicts:
demos/cube.c
demos/tri.c
include/xgl.h
tests/init.cpp
tests/xgltestbinding.cpp

memory alloc: Add MEMORY_ALLOCATION_COUNT support and usage in tests.

Driver always does one allocation but tests support drivers with N allocations.

Conflicts:
demos/cube.c
demos/tri.c
tests/image_tests.cpp
tests/render_tests.cpp

memory alloc: Add allocation index to BindObjectMemory

For now it is always index 0.  Updates, driver, glave, tests, demos, include,
and layers.

memory alloc: Remove xglGetMemoryHeapXXX from driver,loader, glave, layers

demos: Remove calls to xglGetMemoryHeapXXX in xglinfo

xgl: move to new resource binding model

All except layout(set=) is supported.  The change to
pipeline_compiler_interface.{cpp,h} is ugly and fragile.  It should be fixed
after adding layout(set=) support.

demos, tests: use XGL_BUFFER_VIEW_RAW for constant buffers

complete fixed-function vertex fetch support

Update xgl.h (cosmetic changes only).  Add support for new formats.

v2: fix blit tests and enhance xglinfo for new formats

BIL: Update to support descriptor set GLSL features

xgl: Fix syntax error

xgl: resource transition integrated, update xgl.h version

xgl: Resource transition proposal from Bug 12904.

Added resource transition proposal from Bug 12904.
Updated function prototypes.
Added XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT based on Intel's request.
Unless this flag is specified, image views created from the image must match the base format.
xgl.py: changes for resource tracking
loader: changes for resource tracking
icd: changes for resource tracking
tests: changes for resource tracking
demos: changes for resource tracking

xgl: Dynamic State complete, update header version

driver:implement changes for Dynamic State

xgl: Buffer Object integrated, update xgl.h version

update for buffer object changes

xgl: Tiler updates complete, Update header version

misc: Fix tiler rebase in driver, tests, include

glave: Make tiler GPU changes work for tracing and replaying

The tracing  and replay code gen didn't handle all the special cases
for the removal of CmdBindAttachments() and the addition of nested structures
with pointers and objects  in the three APIs: CreateFramebuffer,
CreateRenderPass, BeginCommandBuffer.  It now does!

demos: Remove CmdBindAttachments() for tiler Gpus

layers: Remove CmdBindAttachment() for tiler GPUs

include: Remove CmdBindAttachments()

layers: Update BeginCommandBuffer API for Tiler Gpus

demos: Change BeginCommandBuffer for Tiler Gpus

include: xglBeginCommandBuffer API changed for Tiler Gpus

Bump version patch number also.

glave: Add support for new APIs to support Tiler Gpus

Adds support for xglCreateFramebuffer and xglCreateRenderPass

include: Add new API changes including structs/enums for Tiling GPU support

Omit changes for now that alter existing APIs: xglcmdBindAttachments and
xglBeginCommandBuffer

Bump the API version patch number, since we are diverging our version numbers
from the SVN  history. This is necessary since we are not implementing header
changes in the same order they were added to SVN header.

XGL: Move to svn r28460.

xgl: Do not build layers or glave during xgl.h update

cmake: Fix BIL overlay to glslang

cmake: fix up gtest and set -fvisibility=hidden globally

icd: update glslang, bil and lunarglass

Move ahead with versions installed by update_external_sources.sh

icd: Link ICD with -Bsymbolic

We were previously linking with -Bsymbolic-functions, but this was not
sufficient as it caused glslang virtual function calls to still be linked
to rendersystemtest copy of glslang.

include: set version to 0.22.1 for recent ABI changes

While this branch is divereged from Khronos SVN sequence of xgl.h versions.
Any ABI change in this branch  should increment the patch number: XX.YY.ZZ++.
Glave relies on the xgl.h version number to track trace file compatibility.

loader: Fix infinite loop on layer library scan if dlopen fails

xgl.py: missing xgl prefix in XGL_LAYER_DISPATCH_TABLE

67ac8db7571aa07cdce3dcaa39102198639f52f1 is incomplete.

layers: Updated MemTracker to track per-region memory transition states for allocations

layers: Added per-region memory state tracking

Initially only tracking mem transitions. Need to validate these and still have further work with images.

layers: Enhancements to MemTracker and DrawState

DrawState flags error when Descriptor Set that hasn't had "EndUpdate" called is bound to cmd buffer.
Moved MemTracker struct defines to header.
Added State to memory objects and flag state transition errors at prepare time
Added CreateInfo for all object types that can be bound to memory

Revert "layers: Fix generation of EnumerateLayers in APIDump"

This reverts commit 9c8e8a955eded8788a68c694cea11742e8d84690.

Stale generated code was the real issue.

layers: Fix generation of EnumerateLayers in APIDump

xgl_helper: Eliminate compiler not used warning

Using static inline vs. static only prevents the compiler
from complaining that the functions have been defined but
not used.

layers: Make sure we deref pointers to counts

For functions that can return a count of elements, be sure to
dereference that pointer when looping over the array.

layers: Fix APIDump param generation for Cpp versus C

Remanent from the merge of glave_integration.

glvreplay_xgl: Add 'EnableLayers' setting to control which XGL validation layers get enabled.

* The string is a comma separated list of layer names, defaulting to "Drawstate,ObjectTracker".
* Fix the way in which the settings are assigned to the default values, as the previous approach was attempting to delete the default 'EnableLayers' value, which would have caused problems eventually.

glave: Update xgl debugger and replayer to include support for settings.

* glvreplay_xgl has a 'debugLevel' setting that is used to control the validation level.
* glvdebug_xgl has a 'supportDrawCalls' placeholder setting that is not currently hooked up.

glave: Fix xglCreateDevice replay code to not modify packet.

Fixes sporadic  crashes on multiple replays.

glave: Remove MemTracker and replace with ObjectTracker

Too many tests cause MemTracker to spew a ton of errors.
Also don't print Info or Warnings during DbgCall in replayer as the
validation layers are too chatty!

glave: Register a handler in replayer for error msg callbacks and report these

Hook up DbgMsgCallbacks  from validation layers to replayer.  Log Warnings
and Info messages.  For Error messages log them and also fail the replay of
the packet that caused it.
By default enable debug level 4 in debugger and layers MemTracker and DrawState.

layers: APIDump* layers now print input array elements

Conflicts:
xgl-layer-generate.py

layers: ParamChecker handles dynamic arrays of structs

layers: Updated README to include ParamChecker

Conflicts:
layers/README.md

layers: Validate structs embedded in structs

layers:  Add comment to xgl_helper.py

layers: Add ENUM param checks to "gpu" funcs

layers: Initial ParamChecker layer

ParamChecker layer is generated and currently only checks that ENUM input to functions or ENUMS as part of input structs have valid values.

Conflicts:
layers/CMakeLists.txt

icd: clean up build rules

- lowercase local variables
- 4-space indentation
- use FindUdev
- use target_include_directories
- use target_link_libraries

cmake: use find_package() for XCB

cmake: add find modules

Add Find{DRM,UDev,XCB}.cmake.  Require 2.8.11 for FOUND_VAR support in
find_package_handle_standard_args().

xgl.py: fix prototype paring

Drop "xgl" prefix.

xgl:  Add xgl header changes for rev30 and 31.

Switched EnumerateLayer parameter order, added conditional definition
of xgl function prototypes, and prepended 'xgl' to all function
prototypes. This included fixes for bugs #13173 and #13180.

layers: Create APIDump[NoAddr]Cpp layers using c++ string and streams

This is fully functional version of APIDump & APIDumpNoAddr using std::string and i/o streams
Hopefully this will fix a few random crashes that were being hit with rendersystemtests & APIDump
Long term we won't keep generating so many different APIDump layers.
The main APIDump layer will be the Cpp version and it will have settings file options to vary file i/o and noaddr along with any new options.
We should keep the C version of APIDump around until we're sure we don't need it, though.

layers: Default MemTracker and DrawState to verbose stdout mode when no settings file present.

glave: Add GLVLIB_TRACE_IPADDR env var for remote system tracing

Setting this env var will make the xlg tracer library send packets to
a remote system  rather than the local system.

glave: Add XGL_LAYER_CREATE_INFO structure to trace files

Recent test changes was adding this structure to the DEVICE_CREATE_INFO
structure.  this was causing a regresiion in Glave.

layers: xgl-helper.py depends on xgl.h

This makes sure helpers are regenerated when xgl.h is edited.

loader: Check for success on return from driver for create object calls

Allows errors from driver that prevented driver from creating object to
return to the app.

layers: More robust parsing of xgl.h in helper script used by layers

info: Update BUILD document with layer info

build: Update render node enable instructions

Render nodes were not getting enabled when setting up a newly installed
14.10 Ubuntu system. To get the rnodes=1 option to work it is necessary
to update the ramfs boot image.

build: Add more error checking for build environment

Make sure that a KHRONOS_ACCOUNT_NAME and necessary BIL
files exist before doing any other work. That way user
knows right away if build environment is setup correctly or not.

loader: Include layers specified in environment

If application specified layer_info in the CreateDevice call
the code would only look for layers the app specified. However,
we want to include layers specified in the environment in addition
to any specified by the application.

loader: Fix some typos and formatting

layers: use generated layer_intercept_proc()

Call layer_intercept_proc() from xglGetProcAddr() in DrawState, MemTracker,
and generated layers.

There should be no functional difference with this change.

layers: intercept xglCmdBindVertexData() in DrawState and MemTracker

xgl-generate.py: add LayerGetProcAddrHelperSubcommand()

It generates layer_intercept_proc() to intercept all but
xglInitAndEnumerateGpus().  It is possible to extend the subcommand to get the
list of functions to intercept from command arguments or layer spec files.
But we do not have the needs yet.

xgl-generate.py: add generate_get_proc_addr_check()

Generate

    if (!pName || pName[0] != 'x' || pName[1] != 'g' || pName[2] != 'l')
        return NULL;

for use in xglGetProcAddr().

layers: simplify xglGetProcAddr() for Basic and Multi

Layers should only handle interested XGL entrypoints in their
xglGetProcAddr(), and chain to the next layer.  Handling everything using the
cached results in pTable is not much faster.

There should be no functional difference with this change.

layers: simplify initLayerTable()

Generate xgl_dispatch_table_helper.h with

 $ ./xgl-generate.py dispatch-table-ops layer

and make use of layer_initialize_dispatch_table() in initLayerTable().

There should be no functional difference with this change.

xgl-generate.py: simplify _does_function_create_object()

Make use of _object_out_params().

xgl-generate.py: simplify _is_dispatchable()

Make use of object_in_params().  Remove unused _is_name_dispatchable().

xgl.py: remove special-purpose functions

Move them to LoaderEntrypointsSubcommand as they are loader-specific.

xgl.py: add more methods to Param and Proto

xgl.py: update with parsed core extension

xgl.py: add the ability to parse xgl.h

This is useful to generate templates for editing.

xgl.py: add names of objects

They can be used to tell if a param is an object.

loader: use generated dispatch table ops

This also fixes several typos in xglGetProcAddr(), such as in

    else if (!strncmp("xglCreateFence", pName, sizeof ("xgllCreateFence")))
        return disp_table->CreateFence;

They are generally harmless though.

xgl-generate.py: add DispatchTableOpsSubcommand

It can generate functions to initialize and lookup a dispatch table.

xgl-generate.py: rename LoaderSubcommand

Rename it to LoaderEntrypointsSubcommand.

xgl-generate.py: clean up IcdDummyEntrypointsSubcommand

Use c_pretty_decl() and generate all protos.