intel: an XGL_INSTANCE is not an XGL_OBJECT

It should not embed an intel_obj nor be created by intel_base_create().  Note
that there is an issue with both the old and new code: the allocation of
intel_instance uses the default allocator instead of the app-provided
allocator.  It will be fixed later.

intel: allow GPU re-enumeration

When apps see XGL_ERROR_DEVICE_LOST, they release everything and enumerate
GPUs again.  The call to intel_gpu_remove_all() was in
xglInitAndEnumerateGpus(), but it was missing in the new xglEnumerateGpus().

intel: rename intel.c to instance.c

There is now XGL_INSTANCE for GPU enumeration and things happen before it.

intel: rename intel_gpa.c to gpa.c

intel: move xglEnumerateLayers() to gpu.c

We are going to rename intel.c to instance.c, and xglEnumerateLayers()
definitely does not belong to instance.c.

layer: Fixed options settings for generated layers, fixed typos

Handling of non-zero default values now also fixed.

intel: fix waiting of present fences

For presentation fences, we should wait until the server has submitted the
presentation command to the kernel _and_ the GPU has executed the command.
We failed to wait for the latter until this fix.

layers: Fix Memtracker fence-related memory leak

MemTracker created internal fence objects to locally track command buffer
completion, but these objects were never destroyed.

Win: Fix compilation error on Windows (xgl_helper.py).

Visual Studio doesn't like the following code construct:

    if (<some test>)
        return <something>;
    <type> variable [= <intial-value>];

We have to use curly-braces, as in:

    if (<some test>) {
        return <something>;
    }
    <type> variable [= <intial-value>];

Win: layers (draw_state.c): Fix compilation error on Windows.

Visual Studio doesn't like:

            static const uint32_t NUM_COLORS = 7;
            char* edgeColors[NUM_COLORS];

Instead, we need to do:

             char* edgeColors[NUM_COLORS];

layers: Track WsiCreatePresentableImage image object

The memory returned by WsiGetPresentableImage is unique
and cannot be freed or unbound by the app. Thus only object tracker
only needs to track the image object.

layers: Do not track PHYSICAL_GPUS

The application does not create PHYSICAL_GPU objects
so do not track them.

layers: Do not track Queue objects

Queue objects are not created by an application and
thus never destroyed. Thus do not need to track.

layers: flush logged output so it's visible immediately

demos: Clean up objects after cmd buf built

demos: Update to single layout

intel: use buffer type memory for linear formats

To behave in a similar fashion to other IHVs we need
to return XGL_MEMORY_TYPE_BUFFER for images that
use format_class of LINEAR and XGL_MEMORY_TYPE_IMAGE for
all other format classes.

demos: Be sure to initialize pNext

demos: Bug fix: Unbind image object

demos: Be sure to request correct memory type

demos: Add use_staging option

Specifying --use_staging as a command line argument to tri
will force tri to upload the texture via a linear mapped staging buffer.

cube: Use staging buffer for texture upload

demos: Integrate feedback from NVIDIA

demos: Refactor to simplify and optimize

Will now check if texturing is supported on linear, CPU accessible
textures. If so, just uses that. If not, will use a staging buffer
to copy to optimized layout texture image.

intel: linear images require buffer type memory

layers: Check for NULL pointer with dynamic_display()

glave: Fix locking of mem_info entries in UnmapMemory

The retruned entry pointer could change after lock released in the case the mem info list was realloc.

layers: Fix DrawState buffer over-run when clearing descriptors

layers: Drawstate color descriptor edges and correctly clear slot mappings

layers: Fix layer config file options

Needed to end up with enums here, added this option.

layers: Validation check for CPU_VISIBLE bit set on MapMemory calls

layers: Fix uninitialized variable in DrawState.

update BUILD.md for imported libdrm

Two new dependencies introduced by libdrm: libpciaccess-dev and
libpthread-stubs0-dev.

glave: For color array params, correctly size trace buffer based on array type and size

intel: use unlimited VMA cache

With the switch to non-GTT mapping, we should have enough address space for
unlimited VMA caching.

intel: use intel_bo_map_async() for xglMapMemory()

