vk/meta: Add support for copying arbitrary size buffers

vk/meta: Use the biggest format possible for buffer copies

This should substantially improve throughput of buffer copies.

vk/meta: Fix buffer copy extents

vk/meta: Use texture() instead of texture2D()

vk: Use binding instead of index in uniform layout qualifiers

This more closely matches what the Vulkan docs say to do.

vk/glsl_scraper: Add a --glsl-only option

vk/glsl_scraper: Use the line number from the end of the macro

We used to use the line number from the start of the macro but this doesn't
seem to match the c preprocessor

vk/glsl_scraper: Don't open files until needed

This prevents us from writing an empty file when the compile failed.

vk: Call finish for binding table state stream

vk/meta: Use the new *view_init functions and stack-allocated views

This should save us a good deal of the leakage that meta currently has.

vk/image: Factor view creation out into separate *_init functions

The *_init functions work basically the same as the Vulkan entrypoints
except that they act on an already-created view and take an optional
command buffer option.  If a command buffer is given, the surface state is
allocated out of the command buffer's state stream.

Revert "vk/allocator: Don't use memfd when valgrind is detected"

This reverts commit b6ab076d6b7dd91ce0dda8741ba974b2402fa726.

It turns out setting USE_MEMFD to 0 is really bad because it means we can't
resize the pool.  Besides, valgrind SVN handles memfd so we really don't
need this fallback for valgrind anymore.

vk: Use a separate block pool and state stream for binding tables

The binding table pointers packet only allows for a 16-bit binding table
address so all binding tables have to be in the first 64 KB of the surface
state BO.  We solve this by adding a slave block pool that pulls off the
first 64 KB worth of blocks and reserves them for binding tables.

vk/allocator: Add a concept of a slave block pool

We probably need a better name but this will do for now.

vk/test: Add test that prints format features

vk/test: Test timestamps and occlusion queries

vk: Make timestamp command work correctly

This was using the wrong timestamp register and needs to write a 64 bit
value.

vk: Make occlusion query work, both copy and get functions

vk: Update generated header files

This fixes a problem where register addresses where incorrectly shifted.

vk: Only fill render targets for meta clear

Clear inherits the render targets from the current render pass. This
means we need to fill out the binding table after switching to meta
bindings. However, meta copies etc happen outside a render pass and
break when we try to fill in the render targets. This change fills the
render targets only for meta clear.

vk/pipeline: Use a state_stream for storing programs

Previously, we were effectively using a state_stream, it was just
hand-rolled based on a block pool.  Now we actually use the data structure.

vk/allocator: Add support for valgrind tracking of state pools and streams

We leave the block pool untracked so that reads/writes to freed blocks
will get caught and do the tracking at the state pool/stream level.  We
have to do a few extra gymnastics for streams because valgrind works in
terms of poitners and we work in terms of separate map and offset.
Fortunately, the users of the state pool and stream should always be using
the map pointer provided in the anv_state structure.  We just have to
track, per block, the map that was used when we initially got the block.
Then we can make sure we always use that map and valgrind should stay
happy.

vk/allocator: Don't use memfd when valgrind is detected

vk/allocator: Assert that block_pool_grow succeeds

vk/gem: VG_CLEAR the padding for the gem_mmap struct

vk/meta: Rework the indentation style

No functional change.

vk: Provide more realistic values for device info

vk: Use a temporary buffer for formatting in finishme

This is more likely to avoid breaking up the message when racing with
other threads.

vk/meta: Add an initial implementation of vkCmdCopyBuffer

Compile-tested only

vk/meta: Add an initial implementation of vkCmdCopyBufferToImage

Compile-tested only

vk/meta: Add an initial implementation of vkCmdBlitImage

Compile-tested only

vk/meta: Add an initial implementation of vkCmdCopyImage

Compile-tested only

vk/gem: Set the gem_mmap.flags parameter to 0 if it exists

vk/gem: Only VK_CLEAR the addr_ptr in gen_mmap

vk: Add a logger wrapper for the generated entrypoint

vk/gem: Just return -1 from anv_gem_wait() on error

We were returning -errno, unlike all the other gem functions.

vk: Fix vkGetOjectInfo return values

We weren't properly returning the allocation count.

vk: Implement fences

This basic implementation uses a throw-away bo for synchronization.

vk/meta: Use anv_* internal entrypoints

vk: Implement allocation count query

vk: Change pData/pDataSize semantics

We now always copy the entire struct unless pData is NULL and
unconditionally write back the struct size. It's not clear this is
useful if the structs may grow over time, but it seems to be the
expected behaviour for now.

vk: Return VK_SUCCESS from vkAllocDescriptorSets

This should've been returning VK_SUCCESS all along.

vk: Return VK_SUCCESS for all descriptor pool entry points

vk: Start Implementing vkGetFormatInfo()

We move the format table and vkGetFormatInfo to their own file in the
process.

vk: Add script for generating ifunc entry points

This lets us generate a hash table for vkGetProcAddress and lets us call
public functions internally without the public entrypoint overhead.

