vk/formats: Refactor format properties code

Along with the refactor, we now do the right thing when we hit an
unsupported format: Set the flags to 0 and return VK_SUCCESS.

vk/image: Add a bunch of asserts

vk: Add a couple vk_error calls

vk/private: Add a non-fatal assert

vk/cmd: Add an initial implementation of PipelineBarrier

We may want to do something more inteligent here later such as actually
handling image layout transitions.  However, this should do for now.

vk/emit: Use valgrind to validate every packed field

vk: Add valgrind checks in various emit functions

The check in batch_bo_finish should catch any undefined values in the batch
but isn't that great for debugging.  The checks in the various emit
functions will help get better granularity.

vk: Move the valgrind include and VG() macro to private.h

vk/image: Don't double-allocate stencil buffers

If the main surface has format S8_UINT, then don't allocate the
auxiliary stencil surface.

vk/image: Teach anv_image_choose_tile_mode about WMAJOR

vk/util: Add anv_abortf(), anv_abortfv()

Convenience functions to print an error message then abort.

vk: Define anv_noreturn macro

vk/image: Factor tile mode selection into separate function

Because it will eventually need to get smarter.

vk/device: Actually allow destruction

vk/cmd_buffer: Properly initialize/reset dynamic states

vk/pipeline: Zero out the depth-stencil state when not in use

vk/device: Use anv_CreateDynamicViewportState instead of the vk one

vk/device: Dedent the vkCreateDynamicViewportState call

vk/util: Annotate anv_finishme() as printflike

vk: Define anv_printflike() macro

vk/image: Stop hardcoding alignment of stencil surfaces

Look up the alignment from anv_tile_info_table.

vk/image: Rewrite tile info table

- Reduce the number of table lookups in anv_image_create from 4 to 1.
- Add field for surface alignment.
- Shorten field names tile_width, tile_height -> width, height.

vk/image: Delete an old comment

vk/compiler: Free the GL errors data

vk/compiler: Free more of prog_data when tearing down a pipeline

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