vk/queue: Embed the queue in and allocate it with the device

vk/device: Free border color states when we have valgrind

vk/device: Destroy all batch buffers

Due to a copy+paste error, we were destroying all but the first batch or
surface state buffer.  Now we destroy them all.

vk/meta: Clean up temporary objects

vk/surface_view: Add a destructor

vk/image: Add anv_image::h_align,v_align

Use the new fields to compute RENDER_SURFACE_STATE.Surface*Alignment.
We still hardcode them to 4, though.

vk/allocator: Remove the concept of a slave block pool

This reverts commit d24f8245db3418d8d146f373e085780d2217335c.

vk/device: Remove the binding table pools/streams

vk/pipeline: Move freeing the program stream to pipeline.c

It's created in pipeline.c so we should free it there.

vk/pipeline: Don't destroy the program stream

It's freed in compiler.cpp and we don't want to free it twice.

vk/allocator: Make the use of NULL_BLOCK in state_stream_finish explicit

vk: Quiet a few warnings

vk: Create a minimal context for the compiler

This avoids the full brw context initialization and just sets up context
constants, initializes extensions and sets a few driver vfuncs for the
front-end GLSL compiler.

vk/cmd_buffer: Use the dynamic state stream in emit_dynamic and merge_dynamic

vk/device: Use a 64-byte alignment for CC state

vk/pipeline: Actually free the program stream and dynamic pool

vk/allocator: Avoid double-free in the bo pool

vk/gem: Call VALGRIND_FREELIKE_BLOCK before unmapping

vk: Fix 2 incorrect typecasts

The compiler didn't find the cast errors because all Vulkan types are
just integers.

vk: Make `make clean` remove generated spirv headers

vk/allocator: Remove an unneeded VG() wrapper

vk/device: Dissalow device destruction

vk: Fix build

Commit 1286bd, which deleted vk.c, broke the build. Update the Makefile
to fix it.

vk/DS: Mask stencil masks to 8 bits

vk: Set color/blend state in meta clear if not set yet

vk: Delete vk.c test case

We now have crucible up and running and all vk sub-cases have been moved
over. Delete this crufty old hack of a test case.

vk: Update generated headers with support for 64 bit fields

vk: Set cb_state to NULL at cmd buffer create time

Dynamic color/blend state can be NULL in case we're not rendering to
color targets (only output to depth and/or stencil). Initialize
cmd_buffer->cb_state to NULL so we can reliably detect whether it's been
set or not.

vk: Implement vertexOffset parameter of vkCmdDrawIndexed()

As exposed by the func.draw_indexed test, we were ignoring the argument
and hardcoding 0.

vk/formats: Add a name to the metadata and better logging

vk/formats: Rework the formats table

vk: Move query related functionality to new file query.c

i965: Use NIR by default for vertex shaders on GEN8+

GLSL IR vs. NIR shader-db results for SIMD8 vertex shaders on Broadwell:

   total instructions in shared programs: 2742062 -> 2681339 (-2.21%)
   instructions in affected programs:     1514770 -> 1454047 (-4.01%)
   helped:                                5813
   HURT:                                  1120

The gained programs are ARB vertext programs that were previously going
through the vec4 backend.  Now that we have prog_to_nir, ARB vertex
programs can go through the scalar backend so they show up as "gained" in
the shader-db results.

Acked-by: Kenneth Graunke <kenneth@whitecape.org>
Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
Acked-by: Matt Turner <mattst88@gmail.com>

vk/compiler: Add an index_count to the bind map and check for OOB

vk/HACK: Plumb real descriptor set/index into textures

NIR: Add a helper for doing sampler lowering for vulkan

vk: Indent tables to align '=' at column 48

vk: Add support for anisotropic bits

vk: Implement support for sampler border colors

This supports the three Vulkan border color types for float color
formats. The support for integer formats is a little trickier, as we
don't know the format of the texture at this time.

vk/device: Only flush the texture cache when setting state base address

After further examination, it appears that the other flushes and stalls
weren't actually needed.

vk/cmd_buffer: Track descriptor set dirtying per-stage

vk/device: Emit PIPE_CONTROL flushes surrounding new STATE_BASE_ADDRESS

According to the bspec, you're supposed to emit a PIPE_CONTROL with a CS
stall and a render target flush prior to chainging STATE_BASE_ADDRESS.  A
little experimentation, however, shows that this is not enough.  It also
appears as if you have to flush the texture cache after chainging base
address or things won't propagate properly.

vk/allocator: Don't call VALGRIND_MALLOCLIKE_BLOCK on fresh gem_mmap's

vk: Don't crash on partial descriptor sets

vk/device: Allow for starting a new surface state buffer

This commit allows for us to create a whole new surface state buffer when
the old one runs out of room.  We simply re-emit the state base address for
the new state, re-emit binding tables, and keep going.

vk/device: Do lazy surface state emission for binding tables

Before, we were emitting surface states up-front when binding tables were
updated.  Now, we wait to emit the surface states until we emit the binding
table.  This makes meta simpler and should make it easier to deal with
swapping out the surface state buffer.

vk: Store dynamic slot index with struct anv_descriptor_slot

We need to make sure we use the right index into dynamic offset
array. Dynamic descriptors can be present or not in different stages and
to get the right offset, we need to compute the index at
vkCreateDescriptorSetLayout time.

vk: Implement dynamic buffer offsets