When the mappable aperture is near full, BOs mapped by
intel_bo_map_gtt_async() will need to evict something in their page fault
routine, creating unpredictable latencies.  It also appears that the page
fault routine waits for the BOs to be unbusy, against the idea of
GL_MAP_UNSYNCHRONIZED_BIT.

intel: add intel_bo_map_async()

Non-blocking version of intel_bo_map().

cmake: remove unused FindDRM.cmake

intel: add and link with libintelkmd.a

Add cmake rules to build libintelkmd.a, which implements our KMD interface
using our own stripped-down libdrm.  This removes libdrm dependency.

intel: import stripped-down libdrm-2.4.59-23-g1f73578

Add selected files from libdrm, unmodified.

intel: remove libdrm dependency from libintelcompiler.a

We should not need libdrm in the compiler.

glvdebug_xgl: String replace of xgl to vk and XGL to VK for purposes of the GDC demo.

* The most recent headers will use the vk prefix, and then the generated xgl code will automatically output the correct packet strings.
* However, the header version we're using for the GDC demo doesn't have that prefix yet, so we're doing the switch in the UI temporarily.

compiler: Start using SIMD16 fragment shaders

The SIMD16 ISA has always been available, we just hadn't hooked it
up yet in the driver.  We've got enough workloads to know if it helps
performance now, so flip the switch!

demos/cube: use a single layout

demos: Updated tri to use staging buffer for texture

cube: Fix leaking resources

Demo was leaking Framebuffers and RenderPasses every time a new command
buffer was created (every frame). Now app creates only two command
buffers (one for each render target) and re-uses those command buffers
to draw the cube.

layers: Add simple Cmd Buffer dot file dump to DrawState

layers: For ParamChecker, verify struct ptrs aren't NULL before validating

layers: Remove destroyed/freed objects from both object lists

Some objects, upon being freed or destroyed, were removed from the
object-specific linked list but not from the master object list.

glvdebug: Enable/disable draw state widget.

Enable/disable the draw state widget instead of adding/removing the tab
containing the draw state. Display an empty scene when the widget is
disabled because disabled tabs are still visible.

glvdebug: ReplayWorker now properly cleans up the "Play to Here" action.

* This was being leaked before, and was resulting in multiple "Play to Here" context menu items in the API Call tree.

glvdebug: Resize text and items on Timeline.

* The Thread ID text is now drawn at 30% of the thread's area, but is cap'd at the default font height.
* The timeline items are now drawn at 40% of the thread's area, to ensure that it never overlaps the Thread Id text.

glvdebug: Close currently open trace files before trying to open a new one.

* Previously, If the user used File->Open to open a new trace file, the currently open trace file would not be closed. This was resulting in multiple Replayer tabs being visible in the UI (and likely a bunch of other less noticeable issues).
* Attempting to close the trace file prior to opening a new one seems the best way to resolve this issue.

glvdebug: ThreadIds are uint32_t, not int.

* This was causing some thread ids to be printed in the timeline as negative.

glvdebug: Timeline now resizes properly when the window is resized.

* The zoom factor and horizontal scrollbar was not being updated correctly.

glvdebug_xgl: Remove pipeline_dump files in more places.

* Files are now deleted when the trace file is loaded, and when the replay is started or continued. This ensure that stale images are left on disk.
* Also make the file removing code portable by using QFile::Remove(..).

glvdebug: Add option for separate replay window.

layers:  Remove the automatic dumping of DOT files.
This is now controlled solely by the app calling drawStateDumpDOTFile()

Conflicts:
layers/draw_state.c

glave: Add Dump() to debugger so DrawState dumping can occur on pauses

Conflicts:
glave-generate.py

glvdebug: minor improvement to timeline so it doesn't try to scrollTo(..) invalid items.

* This would cause the timeline to redraw thinking that the item wasn't in view.

glvdebug: Fix highlighting API call in call tree when replayer is paused and a proxyModel is being used.

* There was inconsistency in which model was being used to get the QModelIndex, which caused nothing to be highlighted in the API call tree.

glvdebug: Remove functions and buttons related to snapshots from the main UI.

* They were previously hidden by default, but to clean up the code, I decided to remove them completely.

glvdebug: Use svg instead of png.

