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)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2015-12-28 19:49:33 +00:00
|
|
|
#include "nir/nir.h"
|
|
|
|
#include "nir/nir_builder.h"
|
2015-12-29 18:24:54 +00:00
|
|
|
#include "nir/nir_array.h"
|
2015-05-04 20:25:09 +01:00
|
|
|
#include "nir_spirv.h"
|
|
|
|
#include "spirv.h"
|
|
|
|
|
|
|
|
struct vtn_builder;
|
|
|
|
struct vtn_decoration;
|
|
|
|
|
|
|
|
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,
|
|
|
|
vtn_value_type_deref,
|
|
|
|
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 */
|
|
|
|
nir_array values;
|
|
|
|
|
|
|
|
/* 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-01-05 22:59:40 +00:00
|
|
|
/** The last block in this SPIR-V block. */
|
|
|
|
nir_block *end_block;
|
2015-05-04 20:25:09 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
struct vtn_function {
|
|
|
|
struct exec_node node;
|
|
|
|
|
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
|
|
|
};
|
|
|
|
|
|
|
|
typedef bool (*vtn_instruction_handler)(struct vtn_builder *, uint32_t,
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2015-07-02 22:24:12 +01:00
|
|
|
struct vtn_type {
|
|
|
|
const struct glsl_type *type;
|
|
|
|
|
|
|
|
/* for matrices, whether the matrix is stored row-major */
|
|
|
|
bool row_major;
|
|
|
|
|
|
|
|
/* for structs, the offset of each member */
|
|
|
|
unsigned *offsets;
|
|
|
|
|
2015-07-16 05:58:57 +01:00
|
|
|
/* for structs, whether it was decorated as a "non-SSBO-like" block */
|
|
|
|
bool block;
|
|
|
|
|
|
|
|
/* for structs, whether it was decorated as an "SSBO-like" block */
|
|
|
|
bool buffer_block;
|
|
|
|
|
2015-07-16 19:04:22 +01:00
|
|
|
/* for structs with block == true, whether this is a builtin block (i.e. a
|
|
|
|
* block that contains only builtins).
|
|
|
|
*/
|
|
|
|
bool builtin_block;
|
|
|
|
|
2015-11-13 23:52:52 +00:00
|
|
|
/* Image format for image_load_store type images */
|
|
|
|
unsigned image_format;
|
|
|
|
|
2015-07-02 22:24:12 +01:00
|
|
|
/* for arrays and matrices, the array stride */
|
|
|
|
unsigned stride;
|
|
|
|
|
|
|
|
/* for arrays, the vtn_type for the elements of the array */
|
|
|
|
struct vtn_type *array_element;
|
|
|
|
|
|
|
|
/* for structures, the vtn_type for each member */
|
|
|
|
struct vtn_type **members;
|
|
|
|
|
|
|
|
/* Whether this type, or a parent type, has been decorated as a builtin */
|
|
|
|
bool is_builtin;
|
|
|
|
|
|
|
|
SpvBuiltIn builtin;
|
|
|
|
};
|
|
|
|
|
2015-11-14 01:26:22 +00:00
|
|
|
struct vtn_image_pointer {
|
|
|
|
nir_deref_var *deref;
|
|
|
|
nir_ssa_def *coord;
|
|
|
|
nir_ssa_def *sample;
|
|
|
|
};
|
|
|
|
|
2015-11-15 06:32:54 +00:00
|
|
|
struct vtn_sampled_image {
|
|
|
|
nir_deref_var *image; /* Image or array of images */
|
|
|
|
nir_deref_var *sampler; /* Sampler */
|
|
|
|
};
|
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
struct vtn_value {
|
|
|
|
enum vtn_value_type value_type;
|
|
|
|
const char *name;
|
|
|
|
struct vtn_decoration *decoration;
|
|
|
|
union {
|
|
|
|
void *ptr;
|
|
|
|
char *str;
|
2015-07-02 22:24:12 +01:00
|
|
|
struct vtn_type *type;
|
2015-07-02 20:55:25 +01:00
|
|
|
struct {
|
|
|
|
nir_constant *constant;
|
|
|
|
const struct glsl_type *const_type;
|
|
|
|
};
|
2015-07-02 23:49:08 +01:00
|
|
|
struct {
|
|
|
|
nir_deref_var *deref;
|
|
|
|
struct vtn_type *deref_type;
|
|
|
|
};
|
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;
|
|
|
|
|
|
|
|
nir_shader *shader;
|
|
|
|
nir_function_impl *impl;
|
|
|
|
struct vtn_block *block;
|
|
|
|
|
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
|
|
|
|
2015-07-04 23:53:47 +01:00
|
|
|
/*
|
|
|
|
* NIR variable for each SPIR-V builtin.
|
|
|
|
*/
|
2015-10-23 01:54:24 +01:00
|
|
|
struct {
|
|
|
|
nir_variable *in;
|
|
|
|
nir_variable *out;
|
|
|
|
} builtins[42]; /* XXX need symbolic constant from SPIR-V header */
|
2015-07-04 23:53:47 +01:00
|
|
|
|
2015-05-04 20:25:09 +01:00
|
|
|
unsigned value_id_bound;
|
|
|
|
struct vtn_value *values;
|
|
|
|
|
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-05-04 20:25:09 +01:00
|
|
|
SpvExecutionModel execution_model;
|
2015-10-20 23:23:56 +01:00
|
|
|
bool origin_upper_left;
|
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;
|
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)
|
|
|
|
{
|
|
|
|
assert(value_id < b->value_id_bound);
|
|
|
|
assert(b->values[value_id].value_type == vtn_value_type_invalid);
|
|
|
|
|
|
|
|
b->values[value_id].value_type = value_type;
|
|
|
|
|
|
|
|
return &b->values[value_id];
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct vtn_value *
|
|
|
|
vtn_untyped_value(struct vtn_builder *b, uint32_t value_id)
|
|
|
|
{
|
|
|
|
assert(value_id < b->value_id_bound);
|
|
|
|
return &b->values[value_id];
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
assert(val->value_type == value_type);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2015-12-29 20:09:32 +00:00
|
|
|
void vtn_variable_store(struct vtn_builder *b, struct vtn_ssa_value *src,
|
|
|
|
nir_deref_var *dest, struct vtn_type *dest_type);
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2015-05-04 23:17:56 +01:00
|
|
|
bool vtn_handle_glsl450_instruction(struct vtn_builder *b, uint32_t ext_opcode,
|
|
|
|
const uint32_t *words, unsigned count);
|