We do this by creating a surface state on the fly that incorporates the
dynamic offset. This patch also refactor the descriptor set layout
constructor a bit to be less clever with switch statement fall
through. Instead of duplicating the subtle code to update the sampler
and surface slot map, we just use two switch statements.

vk/device: Split state base address emit into its own function

vk/device: Use anv_batch_emit for MI_BATCH_BUFFER_START

vk/device: Actually destroy batch buffers

vk/query: Don't emit a CS stall by itself

Both the bspec and the simulator don't like this.  I'm not sure if stalling
at the scoreboard is right but it at least shuts up the simulator.

vk/device: Fixups for batch buffer chaining

Some how these didn't get merged with the other batch buffer chaining
stuff.  Oh well, it's here now.

meta: Add a default ds_state and use it when no ds state is set

vk/meta: Share the dummy RS and CB state between clear and blit

vk: Initialize dynamic state binding points to NULL

We rely on these being initialized to NULL so meta can reliably detect
whether or not they've been set. ds_state is also allowed to not be
present so we need a well-defined value for that.

.gitignore: Ignore spirv2nir binary

.gitignore: Scope Vulkan's generated source files

Don't ignore any file named entrypoints.{c,h}. Ignore it only if it's in
src/vulkan.

vk: gitignore generated source files

vk/glsl_scraper: Replace adhoc arg parsing with argparse

vk/image: Assert that VkImageTiling is valid

vk/image: Remove trailing whitespace

vk/glsl: Reject invalid options

The script incorrectly interpreted --blah as the input filename.

vk/glsl_scraper: Indent large text blocks

Indent them to the same level as if the text was code.

No changes in entrypoints.{c,h} after a clean build.

vk/glsl_scraper: Fix code style for imports

Python style is one module imported per line, and imports are at the top
of the file.

vk/meta: Actually create the CB state for blits

vk: Rework anv_batch and use chaining batch buffers

This mega-commit primarily does two things.  First, is to turn anv_batch
into a better abstraction of a batch.  Instead of actually having a BO, it
now has a few pointers to some piece of memory that are used to add data to
the "batch".  If it gets to the end, there is a function pointer that it
can call to attempt to grow the batch.

The second change is to start using chained batch buffers.  When the end of
the current batch BO is reached, it automatically creates a new one and
ineserts an MI_BATCH_BUFFER_START command to chain to it.  In this way, our
batch buffers are effectively infinite in length.

Fixup for growable reloc lists

vk/cmd_buffer: Allocate the surface_bo from device->batch_bo_pool

vk/device: Make reloc lists growable

vk/device: Use a bo pool for batch buffers

vk/allocator: Add a BO pool

vk/allocator: Add a free list that acts on pointers instead of offsets

vk: Add support for dynamic and pipeline color blend state

vk/test: Create and use color/blend dynamic and pipeline state

vk/meta: Allocate and set color/blend state

For color blend, we have to set our own state to avoid inheriting bogus
blend state.

vk: Allocate samplers from dynamic stream

vk: Emit color calc state

This involves pulling stencil ref values out of DS dynamic state and the
blend constant out of CB dynamic state.

vk/pack: Generate length macros for structs

vk: Program depth bias

This makes 3DSTATE_RASTER a split state command.

vk: Add support for texture component swizzle

This also drops the share create_surface_state helper and moves filling
out SURFACE_STATE directly into anv_image_view_init() and
anv_color_attachment_view_init().

vk: Implement dynamic and pipeline ds state

vk: Set up depth and stencil buffers

vk/test: Add new depth-stencil test

Not yet a depth stencil test, but will become one.

vk: Add basic MOCS settings

This matches what we do for GL.

vk: Update to header files with nested struct support

This will let us do MOCS settings right.

vk/cmd_buffer: Initialize the pipeline pointer to NULL

If a meta operation is called before the pipeline is set, this can cause
uses of undefined values.  They *should* be harmless, but we might as well
shut up valgrind on this one too.

vk/device: Use the correct number of viewports when creating default VP state

Fixes valgrind uninitialized value errors

vk/compiler: Zero out the vs_prog_data struct when VS is disabled

Prevents uninitialized value errors

vk/compiler: Fix up the binding hack and make it work in NIR

vk: Actually implement some sort of destructor for all object types

vk/pipeline: Track VB's that are actually used by the pipeline

Previously, we just blasted out whatever VB's we had marked as "dirty"
regardless of which ones were used by the pipeline.  Given that the stride
of the VB is embedded in the pipeline this can cause problems.  One problem
is if the pipeline doesn't use the given VB binding we emit a bogus stride.
Another problem is that we weren't properly resetting the dirty bits when
the pipeline changed.

vk/device: Memset descriptor sets to 0 and handle descriptor set holes

vk: Do relocations in surface states when they are created

Previously, we waited until later and did a pass through the used surfaces
and did the relocations then.  This lead to doing double-relocations which
was causing us to get bogus surface offsets.

vk/test: Use the glsl_scraper for building shaders

vk/glsl_scraper: Use the LunarG back-door for GLSL source

vk/glsl_scraper: Use a fake GLSL version that glslang will accept

vk: Bake the GLSL_VK_SHADER macro into the scraper output file

vk/meta: Use glsl_scraper for our GLSL source

We are not yet using SPIR-V for meta but this is a first step.

vk: More out-of-tree build fixes