vk: Fix vulkan header inconsistency

The function pointer typedef and the function prototype for
vkCmdClearColorImage() didn't agree. Fix the typedef to match the
prototype.

vk: Add function pointer typedef for intel extension

Also guard function prototype by VK_PROTOTYPES.

vk: Add missing VKAPI for vkQueueRemoveMemReferences

Merge remote-tracking branch 'fdo-personal/wip/nir-vtn' into vulkan

This adds the SPIR-V -> NIR translator.

nir/spirv: Don't assert that the current block is empty

It's possible that someone will give us SPIR-V code in which someone
needlessly branches to new blocks.  We should handle that ok now.

nir/spirv: Add initial support for samplers

nir/spirv: Move Exp and Log to the list of currently unhandled ALU ops

NIR doesn't have the native opcodes for them anymore

nir/types: Add support for sampler types

nir/spirv: Make the global constants in spirv.h static

I've been promissed in a bug that this will be fixed in a future version of
the header.  However, in the interest of my branch building, I'm adding
these changes in myself for the moment.

nir/spirv: Handle jump-to-loop in a more general way

nir/spirv: Handle boolean uniforms correctly

nir/spirv: Handle control-flow with loops

nir/spirv: Set a name on temporary variables

nir/spirv: Use the correct length for copying string literals

nir/spirv: Make vtn_ssa_value handle constants as well as ssa values

nir/spirv: Add initial support for GLSL 4.50 builtins

nir/spirv: Split the core datastructures into a header file

nir/spirv: Use the builder for all instructions

We don't actually use it to create all the instructions but we do use it
for insertion always.  This should make things far more consistent for
implementing extended instructions.

nir/spirv: Add support for a bunch of ALU operations

nir/spirv: Add support for indirect array accesses

nir/spirv: Explicitly type constants and SSA values

nir/spirv: Handle OpBranchConditional

We do control-flow handling as a two-step process.  The first step is to
walk the instructions list and record various information about blocks and
functions.  This is where the acutal nir_function_overload objects get
created.  We also record the start/stop instruction for each block.  Then
a second pass walks over each of the functions and over the blocks in each
function in a way that's NIR-friendly and actually parses the instructions.

nir/spirv: Add a helper for getting a value as an SSA value

nir/spirv: Split instruction handling into preamble and body sections

nir/spirv: Implement load/store instructiosn

nir: Add a helper for getting the tail of a deref chain

nir/spirv: Actaully add variables to the funciton or shader

nir/spirv: Add a vtn_untyped_value helper

nir/spirv: Use vtn_value in the types code and fix a off-by-one error

nir/types: Add an is_vector_or_scalar helper

nir/spirv: Add support for deref chains

nir/types: Add a scalar type constructor

nir/spirv: Add support for OpLabel

nir/spirv: Add support for declaring functions

nir/types: Add accessors for function parameter/return types

nir/spirv: Add support for declaring variables

Deref chains and variable load/store operations are still missing.

nir/spirv: Add support for constants

nir/spirv: Add basic support for types

nir/types: Add more helpers for creating types

glsl/types: Expose the function_param and struct_field structs to C

Previously, they were hidden behind a #ifdef __cplusplus so C wouldn't find
them.  This commit simpliy moves the ifdef.

glsl/types: Add support for function types

glsl: Add GLSL_TYPE_FUNCTION to the base types enums

nir/spirv: Rework the way values are added

Instead of having functions to add values and set various things, we just
have a function that does a few asserts and then returns the value.  The
caller is then responsible for setting the various fields.

nir/spirv: Add stub support for extension instructions

REVERT: Add a simple helper program for testing SPIR-V -> NIR translation

glsl/compiler: Move the error_no_memory stub to standalone_scaffolding.cpp

nir: Add the start of a SPIR-V to NIR translator

At the moment, it can handle the very basics of strings and can ignore
debug instructions.  It also has basic support for decorations.

nir: Import the revision 30 SPIR-V header from Khronos

vk/device: Use bias rather than layers for computing binding table size

Because we statically use the first 8 binding table entries for render
targets, we need to create a table of size 8 + surfaces.

vk/meta: Make clear a no-op if no layers need clearing

Among other things, this prevents recursive meta.

vk/meta: Save and restore the old bindings pointer

If we don't do this then recursive meta is completely broken.  What happens
is that the outer meta call may change the bindings pointer and the inner
meta call will change it again and, when it exits set it back to the
default.  However, the outer meta call may be relying on it being left
alone so it uses the non-meta descriptor sets instead of its own.

vk/device: Simplify surface_count calculation

vk/glsl_helpers: Fix GLSL_VK_SHADER with respect to commas

Previously, the GLSL_VK_SHADER macro didn't work if the shader contained
commas outside of parentheses due to the way the C preprocessor works.
This commit fixes this by making it variadic again and doing it correctly
this time.

vk: Make cmd_buffer->bindings a pointer

This lets us save and restore efficiently by just moving the pointer to
a temporary bindings struct for meta.

vk: Move vertex buffers into struct anv_bindings