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

vk: Fix GLSL_VK_SHADER macro

Stringify doesn't work with __ARGV__. The last macro argument swallows
up excess arguments and as such we can just stringify that.

vk: Fix warning from missing initializer

Struct initializers need to be { 0, } to zero out the variable they're
initializing.

vk: Build binding tables at bind descriptor time

This changes the way descriptor sets and layouts work so that we fill
out binding table contents at the time we bind descriptor sets. We
manipulate the binding table contents and sampler state in a shadow-copy
in anv_cmd_buffer. At draw time, we allocate the actual binding table
and sampler state and flush the anv_cmd_buffer copies.

vk: Update the bind map length to reflect MAX_SETS

vk: Flip back to using memfd for the allocators

vk: Rename dyn_state_pool to dynamic_state_pool

Given that we already tolerate surface_state_pool and the even longer
instruction_state_pool, there's no reason to arbitrarily abbreviate
dynamic.

vk: Consolidate image, buffer and color attachment views

These are all just surface state, offset and a bo.

vk: Add a GLSL scraper utility

This new utility, glsl_scraper.py scrapes C files for instances of the
GLSL_VK_SHADER macro, pulls out the shader source, and compiles it to
SPIR-V.  The compilation is done using glslValidator.  The result is then
placed into another C file as arrays of dwords that can be easiliy handed
to a Vulkan driver.

vk/meta: Add a magic GLSL shader source macro

vk/meta: Add a better comment about the VS for blits

vk/test: Use VK_IMAGE_TILING_OPTIMAL for the render target

vk/test: Do a copy of the RT into a linear buffer and write that to a PNG

vk/meta: Add the start of a blit implementation

Currently, we only implement CopyImageToBuffer

vk/pipeline: Default to a SamplerCount of 1 for PS

vk/pipeline: Add an extra flag for force-disabling the vertex shader

This way we can pass in a vertex shader and yet have the pipeline emit an
empty 3DSTATE_VS packet.  We need this for meta because we need to trick
the compiler into not deleting our inputs but at the same time disable the
VS so that we can use a rectlist.  This should go away once we actually get
SPIR-V.

vk/pass: Emit a flushing pipe control at the end of the pass

This is rather crude but it at least makes sure that all the render targets
get flushed at the end of the pass.  We probably actually want to do
somthing based on image layout traansitions, but this will work for now.

vk/compiler: Set the binding table texture_start

This is by no means a complete solution to the binding table problems.
However, it does make texturing actually work.  Before, we were texturing
from the render target since they were both starting at 0.

vk/compiler: Zero the prog data

We use prog_data[stage] != NULL to determine whether or not we need to
clean up that stage.  Make sure it default to NULL.

vk/image: Stash more information in images and views

vk/meta: Save/restore more stuff in cmd_buffer_restore

vk: Install headers

I need this for building a testsuite.

vk: Add support for sampler descriptors

vk: Use a typesafe anv_descriptor struct

vk: Create and bind a sampler in vk.c

vk: Fix copy-n-paste sType in vkCreateSampler

vk: Add a dynamic state stream to anv_cmd_buffer

We'll need this for sampler state.

vk: Move struct anv_sampler to private.h

vk: Allocate layout->count number of descriptors

layout->count is the number of descriptors the application
requested. layout->total is the number of entries we need across all
stages.

vk: Fill out sampler state from API values

vk: Ignore vk executable

vk: Fix stale error handling in vkQueueSubmit