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

vk: Fix for out-of-tree builds

vk: Remove render pass stub call

This isn't really a stub.

vk: Add WSI implementation

vk: Add debug stubs

vk: Mark remaining unsupported formats as such

vk: Mark VK_FORMAT_UNDEFINED as 1 cpp, 1 channel

vk: Stream surface state instead of using the surface pool

Since the binding table pointer is only 16 bits, we can only have 64kb
of binding table state allocated at any given time. With a block size of
1kb, that amounts to just 64 command buffers, which is not enough.

vk: Use surface_format_info from dri driver for vkGetFormatInfo

vk: Fix result of vkCreateInstance

When fill_physical_device() fails, don't return VK_SUCCESS.

vk/compiler: Add shader language detection

This commit adds support for the LunarG GLSL back-door as well as detecting
regular GLSL and SPIR-V.  The SPIR-V path doesn't exist yet, so that will
cause an assert-fail.

vk/test: Add a test for testing buffer copies

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