vk: Update generated headers

This adds zeroing of reserved blocks of dwords and removes an
instruction definition.

vk/allocator: Solve a data race in anv_block_pool

The anv_block_pool data structure suffered from the exact same race as the
state pool.  Namely, that the uniqueness of the blocks handed out depends
on the next_block value increasing monotonically.  However, this invariant
did not hold thanks to our block "return" concept.

vk: Add and use an anv_block_pool_size() helper

vk/allocator: Make block_pool_grow take and return a size

It takes the old size as an argument and returns the new size as the return
value.  On error, it returns a size of 0.

vk/allocator: Fix a data race in the state pool

The previous algorithm had a race because of the way we were using
__sync_fetch_and_add for everything.  In particular, the concept of
"returning" over-allocated states in the "next > end" case was completely
bogus.  If too many threads were hitting the state pool at the same time,
it was possible to have the following sequence:

A: Get an offset (next == end)
B: Get an offset (next > end)
A: Resize the pool (now next < end by a lot)
C: Get an offset (next < end)
B: Return the over-allocated offset
D: Get an offset

in which case D will get the same offset as C.  The solution to this race
is to get rid of the concept of "returning" over-allocated states.
Instead, the thread that gets a new block simply sets the next and end
offsets directly and threads that over-allocate don't return anything and
just futex-wait.  Since you can only ever hit the over-allocate case if
someone else hit the "next == end" case and hasn't resized yet, you're
guaranteed that the end value will get updated and the futex won't block
forever.

vk/allocator: Make a few things more consistant

vk/allocator: Use memory pools rather than (MALLOC|FREE)LIKE

We have pools, so we should be using them.  Also, I think this will help
keep valgrind from getting confused when we have to end up fighting with
system allocations such as those from malloc/free and mmap/munmap.

vk/allocator: Add an anv_state_pool_finish function

Currently this is a no-op but it gives us a place to put finalization
things in the future.

vk/instance: valgrind-guard client-provided allocations

vk/device: Add anv_instance_alloc/free helpers

This way we can more consistently alloc/free the device and it will provide
us a better place to put valgrind hooks in the next patch

vk/device: Mark newly allocated memory as undefined for valgrind

This way valgrind still works even if the client gives us memory that has
been initialized or re-uses memory for some reason.

vk/batch_chain: Decrement num_relocs instead of incrementing it

vk/batch_chain: Compute secondary exec mode after finishing the bo

Figuring out whether or not to do a copy requires knowing the length of the
final batch_bo.  This gets set by anv_batch_bo_finish so we have to do it
afterwards.  Not sure how this was even working before.

vk: Re-name command buffer implementation files

Previously, the command buffer implementation was split between
anv_cmd_buffer.c and anv_cmd_emit.c.  However, this naming convention was
confusing because none of the Vulkan entrypoints for anv_cmd_buffer were
actually in anv_cmd_buffer.c.  This changes it so that anv_cmd_buffer.c is
what you think it is and the internals are in anv_batch_chain.c.

vk/cmd_buffer: Add a simple command pool implementation

vk/cmd_buffer: Add support for zero-copy batch chaining

vk: Add initial support for secondary command buffers

vk/cmd_buffer: Split batch chaining into a helper function

vk/device: Make BATCH_SIZE a global #define

vk/cmd_buffer: Add functions for cloning a list of anv_batch_bo's

We'll need this to implement secondary command buffers.

vk/reloc_list: Actually set the new length in reloc_list_grow

util/list: Add list splicing functions

This adds functions for splicing one list into another.  These have
more-or-less the same API as the kernel list splicing functions.

CLONE

vk/cmd_buffer: Invalidate texture cache in emit_state_base_address

Previously, the caller of emit_state_base_address was doing this.  However,
putting it directly in emit_state_base_address means that we'll never
forget the flush at the cost of one PIPE_CONTROL at the top every batch
(that should do nothing since the kernel just flushed for us).

vk/cmd_buffer: Rename emit_batch_buffer_end to end_batch_buffer

This is more generic and doesn't imply that it emits MI_BATCH_BUFFER_END.
While we're at it, we'll move NOOP adding from bo_finish to
end_batch_buffer.

vk/cmd_buffer: Use an array to track all know anv_batch_bo objects

Instead of walking the list of batch and surface buffers, we simply keep
track of all known batch and surface buffers as we build the command
buffer.  Then we use this new list to construct the validate list.

vk/cmd_buffer: Rework validate list creation

The algorighm we used previously required us to call add_bo in a particular
order in order to guarantee that we get the initial batch buffer as the
last element in the validate list.  The new algorighm does a recursive walk
over the buffers and then re-orders the list.  This should be much more
robust as we start to add circular dependancies in the relocations.

vk/cmd_buffer: Move emit_batch_buffer_end higher in the file