Conflicts:
layers/draw_state.c

Conflicts:
layers/draw_state.c

glvdebug: Clean up pipeline dumps on trace load.

glvdebug: Fixed label for draw state diagram.

glvdebug: Use SVG renderer for draw state diagram.

intel: Return proper structure size for buffer object

layers: Add DrawState dot file output of descriptor details

layers: Fix buffer overrun in memtracker

Long function name+64-bit pointer caused buffer overrun in rendersystemtest

misc: Use XGL_API_VERSION instead of hard coded value

tri: Change from having a hard-coded API version to using the latest.

Piers actually found and fixed this, but I wanted to get it on "master" without
waiting for the rest of his changes.

layers: In DrawState correctly clear update chain for Struct Node

layers: Lock ObjectTracker linked-list access

layers: Add per-thread tracking of latest cmd buffer

layers: Don't run ObjectTracker checks on NULL mem objects

glave: Don't log error if replay is succesful but trace was not_ready

glave: Add lock around the socket send()

The send() is not atomic as less than full buffer can be sent.  Need to lock
for multithreaded apps.

compiler: Add a mutex for shader creation

Wrap the contents of shader_create_ir with a mutex to allow
multiple threads to issue xglCreateShader calls.

Most of this path is thread safe, we just need to rethink
how some initialization is happening, calls that used to live
on a single thread.

glave: Fix search of mem_info list  on UnmapMemory during tracing

glave: Improve logging for anomalous conditions around Map and Unmap memory

glave: Lock around access to the global mem_info list

compiler: Fix string use after delete in translator

Don't use a string that was only allocated for the scope of an if.
Instead, allocate the string at loop scope, and allow it to
deconstruct after use.

Courtesy of -fsanitize=address.

Also fix one other potentially unsafe string reference.

compiler: Fail pipeline creation if shader uses global uniforms

If the shader reads a global, non-block uniform, XGL does
not know where to read the value from.  Rather than segfault,
log an error, set an error code, and exit.  There is probably
someplace higher in the stack that should catch this.

glave: Fix bug in tracing CreateRenderPass with NULL attachments

layers: Multi-threading fixes for DrawState

layers: Disable DrawState dot file autodump and an incorrect validation check

layers: Fix DrawState bug to correctly shadow image/update structs

intel: enable HiZ on Gen7+

The support is restricted to Gen7+.  To support HiZ on Gen6, we need to
perform manual combined/separated stencil resolves and that may hurt the
performance instead.

Also, we do not support fast depth clears.  xglSetFastClearDepth() will be
removed in a later xgl.h revision.

intel: add cmd_meta_ds_op()

It can perform fast depth clear, depth resolve, and hiz resolve.  There is a
TODO about fast depth clear.

With our current xgl.h revision, I have to assume a layout in
xglCmdClearDepthStencil().  It will get fixed when we are at revision 59.
Alternatively, I could also assume the worst case and always do a depth
resolve after clearing, but that may hurt the performance.

In other words, it is invalid to use XGL_IMAGE_LAYOUT_GENERAL for shadow
textures.

intel: make sense of gen6_meta_DEPTH_STENCIL_STATE()

When operating on DEPTH, enable only depth write.  When operating on STENCIL,
enable only stencil test and stencil write for both faces.  The old code
should supposedly work, but it is hard to reason about it.

intel: avoid unnecessary stencil and hiz relocs

When the depth/stencil view does not need a separate stencil buffer or a hiz
buffer, do not set up relocs for them.

intel: add intel_format_has_depth()

Replace intel_format_is_depth() by intel_format_has_depth().

intel: remove intel_format_is_stencil()

It is not needed since the update to XGL_FORMAT by
2b7e88a1fdefc49d78e80765745e87e00034c2a0.

loader: Fix merge of layer names from env and CreateDevice

loader: initialize result for xglCreateInstance().

nulldrv: Return proper structure size for buffer object

This defect was cloned from the Intel driver; and so it gets the same fix:-).

intel: ICD_EXPORT all API functions

intel: format API functions as declared in xgl.h

intel: rename cmd_prepare.c to cmd_barrier.c

intel: minor improvements to fb.c

Less surprises when the applications do things we do not support.