2015-05-04 20:25:09 +01:00
|
|
|
/*
|
|
|
|
* Copyright © 2015 Intel Corporation
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
* IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Jason Ekstrand (jason@jlekstrand.net)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2017-03-20 16:04:17 +00:00
|
|
|
#ifndef _VTN_PRIVATE_H_
|
|
|
|
#define _VTN_PRIVATE_H_
|
|
|
|
|
2017-08-17 00:15:23 +01:00
|
|
|
#include <setjmp.h>
|
|
|
|
|
2015-12-28 19:49:33 +00:00
|
|
|
#include "nir/nir.h"
|
|
|
|
#include "nir/nir_builder.h"
|
2017-06-07 19:45:41 +01:00
|
|
|
#include "util/u_dynarray.h"
|
2015-05-04 20:25:09 +01:00
|
|
|
#include "nir_spirv.h"
|
|
|
|
#include "spirv.h"
|
|
|
|
|
|
|
|
struct vtn_builder;
|
|
|
|
struct vtn_decoration;
|
|
|
|
|
2017-08-17 00:04:08 +01:00
|
|
|
void vtn_log(struct vtn_builder *b, enum nir_spirv_debug_level level,
|
|
|
|
size_t spirv_offset, const char *message);
|
|
|
|
|
|
|
|
void vtn_logf(struct vtn_builder *b, enum nir_spirv_debug_level level,
|
|
|
|
size_t spirv_offset, const char *fmt, ...) PRINTFLIKE(4, 5);
|
|
|
|
|
|
|
|
#define vtn_info(...) vtn_logf(b, NIR_SPIRV_DEBUG_LEVEL_INFO, 0, __VA_ARGS__)
|
|
|
|
|
|
|
|
void _vtn_warn(struct vtn_builder *b, const char *file, unsigned line,
|
|
|
|
const char *fmt, ...) PRINTFLIKE(4, 5);
|
|
|
|
#define vtn_warn(...) _vtn_warn(b, __FILE__, __LINE__, __VA_ARGS__)
|
|
|
|
|
2018-06-01 13:27:24 +01:00
|
|
|
void _vtn_err(struct vtn_builder *b, const char *file, unsigned line,
|
|
|
|
const char *fmt, ...) PRINTFLIKE(4, 5);
|
|
|
|
#define vtn_err(...) _vtn_err(b, __FILE__, __LINE__, __VA_ARGS__)
|
|
|
|
|
2017-08-17 00:15:23 +01:00
|
|
|
/** Fail SPIR-V parsing
|
|
|
|
*
|
|
|
|
* This function logs an error and then bails out of the shader compile using
|
|
|
|
* longjmp. This being safe relies on two things:
|
|
|
|
*
|
|
|
|
* 1) We must guarantee that setjmp is called after allocating the builder
|
|
|
|
* and setting up b->debug (so that logging works) but before before any
|
|
|
|
* errors have a chance to occur.
|
|
|
|
*
|
|
|
|
* 2) While doing the SPIR-V -> NIR conversion, we need to be careful to
|
|
|
|
* ensure that all heap allocations happen through ralloc and are parented
|
|
|
|
* to the builder. This way they will get properly cleaned up on error.
|
|
|
|
*
|
|
|
|
* 3) We must ensure that _vtn_fail is never called while a mutex lock or a
|
|
|
|
* reference to any other resource is held with the exception of ralloc
|
|
|
|
* objects which are parented to the builder.
|
|
|
|
*
|
|
|
|
* So long as these two things continue to hold, we can easily longjmp back to
|
|
|
|
* spirv_to_nir(), clean up the builder, and return NULL.
|
|
|
|
*/
|
2018-03-30 18:07:46 +01:00
|
|
|
NORETURN void
|
|
|
|
_vtn_fail(struct vtn_builder *b, const char *file, unsigned line,
|
|
|
|
const char *fmt, ...) PRINTFLIKE(4, 5);
|
|
|
|
|
2017-08-17 00:15:23 +01:00
|
|
|
#define vtn_fail(...) _vtn_fail(b, __FILE__, __LINE__, __VA_ARGS__)
|
|
|
|
|
|
|
|
/** Fail if the given expression evaluates to true */
|
|
|
|
#define vtn_fail_if(expr, ...) \
|
|
|
|
do { \
|
|
|
|
if (unlikely(expr)) \
|
|
|
|
vtn_fail(__VA_ARGS__); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
/** Assert that a condition is true and, if it isn't, vtn_fail
|
|
|
|
*
|
|
|
|
* This macro is transitional only and should not be used in new code. Use
|
|
|
|
* vtn_fail_if and provide a real message instead.
|
|
|
|
*/
|
|
|
|
#define vtn_assert(expr) \
|
|
|
|
do { \
|
|
|
|
if (!likely(expr)) \
|
|
|
|
vtn_fail("%s", #expr); \
|
|
|
|
} while (0)
|
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
enum vtn_value_type {
|
|
|
|
vtn_value_type_invalid = 0,
|
|
|
|
vtn_value_type_undef,
|
|
|
|
vtn_value_type_string,
|
|
|
|
vtn_value_type_decoration_group,
|
|
|
|
vtn_value_type_type,
|
|
|
|
vtn_value_type_constant,
|
2017-06-29 18:33:27 +01:00
|
|
|
vtn_value_type_pointer,
|
2015-05-04 20:25:09 +01:00
|
|
|
vtn_value_type_function,
|
|
|
|
vtn_value_type_block,
|
|
|
|
vtn_value_type_ssa,
|
2015-05-04 23:17:56 +01:00
|
|
|
vtn_value_type_extension,
|
2015-11-14 01:26:22 +00:00
|
|
|
vtn_value_type_image_pointer,
|
2015-11-15 06:32:54 +00:00
|
|
|
vtn_value_type_sampled_image,
|
2015-05-04 20:25:09 +01:00
|
|
|
};
|
|
|
|
|
2015-12-29 02:19:40 +00:00
|
|
|
enum vtn_branch_type {
|
|
|
|
vtn_branch_type_none,
|
2015-12-29 18:24:54 +00:00
|
|
|
vtn_branch_type_switch_break,
|
|
|
|
vtn_branch_type_switch_fallthrough,
|
|
|
|
vtn_branch_type_loop_break,
|
|
|
|
vtn_branch_type_loop_continue,
|
2015-12-29 02:19:40 +00:00
|
|
|
vtn_branch_type_discard,
|
|
|
|
vtn_branch_type_return,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum vtn_cf_node_type {
|
|
|
|
vtn_cf_node_type_block,
|
|
|
|
vtn_cf_node_type_if,
|
|
|
|
vtn_cf_node_type_loop,
|
|
|
|
vtn_cf_node_type_switch,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct vtn_cf_node {
|
|
|
|
struct list_head link;
|
|
|
|
enum vtn_cf_node_type type;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct vtn_loop {
|
|
|
|
struct vtn_cf_node node;
|
|
|
|
|
|
|
|
/* The main body of the loop */
|
|
|
|
struct list_head body;
|
|
|
|
|
|
|
|
/* The "continue" part of the loop. This gets executed after the body
|
|
|
|
* and is where you go when you hit a continue.
|
|
|
|
*/
|
|
|
|
struct list_head cont_body;
|
|
|
|
|
|
|
|
SpvLoopControlMask control;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct vtn_if {
|
|
|
|
struct vtn_cf_node node;
|
|
|
|
|
|
|
|
uint32_t condition;
|
|
|
|
|
|
|
|
enum vtn_branch_type then_type;
|
|
|
|
struct list_head then_body;
|
|
|
|
|
|
|
|
enum vtn_branch_type else_type;
|
|
|
|
struct list_head else_body;
|
|
|
|
|
|
|
|
SpvSelectionControlMask control;
|
|
|
|
};
|
|
|
|
|
2015-12-29 18:24:54 +00:00
|
|
|
struct vtn_case {
|
|
|
|
struct list_head link;
|
|
|
|
|
|
|
|
struct list_head body;
|
|
|
|
|
2016-01-06 00:18:01 +00:00
|
|
|
/* The block that starts this case */
|
|
|
|
struct vtn_block *start_block;
|
|
|
|
|
2015-12-29 18:24:54 +00:00
|
|
|
/* The fallthrough case, if any */
|
|
|
|
struct vtn_case *fallthrough;
|
|
|
|
|
|
|
|
/* The uint32_t values that map to this case */
|
2017-06-07 19:45:41 +01:00
|
|
|
struct util_dynarray values;
|
2015-12-29 18:24:54 +00:00
|
|
|
|
|
|
|
/* True if this is the default case */
|
|
|
|
bool is_default;
|
|
|
|
|
|
|
|
/* Initialized to false; used when sorting the list of cases */
|
|
|
|
bool visited;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct vtn_switch {
|
|
|
|
struct vtn_cf_node node;
|
|
|
|
|
|
|
|
uint32_t selector;
|
|
|
|
|
|
|
|
struct list_head cases;
|
|
|
|
};
|
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
struct vtn_block {
|
2015-12-29 02:19:40 +00:00
|
|
|
struct vtn_cf_node node;
|
|
|
|
|
|
|
|
/** A pointer to the label instruction */
|
2015-05-04 20:25:09 +01:00
|
|
|
const uint32_t *label;
|
2015-12-29 02:19:40 +00:00
|
|
|
|
|
|
|
/** A pointer to the merge instruction (or NULL if non exists) */
|
|
|
|
const uint32_t *merge;
|
|
|
|
|
|
|
|
/** A pointer to the branch instruction that ends this block */
|
2015-05-04 20:25:09 +01:00
|
|
|
const uint32_t *branch;
|
2015-12-29 02:19:40 +00:00
|
|
|
|
|
|
|
enum vtn_branch_type branch_type;
|
|
|
|
|
|
|
|
/** Points to the loop that this block starts (if it starts a loop) */
|
|
|
|
struct vtn_loop *loop;
|
|
|
|
|
2015-12-29 18:24:54 +00:00
|
|
|
/** Points to the switch case started by this block (if any) */
|
|
|
|
struct vtn_case *switch_case;
|
|
|
|
|
2016-09-16 05:12:34 +01:00
|
|
|
/** Every block ends in a nop intrinsic so that we can find it again */
|
|
|
|
nir_intrinsic_instr *end_nop;
|
2015-05-04 20:25:09 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
struct vtn_function {
|
|
|
|
struct exec_node node;
|
|
|
|
|
2018-03-23 01:44:06 +00:00
|
|
|
struct vtn_type *type;
|
|
|
|
|
2017-10-19 18:11:22 +01:00
|
|
|
bool referenced;
|
|
|
|
bool emitted;
|
|
|
|
|
2015-12-18 23:07:16 +00:00
|
|
|
nir_function_impl *impl;
|
2015-05-04 20:25:09 +01:00
|
|
|
struct vtn_block *start_block;
|
2015-06-23 18:34:55 +01:00
|
|
|
|
2015-12-29 02:19:40 +00:00
|
|
|
struct list_head body;
|
|
|
|
|
2015-06-23 18:34:55 +01:00
|
|
|
const uint32_t *end;
|
2015-12-29 02:19:40 +00:00
|
|
|
|
|
|
|
SpvFunctionControlMask control;
|
2015-05-04 20:25:09 +01:00
|
|
|
};
|
|
|
|
|
2018-03-30 18:10:11 +01:00
|
|
|
typedef bool (*vtn_instruction_handler)(struct vtn_builder *, SpvOp,
|
2015-05-04 20:25:09 +01:00
|
|
|
const uint32_t *, unsigned);
|
|
|
|
|
2015-12-29 20:09:32 +00:00
|
|
|
void vtn_build_cfg(struct vtn_builder *b, const uint32_t *words,
|
|
|
|
const uint32_t *end);
|
|
|
|
void vtn_function_emit(struct vtn_builder *b, struct vtn_function *func,
|
|
|
|
vtn_instruction_handler instruction_handler);
|
|
|
|
|
2015-12-29 02:19:40 +00:00
|
|
|
const uint32_t *
|
|
|
|
vtn_foreach_instruction(struct vtn_builder *b, const uint32_t *start,
|
|
|
|
const uint32_t *end, vtn_instruction_handler handler);
|
|
|
|
|
2015-06-18 00:25:38 +01:00
|
|
|
struct vtn_ssa_value {
|
|
|
|
union {
|
|
|
|
nir_ssa_def *def;
|
|
|
|
struct vtn_ssa_value **elems;
|
|
|
|
};
|
|
|
|
|
2015-12-23 20:45:13 +00:00
|
|
|
/* For matrices, if this is non-NULL, then this value is actually the
|
|
|
|
* transpose of some other value. The value that `transposed` points to
|
|
|
|
* always dominates this value.
|
2015-06-19 02:52:44 +01:00
|
|
|
*/
|
|
|
|
struct vtn_ssa_value *transposed;
|
|
|
|
|
2015-06-18 00:25:38 +01:00
|
|
|
const struct glsl_type *type;
|
|
|
|
};
|
|
|
|
|
2017-06-29 18:33:37 +01:00
|
|
|
enum vtn_base_type {
|
|
|
|
vtn_base_type_void,
|
|
|
|
vtn_base_type_scalar,
|
|
|
|
vtn_base_type_vector,
|
|
|
|
vtn_base_type_matrix,
|
|
|
|
vtn_base_type_array,
|
|
|
|
vtn_base_type_struct,
|
2017-06-29 18:33:39 +01:00
|
|
|
vtn_base_type_pointer,
|
2017-06-29 18:33:37 +01:00
|
|
|
vtn_base_type_image,
|
|
|
|
vtn_base_type_sampler,
|
2017-12-08 07:42:13 +00:00
|
|
|
vtn_base_type_sampled_image,
|
2017-06-29 18:33:37 +01:00
|
|
|
vtn_base_type_function,
|
|
|
|
};
|
|
|
|
|
2015-07-02 22:24:12 +01:00
|
|
|
struct vtn_type {
|
2017-06-29 18:33:37 +01:00
|
|
|
enum vtn_base_type base_type;
|
|
|
|
|
2015-07-02 22:24:12 +01:00
|
|
|
const struct glsl_type *type;
|
|
|
|
|
2018-01-03 16:41:42 +00:00
|
|
|
/* The SPIR-V id of the given type. */
|
|
|
|
uint32_t id;
|
2016-01-21 20:41:45 +00:00
|
|
|
|
2017-10-19 01:59:47 +01:00
|
|
|
/* Specifies the length of complex types.
|
|
|
|
*
|
|
|
|
* For Workgroup pointers, this is the size of the referenced type.
|
|
|
|
*/
|
2017-06-29 18:33:37 +01:00
|
|
|
unsigned length;
|
|
|
|
|
2017-06-29 00:31:06 +01:00
|
|
|
/* for arrays, matrices and pointers, the array stride */
|
|
|
|
unsigned stride;
|
|
|
|
|
2017-06-29 18:33:36 +01:00
|
|
|
union {
|
|
|
|
/* Members for scalar, vector, and array-like types */
|
|
|
|
struct {
|
|
|
|
/* for arrays, the vtn_type for the elements of the array */
|
|
|
|
struct vtn_type *array_element;
|
|
|
|
|
|
|
|
/* for matrices, whether the matrix is stored row-major */
|
|
|
|
bool row_major:1;
|
|
|
|
|
|
|
|
/* Whether this type, or a parent type, has been decorated as a
|
|
|
|
* builtin
|
|
|
|
*/
|
|
|
|
bool is_builtin:1;
|
|
|
|
|
|
|
|
/* Which built-in to use */
|
|
|
|
SpvBuiltIn builtin;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Members for struct types */
|
|
|
|
struct {
|
|
|
|
/* for structures, the vtn_type for each member */
|
|
|
|
struct vtn_type **members;
|
|
|
|
|
|
|
|
/* for structs, the offset of each member */
|
|
|
|
unsigned *offsets;
|
|
|
|
|
|
|
|
/* for structs, whether it was decorated as a "non-SSBO-like" block */
|
|
|
|
bool block:1;
|
|
|
|
|
|
|
|
/* for structs, whether it was decorated as an "SSBO-like" block */
|
|
|
|
bool buffer_block:1;
|
|
|
|
|
|
|
|
/* for structs with block == true, whether this is a builtin block
|
|
|
|
* (i.e. a block that contains only builtins).
|
|
|
|
*/
|
|
|
|
bool builtin_block:1;
|
|
|
|
};
|
|
|
|
|
2017-06-29 18:33:39 +01:00
|
|
|
/* Members for pointer types */
|
|
|
|
struct {
|
|
|
|
/* For pointers, the vtn_type for dereferenced type */
|
|
|
|
struct vtn_type *deref;
|
|
|
|
|
|
|
|
/* Storage class for pointers */
|
|
|
|
SpvStorageClass storage_class;
|
2017-10-19 01:59:47 +01:00
|
|
|
|
|
|
|
/* Required alignment for pointers */
|
|
|
|
uint32_t align;
|
2017-06-29 18:33:39 +01:00
|
|
|
};
|
|
|
|
|
2017-06-29 18:33:36 +01:00
|
|
|
/* Members for image types */
|
|
|
|
struct {
|
2017-06-29 18:33:37 +01:00
|
|
|
/* For images, indicates whether it's sampled or storage */
|
|
|
|
bool sampled;
|
|
|
|
|
2017-06-29 18:33:36 +01:00
|
|
|
/* Image format for image_load_store type images */
|
|
|
|
unsigned image_format;
|
|
|
|
|
|
|
|
/* Access qualifier for storage images */
|
|
|
|
SpvAccessQualifier access_qualifier;
|
|
|
|
};
|
2017-06-29 18:33:38 +01:00
|
|
|
|
2017-12-08 07:42:13 +00:00
|
|
|
/* Members for sampled image types */
|
|
|
|
struct {
|
|
|
|
/* For sampled images, the image type */
|
|
|
|
struct vtn_type *image;
|
|
|
|
};
|
|
|
|
|
2017-06-29 18:33:38 +01:00
|
|
|
/* Members for function types */
|
|
|
|
struct {
|
|
|
|
/* For functions, the vtn_type for each parameter */
|
|
|
|
struct vtn_type **params;
|
|
|
|
|
|
|
|
/* Return type for functions */
|
|
|
|
struct vtn_type *return_type;
|
|
|
|
};
|
2017-06-29 18:33:36 +01:00
|
|
|
};
|
2015-07-02 22:24:12 +01:00
|
|
|
};
|
|
|
|
|
2018-01-02 15:45:42 +00:00
|
|
|
bool vtn_types_compatible(struct vtn_builder *b,
|
|
|
|
struct vtn_type *t1, struct vtn_type *t2);
|
|
|
|
|
2016-01-21 10:09:38 +00:00
|
|
|
struct vtn_variable;
|
|
|
|
|
2016-01-21 18:20:50 +00:00
|
|
|
enum vtn_access_mode {
|
|
|
|
vtn_access_mode_id,
|
|
|
|
vtn_access_mode_literal,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct vtn_access_link {
|
|
|
|
enum vtn_access_mode mode;
|
|
|
|
uint32_t id;
|
|
|
|
};
|
|
|
|
|
2016-01-21 01:11:55 +00:00
|
|
|
struct vtn_access_chain {
|
|
|
|
uint32_t length;
|
|
|
|
|
2017-06-29 00:31:06 +01:00
|
|
|
/** Whether or not to treat the base pointer as an array. This is only
|
|
|
|
* true if this access chain came from an OpPtrAccessChain.
|
|
|
|
*/
|
|
|
|
bool ptr_as_array;
|
|
|
|
|
2017-06-29 18:33:33 +01:00
|
|
|
/** Struct elements and array offsets.
|
|
|
|
*
|
|
|
|
* This is an array of 1 so that it can conveniently be created on the
|
|
|
|
* stack but the real length is given by the length field.
|
|
|
|
*/
|
|
|
|
struct vtn_access_link link[1];
|
2016-01-21 01:11:55 +00:00
|
|
|
};
|
|
|
|
|
2016-01-21 10:09:38 +00:00
|
|
|
enum vtn_variable_mode {
|
|
|
|
vtn_variable_mode_local,
|
|
|
|
vtn_variable_mode_global,
|
2017-06-22 12:00:08 +01:00
|
|
|
vtn_variable_mode_uniform,
|
2016-01-21 10:09:38 +00:00
|
|
|
vtn_variable_mode_ubo,
|
|
|
|
vtn_variable_mode_ssbo,
|
|
|
|
vtn_variable_mode_push_constant,
|
|
|
|
vtn_variable_mode_workgroup,
|
|
|
|
vtn_variable_mode_input,
|
|
|
|
vtn_variable_mode_output,
|
|
|
|
};
|
|
|
|
|
2017-06-29 18:33:28 +01:00
|
|
|
struct vtn_pointer {
|
|
|
|
/** The variable mode for the referenced data */
|
|
|
|
enum vtn_variable_mode mode;
|
|
|
|
|
|
|
|
/** The dereferenced type of this pointer */
|
|
|
|
struct vtn_type *type;
|
|
|
|
|
2017-06-29 18:33:39 +01:00
|
|
|
/** The pointer type of this pointer
|
|
|
|
*
|
|
|
|
* This may be NULL for some temporary pointers constructed as part of a
|
|
|
|
* large load, store, or copy. It MUST be valid for all pointers which are
|
|
|
|
* stored as SPIR-V SSA values.
|
|
|
|
*/
|
|
|
|
struct vtn_type *ptr_type;
|
|
|
|
|
2017-06-29 18:33:34 +01:00
|
|
|
/** The referenced variable, if known
|
|
|
|
*
|
|
|
|
* This field may be NULL if the pointer uses a (block_index, offset) pair
|
2018-03-23 15:22:54 +00:00
|
|
|
* instead of an access chain or if the access chain starts at a deref.
|
2017-06-29 18:33:34 +01:00
|
|
|
*/
|
2017-06-29 18:33:28 +01:00
|
|
|
struct vtn_variable *var;
|
|
|
|
|
2018-03-23 15:22:54 +00:00
|
|
|
/** The deref at the base of the chain
|
|
|
|
*
|
|
|
|
* This field may be NULL if the pointer uses a (block_index, offset) pair
|
|
|
|
* instead of an access chain or if the access chain starts at a variable.
|
|
|
|
*/
|
|
|
|
nir_deref_instr *deref;
|
|
|
|
|
2017-06-29 18:33:28 +01:00
|
|
|
/** An access chain describing how to get from var to the referenced data
|
|
|
|
*
|
2017-06-29 18:33:34 +01:00
|
|
|
* This field may be NULL if the pointer references the entire variable or
|
|
|
|
* if a (block_index, offset) pair is used instead of an access chain.
|
2017-06-29 18:33:28 +01:00
|
|
|
*/
|
|
|
|
struct vtn_access_chain *chain;
|
2017-06-29 18:33:34 +01:00
|
|
|
|
|
|
|
/** A (block_index, offset) pair representing a UBO or SSBO position. */
|
|
|
|
struct nir_ssa_def *block_index;
|
|
|
|
struct nir_ssa_def *offset;
|
2017-06-29 18:33:28 +01:00
|
|
|
};
|
|
|
|
|
2016-01-21 10:09:38 +00:00
|
|
|
struct vtn_variable {
|
|
|
|
enum vtn_variable_mode mode;
|
|
|
|
|
|
|
|
struct vtn_type *type;
|
|
|
|
|
|
|
|
unsigned descriptor_set;
|
|
|
|
unsigned binding;
|
2018-02-23 16:07:52 +00:00
|
|
|
bool explicit_binding;
|
2016-11-14 22:22:56 +00:00
|
|
|
unsigned input_attachment_index;
|
2016-09-25 22:23:55 +01:00
|
|
|
bool patch;
|
2016-01-21 10:09:38 +00:00
|
|
|
|
|
|
|
nir_variable *var;
|
|
|
|
|
2017-10-19 01:59:47 +01:00
|
|
|
int shared_location;
|
|
|
|
|
2017-06-20 17:06:44 +01:00
|
|
|
/**
|
|
|
|
* In some early released versions of GLSLang, it implemented all function
|
|
|
|
* calls by making copies of all parameters into temporary variables and
|
|
|
|
* passing those variables into the function. It even did so for samplers
|
|
|
|
* and images which violates the SPIR-V spec. Unfortunately, two games
|
|
|
|
* (Talos Principle and Doom) shipped with this old version of GLSLang and
|
|
|
|
* also happen to pass samplers into functions. Talos Principle received
|
|
|
|
* an update fairly shortly after release with an updated GLSLang. Doom,
|
|
|
|
* on the other hand, has never received an update so we need to work
|
|
|
|
* around this GLSLang issue in SPIR-V -> NIR. Hopefully, we can drop this
|
|
|
|
* hack at some point in the future.
|
|
|
|
*/
|
2017-06-29 18:33:28 +01:00
|
|
|
struct vtn_pointer *copy_prop_sampler;
|
2016-01-21 10:09:38 +00:00
|
|
|
};
|
|
|
|
|
2015-11-14 01:26:22 +00:00
|
|
|
struct vtn_image_pointer {
|
2017-06-29 18:33:28 +01:00
|
|
|
struct vtn_pointer *image;
|
2015-11-14 01:26:22 +00:00
|
|
|
nir_ssa_def *coord;
|
|
|
|
nir_ssa_def *sample;
|
|
|
|
};
|
|
|
|
|
2015-11-15 06:32:54 +00:00
|
|
|
struct vtn_sampled_image {
|
2017-11-06 10:37:05 +00:00
|
|
|
struct vtn_type *type;
|
2017-06-29 18:33:28 +01:00
|
|
|
struct vtn_pointer *image; /* Image or array of images */
|
|
|
|
struct vtn_pointer *sampler; /* Sampler */
|
2015-11-15 06:32:54 +00:00
|
|
|
};
|
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
struct vtn_value {
|
|
|
|
enum vtn_value_type value_type;
|
|
|
|
const char *name;
|
|
|
|
struct vtn_decoration *decoration;
|
2017-12-06 05:39:51 +00:00
|
|
|
struct vtn_type *type;
|
2015-05-04 20:25:09 +01:00
|
|
|
union {
|
|
|
|
void *ptr;
|
|
|
|
char *str;
|
2017-12-06 05:39:51 +00:00
|
|
|
nir_constant *constant;
|
2017-06-29 18:33:28 +01:00
|
|
|
struct vtn_pointer *pointer;
|
2015-11-14 01:26:22 +00:00
|
|
|
struct vtn_image_pointer *image;
|
2015-11-15 06:32:54 +00:00
|
|
|
struct vtn_sampled_image *sampled_image;
|
2015-05-04 20:25:09 +01:00
|
|
|
struct vtn_function *func;
|
|
|
|
struct vtn_block *block;
|
2015-06-18 00:25:38 +01:00
|
|
|
struct vtn_ssa_value *ssa;
|
2015-05-04 23:17:56 +01:00
|
|
|
vtn_instruction_handler ext_handler;
|
2015-05-04 20:25:09 +01:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2015-12-31 00:38:16 +00:00
|
|
|
#define VTN_DEC_DECORATION -1
|
|
|
|
#define VTN_DEC_EXECUTION_MODE -2
|
|
|
|
#define VTN_DEC_STRUCT_MEMBER0 0
|
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
struct vtn_decoration {
|
|
|
|
struct vtn_decoration *next;
|
2015-12-31 00:38:16 +00:00
|
|
|
|
|
|
|
/* Specifies how to apply this decoration. Negative values represent a
|
|
|
|
* decoration or execution mode. (See the VTN_DEC_ #defines above.)
|
|
|
|
* Non-negative values specify that it applies to a structure member.
|
|
|
|
*/
|
|
|
|
int scope;
|
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
const uint32_t *literals;
|
|
|
|
struct vtn_value *group;
|
2015-12-31 00:38:16 +00:00
|
|
|
|
|
|
|
union {
|
|
|
|
SpvDecoration decoration;
|
|
|
|
SpvExecutionMode exec_mode;
|
|
|
|
};
|
2015-05-04 20:25:09 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
struct vtn_builder {
|
|
|
|
nir_builder nb;
|
|
|
|
|
2017-08-17 00:15:23 +01:00
|
|
|
/* Used by vtn_fail to jump back to the beginning of SPIR-V compilation */
|
|
|
|
jmp_buf fail_jump;
|
|
|
|
|
2017-08-17 00:04:08 +01:00
|
|
|
const uint32_t *spirv;
|
2018-01-02 03:55:33 +00:00
|
|
|
size_t spirv_word_count;
|
2017-08-17 00:04:08 +01:00
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
nir_shader *shader;
|
2017-10-19 01:28:19 +01:00
|
|
|
const struct spirv_to_nir_options *options;
|
2015-05-04 20:25:09 +01:00
|
|
|
struct vtn_block *block;
|
|
|
|
|
2017-08-17 00:04:08 +01:00
|
|
|
/* Current offset, file, line, and column. Useful for debugging. Set
|
2016-01-20 02:44:44 +00:00
|
|
|
* automatically by vtn_foreach_instruction.
|
|
|
|
*/
|
2017-08-17 00:04:08 +01:00
|
|
|
size_t spirv_offset;
|
2016-01-20 02:44:44 +00:00
|
|
|
char *file;
|
|
|
|
int line, col;
|
|
|
|
|
2015-06-18 00:25:38 +01:00
|
|
|
/*
|
|
|
|
* In SPIR-V, constants are global, whereas in NIR, the load_const
|
|
|
|
* instruction we use is per-function. So while we parse each function, we
|
|
|
|
* keep a hash table of constants we've resolved to nir_ssa_value's so
|
|
|
|
* far, and we lazily resolve them when we see them used in a function.
|
|
|
|
*/
|
|
|
|
struct hash_table *const_table;
|
|
|
|
|
2015-06-23 18:34:55 +01:00
|
|
|
/*
|
2016-01-05 22:59:40 +00:00
|
|
|
* Map from phi instructions (pointer to the start of the instruction)
|
|
|
|
* to the variable corresponding to it.
|
2015-06-23 18:34:55 +01:00
|
|
|
*/
|
2016-01-05 22:59:40 +00:00
|
|
|
struct hash_table *phi_table;
|
2015-06-23 18:34:55 +01:00
|
|
|
|
2016-01-13 00:28:28 +00:00
|
|
|
unsigned num_specializations;
|
|
|
|
struct nir_spirv_specialization *specializations;
|
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
unsigned value_id_bound;
|
|
|
|
struct vtn_value *values;
|
|
|
|
|
2016-01-11 18:31:25 +00:00
|
|
|
gl_shader_stage entry_point_stage;
|
2015-12-31 01:17:12 +00:00
|
|
|
const char *entry_point_name;
|
2015-12-31 01:00:16 +00:00
|
|
|
struct vtn_value *entry_point;
|
2015-10-20 23:23:56 +01:00
|
|
|
bool origin_upper_left;
|
2016-05-18 19:06:08 +01:00
|
|
|
bool pixel_center_integer;
|
2015-05-04 20:25:09 +01:00
|
|
|
|
|
|
|
struct vtn_function *func;
|
|
|
|
struct exec_list functions;
|
2015-12-18 23:07:16 +00:00
|
|
|
|
|
|
|
/* Current function parameter index */
|
|
|
|
unsigned func_param_idx;
|
2016-01-18 17:33:56 +00:00
|
|
|
|
|
|
|
bool has_loop_continue;
|
2015-05-04 20:25:09 +01:00
|
|
|
};
|
|
|
|
|
2017-06-28 08:45:36 +01:00
|
|
|
nir_ssa_def *
|
|
|
|
vtn_pointer_to_ssa(struct vtn_builder *b, struct vtn_pointer *ptr);
|
|
|
|
struct vtn_pointer *
|
|
|
|
vtn_pointer_from_ssa(struct vtn_builder *b, nir_ssa_def *ssa,
|
|
|
|
struct vtn_type *ptr_type);
|
|
|
|
|
2017-12-12 05:42:34 +00:00
|
|
|
static inline struct vtn_value *
|
|
|
|
vtn_untyped_value(struct vtn_builder *b, uint32_t value_id)
|
|
|
|
{
|
|
|
|
vtn_fail_if(value_id >= b->value_id_bound,
|
|
|
|
"SPIR-V id %u is out-of-bounds", value_id);
|
|
|
|
return &b->values[value_id];
|
|
|
|
}
|
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
static inline struct vtn_value *
|
|
|
|
vtn_push_value(struct vtn_builder *b, uint32_t value_id,
|
|
|
|
enum vtn_value_type value_type)
|
|
|
|
{
|
2017-12-12 05:42:34 +00:00
|
|
|
struct vtn_value *val = vtn_untyped_value(b, value_id);
|
2015-05-04 20:25:09 +01:00
|
|
|
|
2017-12-12 05:42:34 +00:00
|
|
|
vtn_fail_if(val->value_type != vtn_value_type_invalid,
|
|
|
|
"SPIR-V id %u has already been written by another instruction",
|
|
|
|
value_id);
|
2015-05-04 20:25:09 +01:00
|
|
|
|
2017-12-12 05:42:34 +00:00
|
|
|
val->value_type = value_type;
|
2015-05-04 20:25:09 +01:00
|
|
|
return &b->values[value_id];
|
|
|
|
}
|
|
|
|
|
2017-06-28 10:50:33 +01:00
|
|
|
static inline struct vtn_value *
|
|
|
|
vtn_push_ssa(struct vtn_builder *b, uint32_t value_id,
|
|
|
|
struct vtn_type *type, struct vtn_ssa_value *ssa)
|
|
|
|
{
|
2017-06-28 08:45:36 +01:00
|
|
|
struct vtn_value *val;
|
|
|
|
if (type->base_type == vtn_base_type_pointer) {
|
|
|
|
val = vtn_push_value(b, value_id, vtn_value_type_pointer);
|
|
|
|
val->pointer = vtn_pointer_from_ssa(b, ssa->def, type);
|
|
|
|
} else {
|
|
|
|
val = vtn_push_value(b, value_id, vtn_value_type_ssa);
|
|
|
|
val->ssa = ssa;
|
|
|
|
}
|
2017-06-28 10:50:33 +01:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
static inline struct vtn_value *
|
|
|
|
vtn_value(struct vtn_builder *b, uint32_t value_id,
|
|
|
|
enum vtn_value_type value_type)
|
|
|
|
{
|
|
|
|
struct vtn_value *val = vtn_untyped_value(b, value_id);
|
2017-12-12 05:42:34 +00:00
|
|
|
vtn_fail_if(val->value_type != value_type,
|
|
|
|
"SPIR-V id %u is the wrong kind of value", value_id);
|
2015-05-04 20:25:09 +01:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2017-12-06 06:31:02 +00:00
|
|
|
bool
|
|
|
|
vtn_set_instruction_result_type(struct vtn_builder *b, SpvOp opcode,
|
|
|
|
const uint32_t *w, unsigned count);
|
|
|
|
|
2017-08-23 06:16:01 +01:00
|
|
|
static inline nir_constant *
|
|
|
|
vtn_constant_value(struct vtn_builder *b, uint32_t value_id)
|
|
|
|
{
|
|
|
|
return vtn_value(b, value_id, vtn_value_type_constant)->constant;
|
|
|
|
}
|
|
|
|
|
2015-06-18 00:25:38 +01:00
|
|
|
struct vtn_ssa_value *vtn_ssa_value(struct vtn_builder *b, uint32_t value_id);
|
2015-05-04 20:25:09 +01:00
|
|
|
|
2016-01-08 19:02:17 +00:00
|
|
|
struct vtn_ssa_value *vtn_create_ssa_value(struct vtn_builder *b,
|
|
|
|
const struct glsl_type *type);
|
|
|
|
|
|
|
|
struct vtn_ssa_value *vtn_ssa_transpose(struct vtn_builder *b,
|
|
|
|
struct vtn_ssa_value *src);
|
|
|
|
|
2016-01-21 01:40:49 +00:00
|
|
|
nir_ssa_def *vtn_vector_extract(struct vtn_builder *b, nir_ssa_def *src,
|
|
|
|
unsigned index);
|
|
|
|
nir_ssa_def *vtn_vector_extract_dynamic(struct vtn_builder *b, nir_ssa_def *src,
|
|
|
|
nir_ssa_def *index);
|
|
|
|
nir_ssa_def *vtn_vector_insert(struct vtn_builder *b, nir_ssa_def *src,
|
|
|
|
nir_ssa_def *insert, unsigned index);
|
|
|
|
nir_ssa_def *vtn_vector_insert_dynamic(struct vtn_builder *b, nir_ssa_def *src,
|
|
|
|
nir_ssa_def *insert, nir_ssa_def *index);
|
|
|
|
|
2018-03-16 20:35:59 +00:00
|
|
|
nir_deref_instr *vtn_nir_deref(struct vtn_builder *b, uint32_t id);
|
2016-01-21 01:11:55 +00:00
|
|
|
|
2017-06-29 18:33:28 +01:00
|
|
|
struct vtn_pointer *vtn_pointer_for_variable(struct vtn_builder *b,
|
2017-06-29 18:33:39 +01:00
|
|
|
struct vtn_variable *var,
|
|
|
|
struct vtn_type *ptr_type);
|
2017-06-29 18:33:28 +01:00
|
|
|
|
2018-03-16 20:35:59 +00:00
|
|
|
nir_deref_instr *vtn_pointer_to_deref(struct vtn_builder *b,
|
|
|
|
struct vtn_pointer *ptr);
|
2016-01-21 01:40:49 +00:00
|
|
|
nir_ssa_def *
|
2017-06-29 18:33:28 +01:00
|
|
|
vtn_pointer_to_offset(struct vtn_builder *b, struct vtn_pointer *ptr,
|
2018-03-22 16:07:01 +00:00
|
|
|
nir_ssa_def **index_out);
|
2016-01-21 01:40:49 +00:00
|
|
|
|
2018-03-16 20:35:59 +00:00
|
|
|
struct vtn_ssa_value *
|
|
|
|
vtn_local_load(struct vtn_builder *b, nir_deref_instr *src);
|
2016-01-21 01:11:55 +00:00
|
|
|
|
|
|
|
void vtn_local_store(struct vtn_builder *b, struct vtn_ssa_value *src,
|
2018-03-16 20:35:59 +00:00
|
|
|
nir_deref_instr *dest);
|
2016-01-21 01:11:55 +00:00
|
|
|
|
2016-01-20 02:58:31 +00:00
|
|
|
struct vtn_ssa_value *
|
2017-06-29 18:33:28 +01:00
|
|
|
vtn_variable_load(struct vtn_builder *b, struct vtn_pointer *src);
|
2016-01-20 02:58:31 +00:00
|
|
|
|
2015-12-29 20:09:32 +00:00
|
|
|
void vtn_variable_store(struct vtn_builder *b, struct vtn_ssa_value *src,
|
2017-06-29 18:33:28 +01:00
|
|
|
struct vtn_pointer *dest);
|
2015-12-29 20:09:32 +00:00
|
|
|
|
2016-01-21 01:40:49 +00:00
|
|
|
void vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
|
|
|
|
const uint32_t *w, unsigned count);
|
|
|
|
|
2015-12-29 20:09:32 +00:00
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
typedef void (*vtn_decoration_foreach_cb)(struct vtn_builder *,
|
|
|
|
struct vtn_value *,
|
2015-07-01 22:17:24 +01:00
|
|
|
int member,
|
2015-05-04 20:25:09 +01:00
|
|
|
const struct vtn_decoration *,
|
|
|
|
void *);
|
|
|
|
|
|
|
|
void vtn_foreach_decoration(struct vtn_builder *b, struct vtn_value *value,
|
|
|
|
vtn_decoration_foreach_cb cb, void *data);
|
2015-05-04 23:17:56 +01:00
|
|
|
|
2015-12-31 00:38:16 +00:00
|
|
|
typedef void (*vtn_execution_mode_foreach_cb)(struct vtn_builder *,
|
|
|
|
struct vtn_value *,
|
|
|
|
const struct vtn_decoration *,
|
|
|
|
void *);
|
|
|
|
|
|
|
|
void vtn_foreach_execution_mode(struct vtn_builder *b, struct vtn_value *value,
|
|
|
|
vtn_execution_mode_foreach_cb cb, void *data);
|
|
|
|
|
2017-09-05 23:46:58 +01:00
|
|
|
nir_op vtn_nir_alu_op_for_spirv_opcode(struct vtn_builder *b,
|
|
|
|
SpvOp opcode, bool *swap,
|
2018-03-14 07:49:43 +00:00
|
|
|
unsigned src_bit_size, unsigned dst_bit_size);
|
2016-01-13 01:16:48 +00:00
|
|
|
|
2016-01-08 19:02:17 +00:00
|
|
|
void vtn_handle_alu(struct vtn_builder *b, SpvOp opcode,
|
|
|
|
const uint32_t *w, unsigned count);
|
|
|
|
|
2017-04-28 12:45:50 +01:00
|
|
|
void vtn_handle_subgroup(struct vtn_builder *b, SpvOp opcode,
|
|
|
|
const uint32_t *w, unsigned count);
|
|
|
|
|
2018-03-30 18:10:11 +01:00
|
|
|
bool vtn_handle_glsl450_instruction(struct vtn_builder *b, SpvOp ext_opcode,
|
2015-05-04 23:17:56 +01:00
|
|
|
const uint32_t *words, unsigned count);
|
2016-11-14 11:08:32 +00:00
|
|
|
|
2018-01-18 11:24:38 +00:00
|
|
|
struct vtn_builder* vtn_create_builder(const uint32_t *words, size_t word_count,
|
|
|
|
gl_shader_stage stage, const char *entry_point_name,
|
|
|
|
const struct spirv_to_nir_options *options);
|
|
|
|
|
2018-01-18 11:31:52 +00:00
|
|
|
void vtn_handle_entry_point(struct vtn_builder *b, const uint32_t *w,
|
|
|
|
unsigned count);
|
|
|
|
|
|
|
|
void vtn_handle_decoration(struct vtn_builder *b, SpvOp opcode,
|
|
|
|
const uint32_t *w, unsigned count);
|
|
|
|
|
2017-10-19 01:59:47 +01:00
|
|
|
static inline uint32_t
|
|
|
|
vtn_align_u32(uint32_t v, uint32_t a)
|
|
|
|
{
|
2018-03-30 18:06:50 +01:00
|
|
|
assert(a != 0 && a == (a & -((int32_t) a)));
|
2017-10-19 01:59:47 +01:00
|
|
|
return (v + a - 1) & ~(a - 1);
|
|
|
|
}
|
|
|
|
|
2016-11-14 11:08:32 +00:00
|
|
|
static inline uint64_t
|
|
|
|
vtn_u64_literal(const uint32_t *w)
|
|
|
|
{
|
|
|
|
return (uint64_t)w[1] << 32 | w[0];
|
|
|
|
}
|
2017-03-20 16:04:17 +00:00
|
|
|
|
2018-03-30 18:10:11 +01:00
|
|
|
bool vtn_handle_amd_gcn_shader_instruction(struct vtn_builder *b, SpvOp ext_opcode,
|
2018-02-23 12:54:59 +00:00
|
|
|
const uint32_t *words, unsigned count);
|
|
|
|
|
2018-03-30 18:10:11 +01:00
|
|
|
bool vtn_handle_amd_shader_trinary_minmax_instruction(struct vtn_builder *b, SpvOp ext_opcode,
|
2016-12-28 00:33:07 +00:00
|
|
|
const uint32_t *words, unsigned count);
|
2017-03-20 16:04:17 +00:00
|
|
|
#endif /* _VTN_PRIVATE_H_ */
|