vk/cmd_buffer: Store the relocation list in the anv_batch_bo struct

Before, we were doing this thing where we had one big relocation list for
the whole command buffer and each subbuffer took a chunk out of it.  Now,
we store the actual relocation list in the anv_batch_bo.  This comes at the
cost of more small allocations but makes a lot of things simpler.

vk/batch: Make relocs a pointer to a relocation list

Previously anv_batch.relocs was an actual relocation list.  However, this
is limiting if the implementation of the batch wants to change the
relocation list as the batch progresses.

vk/headers: Update to new generated gen headers

This update fixes cases where a 48-bit address field was split into
two parts:

    __gen_address_type                           MemoryAddress;
    uint32_t                                     MemoryAddressHigh;

which cases this pack code to be generated:

   dw[1] =
       __gen_combine_address(data, &dw[1], values->MemoryAddress, dw1);

   dw[2] =
      __gen_field(values->MemoryAddressHigh, 0, 15) |
      0;

which breaks for addresses above 4G.

This update also fixes arrays of structs in commands and structs, for
example, we now have:

   struct GEN8_BLEND_STATE_ENTRY                Entry[8];

and the pack functions now write all dwords in the packet, making
valgrind happy.

Finally, we would try to pack 64 bits of blend state into a uint32_t -
that's also fixed now.

vk/cmd_buffer: Update a comment

vk/cmd_buffer: Use a doubly-linked list for batch and surface buffers

This is probably better than hand-rolling the list of buffers.

vk/aub: Use the data directly from the execbuf2

Previously, we were crawling through the anv_cmd_buffer datastructure to
pull out batch buffers and things.  This meant that every time something in
anv_cmd_buffer changed, we broke aub dumping.  However, aub dumping should
just dump the stuff the kernel knows about so we really don't need to be
crawling driver internals.

vk/cmd_buffer: Pull the execbuf stuff into a substruct

vk/cmd_buffer: Move the remaining entrypoints into cmd_emit.c

vk/cmd_buffer: Move the re-emission of STATE_BASE_ADDRESS to the flushing code

This used to happen magically in cmd_buffer_new_surface_state_bo.  However,
according to Ken, STATE_BASE_ADDRESS is very gen-specific so we really
shouldn't have it in the generic data-structure code.

vk/cmd_buffer: Factor the guts of CmdBufferEnd into two helpers

vk/cmd_buffer: Factor the guts of (Create|Reset|Destroy)CmdBuffer into helpers

vk/private.h: Re-arrange and better comment anv_cmd_buffer

vk: Actually advertise 0.138.1 at runtime

vk/vulkan.h: Bump to the version 0.138.1 header

This doesn't actually require any implementation changes but it does change
an enum so it is ABI-incompatable with 0.138.0.

vk: Add two more valgrind checks

vk/meta: Destroy shader modules

vk/device: Finish the scratch block pool on device destruction

vk: Add a FreeDescriptorSets function

vk/pipeline: Be more sloppy about shader entrypoint names

The CTS passes in NULL names right now.  It's not too hard to support that
as just "main".  With this, and a patch to vulkancts, we now pass all 6
tests.

vk: Prefix most filenames with anv

Jason started the task by creating anv_cmd_buffer.c and anv_cmd_emit.c.
This patch finishes the task by renaming all other files except
gen*_pack.h and glsl_scraper.py.

vk/image: Remove unneeded data from anv_buffer_view

This completes the FINISHME to trim unneeded data from anv_buffer_view.

A VkExtent3D doesn't make sense for a VkBufferView.
So remove the member anv_surface_view::extent, and push it up to the two
objects that actually need it, anv_image_view and anv_attachment_view.

vk: Document members of anv_surface_view

vk: Remove more raw casts

This removes nearly all the remaining raw Anvil<->Vulkan casts from the
C source files.  (File compiler.cpp still contains many raw casts, and
I plan on ignoring that).

As far as I can tell, the only remaining raw casts are:
    anv_attachment_view -> anv_depth_stencil_view
    anv_attachment_view -> anv_color_attachment_view

vk/image: Add braces around multi-line ifs

nir/spirv: don't declare builtin blocks

They aren't used, and the backend was barfing on them. Also, remove a
hack in in compiler.cpp now that they're gone.

nir/spirv: add support for loading UBO's

We directly emit ubo load intrinsics based off of the offset information
handed to us from SPIR-V.

nir/types: add more nir_type_is_xxx() wrappers

nir: move to two-level binding model for UBO's

The GLSL layer above is still hacky, so we're really just moving the
hack into GLSL-to-NIR. I'd rather not go all the way and make GLSL
support the Vulkan binding model too, since presumably we'll be
switching to SPIR-V exclusively, and so working on proper GLSL support
will be a waste of time. For now, doing this keeps it working as we add
SPIR-V->NIR support though.

vk: Remove unneeded vulkan-138.h

vk: Bump vulkan.h version to 0.138

vk/0.138: Update VkResult values

vk/0.132: Do type-safety

vk/cmd_buffer: Move batch buffer padding to anv_batch_bo_finish()

vk/cmd_buffer: Rename bo_count to exec2_bo_count

vk/cmd_buffer: Add a helper for allocating dynamic state

This matches what we do for surface state and makes the dynamic state pool
more opaque to things that need to get dynamic state.

vk/private.h: Move cmd_buffer functions to near the cmd_buffer struct

vk: Split command buffer state into its own structure

Everything else in anv_cmd_buffer is the actual guts of the datastructure.

vk: Move most of the anv_Cmd related stuff to its own file

vk: Pull the guts of anv_cmd_buffer into its own file

vk/glsl: Replace raw casts

Needed for upcoming type-safety changes.

vk/meta: Remove raw casts

Needed for upcoming type-safety changes.

vk/x11: Remove raw casts

The raw casts in the WSI functions will break the build when the
type-safety changes arrive.

vk: Delete vkDbgSetObjectTag()

Because VkObject is going away.

vk/device: Remove unneeded checks for NULL

vk/device: Provide proper NULL handling in anv_device_free

The Vulkan spec does not specify that the free function provided to
CreateInstance must handle NULL properly so we do it in the wrapper.  If
this ever changes in the spec, we can delete the extra 2 lines.

vk: Stop internally calling anv_DestroyObject()

Replace each anv_DestroyObject() with anv_DestroyFoo().

Let vkDestroyObject() live for a while longer for Crucible's sake.

vk: Fix vkDestroyObject dispatch for VkRenderPass

It called anv_device_free() instead of anv_DestroyRenderPass().

vk: Fix vkCreate/DestroyRenderPass

While updating vkDestroyObject, I discovered that vkDestroyPass reliably
crashes. That hasn't been an issue yet, though, because it is never
called.

In vkCreateRenderPass:
    - Don't allocate empty attachment arrays.
    - Ensure that pointers to empty attachment arrays are NULL.
    - Store VkRenderPassCreateInfo::subpassCount as
      anv_render_pass::subpass_count.

In vkDestroyRenderPass:
    - Fix loop bounds: s/attachment_count/subpass_count/
    - Don't call anv_device_free on null pointers.

vk: Refactor create/destroy code for anv_descriptor_set

Define two new functions:
    anv_descriptor_set_create
    anv_descriptor_set_destroy

vk: Replace some raw casts with safe casts

That is, replace some instances of
    (VkFoo) foo
with
    anv_foo_to_handle(foo)

vk: Correct anv_CreateShaderModule's prototype

s/VkShader/VkShaderModule/

:sigh: I look forward to type-safety.

vk: Define struct anv_image_view, anv_buffer_view

Follow the pattern of anv_attachment_view. We need these structs to
implement the type-safety that arrived in the 0.132 header.

vk/meta: Fix declared type of a shader module

s/VkShader/VkShaderModule/

I'm looking forward to a type-safe vulkan.h ;)

vk: Remove struct anv_object

Trivial removal because vkDestroyObject() no longer uses it.

vk/device: More documentation on surface state flushing

vk/device: explain why a flush is necessary

Jason found this from experimenting, but the docs give a reasonable
explanation of why it's necessary.

vk: Fix indentation of anv_dynamic_cb_state

vk: Add finishmes for VkDescriptorPool

VkDescriptorPool is a stub object. As a consequence, it's impossible to
free descriptor set memory.

vk: Add vulkan-138 and remove vulkan-0.132

Now, 138 is the target and not 132.  Once object destruction is finished,
we can delete 138 as it will be identical to vulkan.h

vk/device: Add stub support for command pools

Real support isn't really that far away.  We just need a data structure
with a linked list and a few tests.

vk/vulkan.h: Add the stuff for cross-queue resource sharing

We only have one queue, so this is currently a no-op on our implementation.

vk/vulkan.h: Add a couple of size fields for specialization constants

vk/vulkan.h: Move around buffer image granularities

vk: Add stubs for all the sparse resource stuff

vk/image: Add a stub for the new ImageFormatProperties function

This lets the client query about things like multisample.  We don't do
multisample right now, so I'll let Chad deal with that when he gets to it.

vk/vulkan.h: Rename FormatInfo to FormatProperties

vk/vulkan.h: Re-order some #define's

vk/vulkan.h: Rename a function parameter

vk: Remove abreviations

vk: Add the new extension/layer enumeration entrypoints

vk/vulkan.h: Change maxAnisotropy to a float

vk/vulkan.h: Add the VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT flag