mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-22 22:36:00 +00:00
feat(vkbridge): SPIR-V editor; clip/cull distance and GS/TES point size emulation
The last pre-raster stage's ClipDistance becomes a varying and the fragment shader discards on a negative distance; cull distance and GS/TES PointSize become unread varyings. Rewritten modules pass spirv-val; DXVK's SV_ClipDistance check passes with the GPU's clip distance hidden. The client reports features by what the server emulates and what the GPU lacks. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01KZqR8XUE8czvGzEpgSCVQR
This commit is contained in:
1 parent
4a96c62f93
commit
2e569b850a
14 files changed
+1046
-28
No files matched your search
@@ -25,7 +25,7 @@ static int env_off(const char *name)
|
||||
return v && !strcmp(v, "0");
|
||||
}
|
||||
|
||||
uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd)
|
||||
uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd, uint32_t *missing)
|
||||
{
|
||||
VkPhysicalDeviceFeatures f;
|
||||
idt->vkGetPhysicalDeviceFeatures(pd, &f);
|
||||
@@ -65,6 +65,14 @@ uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd)
|
||||
if (!depth_clip && f.depthClamp && !env_off("VKBRIDGE_EMU_DEPTHCLIP")) emu |= VKB_EMU_DEPTH_CLIP;
|
||||
/* PointSize in geometry/tessellation stages: stripped when the feature is missing. */
|
||||
if (!f.shaderTessellationAndGeometryPointSize && (f.geometryShader || f.tessellationShader)) emu |= VKB_EMU_POINT_SIZE;
|
||||
uint32_t miss = 0;
|
||||
if (!f.textureCompressionBC) miss |= VKB_EMU_BCN;
|
||||
if (!divisor) miss |= VKB_EMU_DIVISOR;
|
||||
if (!f.shaderClipDistance) miss |= VKB_EMU_CLIP_DISTANCE;
|
||||
if (!f.shaderCullDistance) miss |= VKB_EMU_CULL_DISTANCE;
|
||||
if (!depth_clip) miss |= VKB_EMU_DEPTH_CLIP;
|
||||
if (emu & VKB_EMU_MAINT5) miss |= VKB_EMU_MAINT5;
|
||||
*missing = miss;
|
||||
return emu & VKB_EMU_IMPLEMENTED;
|
||||
}
|
||||
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
#include "vkb_server.h"
|
||||
|
||||
/* Emulations that are implemented (the rest are never offered to the client). */
|
||||
#define VKB_EMU_IMPLEMENTED (VKB_EMU_MAINT5)
|
||||
#define VKB_EMU_IMPLEMENTED (VKB_EMU_MAINT5 | VKB_EMU_CLIP_DISTANCE | VKB_EMU_CULL_DISTANCE | VKB_EMU_POINT_SIZE)
|
||||
|
||||
#define VKB_EMU_BUCKETS 1024
|
||||
|
||||
@@ -51,7 +51,11 @@ void vkb_emu_install_features(vkb_srv_table *dev);
|
||||
void vkb_emu_uninstall_features(vkb_srv_table *dev);
|
||||
void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci);
|
||||
void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img);
|
||||
void vkb_emu_graphics_pipeline_info(vkb_emu_device *e, VkGraphicsPipelineCreateInfo *ci);
|
||||
/* Rewrites a graphics pipeline's shaders; temporary modules are appended to mods. */
|
||||
void vkb_emu_shader_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipelineCreateInfo *ci, VkShaderModule *mods,
|
||||
uint32_t *nmods, uint32_t cap);
|
||||
void vkb_emu_shader_install(vkb_srv_table *dev);
|
||||
void vkb_emu_shader_uninstall(vkb_srv_table *dev);
|
||||
/* 1 = handled (the emulation recorded its own commands instead). */
|
||||
int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
|
||||
uint32_t n, const VkImageCopy *regions);
|
||||
|
||||
@@ -6,11 +6,10 @@
|
||||
#include "server_emu.h"
|
||||
|
||||
int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd) { (void)idt; (void)pd; return 0; }
|
||||
void vkb_emu_install_features(vkb_srv_table *dev) { (void)dev; }
|
||||
void vkb_emu_uninstall_features(vkb_srv_table *dev) { (void)dev; }
|
||||
void vkb_emu_install_features(vkb_srv_table *dev) { vkb_emu_shader_install(dev); }
|
||||
void vkb_emu_uninstall_features(vkb_srv_table *dev) { vkb_emu_shader_uninstall(dev); }
|
||||
void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci) { (void)e; (void)ci; }
|
||||
void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img) { (void)e; (void)img; }
|
||||
void vkb_emu_graphics_pipeline_info(vkb_emu_device *e, VkGraphicsPipelineCreateInfo *ci) { (void)e; (void)ci; }
|
||||
int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
|
||||
uint32_t n, const VkImageCopy *regions)
|
||||
{
|
||||
|
||||
@@ -200,13 +200,14 @@ static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateGraphicsPipelines(VkDevice devic
|
||||
uint32_t nmods = 0;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
VkGraphicsPipelineCreateInfo *ci = (VkGraphicsPipelineCreateInfo *)&infos[i];
|
||||
/* Shader rewrites first: they read inline SPIR-V before it becomes a module. */
|
||||
vkb_emu_shader_pipeline(e, device, ci, mods, &nmods, 64);
|
||||
if (e->flags & VKB_EMU_MAINT5) {
|
||||
VkPipelineCreateFlags2CreateInfo *f2 = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
|
||||
if (f2) ci->flags = (VkPipelineCreateFlags)f2->flags;
|
||||
for (uint32_t s = 0; s < ci->stageCount; s++)
|
||||
prep_stage(device, (VkPipelineShaderStageCreateInfo *)&ci->pStages[s], mods, &nmods, 64);
|
||||
}
|
||||
vkb_emu_graphics_pipeline_info(e, ci);
|
||||
}
|
||||
VkResult r = vkb_emu_real()->vkCreateGraphicsPipelines(device, cache, n, infos, pAllocator, pPipelines);
|
||||
for (uint32_t i = 0; i < nmods; i++) vkb_emu_real()->vkDestroyShaderModule(device, mods[i], NULL);
|
||||
|
||||
@@ -0,0 +1,387 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Shader-side emulations, done when a graphics pipeline is created (both ends of the vertex ->
|
||||
* fragment interface are known then):
|
||||
*
|
||||
* clip distance (shaderClipDistance missing): the last pre-rasterization stage's ClipDistance
|
||||
* output becomes an ordinary varying at a free location; the fragment shader reads it and
|
||||
* discards the fragment when any distance is negative. For planar clip distances this is the
|
||||
* same set of pixels the hardware clipper would keep.
|
||||
* cull distance (shaderCullDistance missing): the output becomes an unread varying - nothing is
|
||||
* culled, which costs fragments but never drops geometry that should be visible.
|
||||
* point size in geometry/tessellation (shaderTessellationAndGeometryPointSize missing): same.
|
||||
*
|
||||
* Shader modules are kept as SPIR-V so a pipeline can build rewritten variants; the driver's own
|
||||
* module is created from a variant that needs none of the missing features.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "server_emu.h"
|
||||
#include "spirv_edit.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
typedef struct shader_rec {
|
||||
VkShaderModule module;
|
||||
uint32_t *code;
|
||||
size_t size;
|
||||
struct shader_rec *next;
|
||||
} shader_rec;
|
||||
|
||||
typedef struct shader_state {
|
||||
pthread_mutex_t lock;
|
||||
shader_rec *mods[1024];
|
||||
} shader_state;
|
||||
|
||||
#define SHADER_EMU (VKB_EMU_CLIP_DISTANCE | VKB_EMU_CULL_DISTANCE | VKB_EMU_POINT_SIZE)
|
||||
|
||||
static unsigned mh(VkShaderModule m)
|
||||
{
|
||||
uint64_t k = (uint64_t)m;
|
||||
k ^= k >> 31;
|
||||
k *= 0x94d049bb133111ebull;
|
||||
return (unsigned)(k >> 54);
|
||||
}
|
||||
|
||||
static shader_state *state(vkb_emu_device *e) { return e->shaders; }
|
||||
|
||||
static const shader_rec *find_module(vkb_emu_device *e, VkShaderModule m)
|
||||
{
|
||||
shader_state *s = state(e);
|
||||
pthread_mutex_lock(&s->lock);
|
||||
shader_rec *r = s->mods[mh(m)];
|
||||
while (r && r->module != m) r = r->next;
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ rewrites */
|
||||
|
||||
/* Finds a standalone Output/Input variable decorated with a builtin; 0 if none. 2 = in a block. */
|
||||
static uint32_t builtin_var(const spv_mod *m, uint32_t builtin, uint32_t storage, int *in_block)
|
||||
{
|
||||
*in_block = 0;
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
if (in->op == SpvOpDecorate && in->w[1] == SpvDecorationBuiltIn && in->w[2] == builtin) {
|
||||
int d = spv_find_def(m, in->w[0]);
|
||||
if (d >= 0 && m->ins[d].op == SpvOpVariable && m->ins[d].w[2] == storage) return in->w[0];
|
||||
}
|
||||
if (in->op == SpvOpMemberDecorate && in->w[2] == SpvDecorationBuiltIn && in->w[3] == builtin) *in_block = 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint32_t var_pointee(const spv_mod *m, uint32_t var)
|
||||
{
|
||||
int d = spv_find_def(m, var);
|
||||
if (d < 0) return 0;
|
||||
int p = spv_find_def(m, m->ins[d].w[0]);
|
||||
return p < 0 ? 0 : m->ins[p].w[2];
|
||||
}
|
||||
|
||||
static void add_decoration(spv_mod *m, uint32_t id, uint32_t dec, uint32_t value)
|
||||
{
|
||||
uint32_t ops[3] = {id, dec, value};
|
||||
spv_insert(m, spv_annotations_end(m), SpvOpDecorate, ops, 3);
|
||||
}
|
||||
|
||||
/* Builtin output -> plain varying at *loc (advanced). Returns the element count, 0 if absent. */
|
||||
static uint32_t demote_builtin(spv_mod *m, uint32_t builtin, uint32_t *loc, int *unsupported)
|
||||
{
|
||||
int in_block;
|
||||
uint32_t var = builtin_var(m, builtin, SpvStorageClassOutput, &in_block);
|
||||
if (!var) {
|
||||
if (in_block) *unsupported = 1;
|
||||
return 0;
|
||||
}
|
||||
uint32_t pointee = var_pointee(m, var);
|
||||
uint32_t n = spv_array_length(m, pointee);
|
||||
if (!n) n = 1;
|
||||
spv_remove_decoration(m, var, SpvDecorationBuiltIn);
|
||||
add_decoration(m, var, SpvDecorationLocation, *loc);
|
||||
*loc += n;
|
||||
return n;
|
||||
}
|
||||
|
||||
/* The pre-rasterization side. Returns the clip distance count (0: none), -1 if it cannot. */
|
||||
static int rewrite_pre_raster(spv_mod *m, uint32_t emu, uint32_t clip_loc, int last_stage)
|
||||
{
|
||||
int unsupported = 0;
|
||||
uint32_t loc = clip_loc;
|
||||
int clip = 0;
|
||||
if ((emu & VKB_EMU_CLIP_DISTANCE) && spv_has_capability(m, SpvCapabilityClipDistance)) {
|
||||
clip = (int)demote_builtin(m, SpvBuiltInClipDistance, &loc, &unsupported);
|
||||
spv_remove_capability(m, SpvCapabilityClipDistance);
|
||||
}
|
||||
if ((emu & VKB_EMU_CULL_DISTANCE) && spv_has_capability(m, SpvCapabilityCullDistance)) {
|
||||
demote_builtin(m, SpvBuiltInCullDistance, &loc, &unsupported);
|
||||
spv_remove_capability(m, SpvCapabilityCullDistance);
|
||||
}
|
||||
int model = spv_execution_model(m);
|
||||
if ((emu & VKB_EMU_POINT_SIZE) && (model == SpvExecutionModelGeometry || model == SpvExecutionModelTessellationEvaluation) &&
|
||||
(spv_has_capability(m, SpvCapabilityGeometryPointSize) || spv_has_capability(m, SpvCapabilityTessellationPointSize))) {
|
||||
demote_builtin(m, SpvBuiltInPointSize, &loc, &unsupported);
|
||||
spv_remove_capability(m, SpvCapabilityGeometryPointSize);
|
||||
spv_remove_capability(m, SpvCapabilityTessellationPointSize);
|
||||
}
|
||||
(void)last_stage;
|
||||
if (unsupported) VKB_ONCE(VKB_LOG_WARN, "emulation: clip/cull distance inside an output block is not handled (logged once)");
|
||||
return unsupported && !clip ? -1 : clip;
|
||||
}
|
||||
|
||||
/* The fragment side: read the distances at `loc` and discard when any is negative. */
|
||||
static int rewrite_fragment(spv_mod *m, uint32_t loc, uint32_t n)
|
||||
{
|
||||
uint32_t f32 = spv_type_float(m, 32);
|
||||
uint32_t len = spv_const_u32(m, n);
|
||||
uint32_t arr = spv_type_array(m, f32, len);
|
||||
uint32_t parr = spv_type_pointer(m, SpvStorageClassInput, arr);
|
||||
uint32_t pf = spv_type_pointer(m, SpvStorageClassInput, f32);
|
||||
uint32_t tbool = spv_type_bool(m);
|
||||
uint32_t zero = spv_const_f32(m, 0.0f);
|
||||
uint32_t idx[16];
|
||||
for (uint32_t i = 0; i < n && i < 16; i++) idx[i] = spv_const_u32(m, i);
|
||||
uint32_t var = spv_new_id(m);
|
||||
uint32_t vops[3] = {parr, var, SpvStorageClassInput};
|
||||
spv_insert(m, spv_types_end(m), SpvOpVariable, vops, 3);
|
||||
add_decoration(m, var, SpvDecorationLocation, loc);
|
||||
spv_add_interface(m, var);
|
||||
|
||||
int ep = spv_find_op(m, SpvOpEntryPoint, 0);
|
||||
if (ep < 0) return -1;
|
||||
uint32_t fn = m->ins[ep].w[1];
|
||||
int fi = -1;
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpFunction && m->ins[i].w[1] == fn) fi = (int)i;
|
||||
if (fi < 0) return -1;
|
||||
int li = spv_find_op(m, SpvOpLabel, (uint32_t)fi);
|
||||
if (li < 0) return -1;
|
||||
uint32_t first_label = m->ins[li].w[0];
|
||||
uint32_t at = (uint32_t)li + 1;
|
||||
while (at < m->count && (m->ins[at].op == SpvOpVariable || m->ins[at].op == SpvOpLine || m->ins[at].op == SpvOpNoLine)) at++;
|
||||
|
||||
uint32_t any = 0;
|
||||
for (uint32_t i = 0; i < n && i < 16; i++) {
|
||||
uint32_t p = spv_new_id(m), v = spv_new_id(m), lt = spv_new_id(m);
|
||||
uint32_t ac[4] = {pf, p, var, idx[i]};
|
||||
at = spv_insert(m, at, SpvOpAccessChain, ac, 4) + 1;
|
||||
uint32_t ld[3] = {f32, v, p};
|
||||
at = spv_insert(m, at, SpvOpLoad, ld, 3) + 1;
|
||||
uint32_t cmp[4] = {tbool, lt, v, zero};
|
||||
at = spv_insert(m, at, SpvOpFOrdLessThan, cmp, 4) + 1;
|
||||
if (any) {
|
||||
uint32_t o = spv_new_id(m), orr[4] = {tbool, o, any, lt};
|
||||
at = spv_insert(m, at, SpvOpLogicalOr, orr, 4) + 1;
|
||||
any = o;
|
||||
} else {
|
||||
any = lt;
|
||||
}
|
||||
}
|
||||
uint32_t kill = spv_new_id(m), merge = spv_new_id(m);
|
||||
uint32_t sm[2] = {merge, 0};
|
||||
at = spv_insert(m, at, SpvOpSelectionMerge, sm, 2) + 1;
|
||||
uint32_t bc[3] = {any, kill, merge};
|
||||
at = spv_insert(m, at, SpvOpBranchConditional, bc, 3) + 1;
|
||||
at = spv_insert(m, at, SpvOpLabel, &kill, 1) + 1;
|
||||
at = spv_insert(m, at, spv_version(m) >= 0x00010600 ? SpvOpTerminateInvocation : SpvOpKill, NULL, 0) + 1;
|
||||
at = spv_insert(m, at, SpvOpLabel, &merge, 1) + 1;
|
||||
/* Phis that named the old entry block as a predecessor now come from the merge block. */
|
||||
for (uint32_t i = at; i < m->count; i++) {
|
||||
spv_inst *in = &m->ins[i];
|
||||
if (in->op != 245 /* OpPhi */) continue;
|
||||
for (uint32_t k = 3; k < (uint32_t)in->n - 1; k += 2)
|
||||
if (in->w[k] == first_label) in->w[k] = merge;
|
||||
}
|
||||
return m->err ? -1 : 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ module store */
|
||||
|
||||
static VkResult make_module(VkDevice device, const spv_mod *m, VkShaderModule *out)
|
||||
{
|
||||
uint32_t *code;
|
||||
size_t size = spv_write(m, &code);
|
||||
if (!size) return VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
const char *dump = getenv("VKBRIDGE_DUMP_SPIRV");
|
||||
if (dump && *dump) {
|
||||
static int seq;
|
||||
char path[512];
|
||||
snprintf(path, sizeof(path), "%s/vkbridge-%d-%d.spv", dump, (int)getpid(), __atomic_fetch_add(&seq, 1, __ATOMIC_RELAXED));
|
||||
FILE *f = fopen(path, "wb");
|
||||
if (f) {
|
||||
fwrite(code, 1, size, f);
|
||||
fclose(f);
|
||||
}
|
||||
}
|
||||
VkShaderModuleCreateInfo ci = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, NULL, 0, size, code};
|
||||
VkResult r = vkb_emu_real()->vkCreateShaderModule(device, &ci, NULL, out);
|
||||
free(code);
|
||||
return r;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *ci,
|
||||
const VkAllocationCallbacks *pAllocator, VkShaderModule *pModule)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
spv_mod m;
|
||||
VkResult r;
|
||||
int needs = 0;
|
||||
if (spv_parse(&m, ci->pCode, ci->codeSize) == 0) {
|
||||
needs = spv_has_capability(&m, SpvCapabilityClipDistance) || spv_has_capability(&m, SpvCapabilityCullDistance) ||
|
||||
spv_has_capability(&m, SpvCapabilityGeometryPointSize) || spv_has_capability(&m, SpvCapabilityTessellationPointSize);
|
||||
}
|
||||
if (needs) {
|
||||
/* The driver's module must not ask for what it lacks; pipelines use rewritten variants. */
|
||||
int maxo = spv_max_location(&m, SpvStorageClassOutput);
|
||||
rewrite_pre_raster(&m, e->flags, (uint32_t)(maxo + 1), 1);
|
||||
r = make_module(device, &m, pModule);
|
||||
} else {
|
||||
r = vkb_emu_real()->vkCreateShaderModule(device, ci, pAllocator, pModule);
|
||||
}
|
||||
spv_free(&m);
|
||||
if (r != VK_SUCCESS) return r;
|
||||
shader_rec *rec = calloc(1, sizeof(*rec));
|
||||
rec->module = *pModule;
|
||||
rec->size = ci->codeSize;
|
||||
rec->code = malloc(ci->codeSize);
|
||||
memcpy(rec->code, ci->pCode, ci->codeSize);
|
||||
shader_state *s = state(e);
|
||||
pthread_mutex_lock(&s->lock);
|
||||
unsigned h = mh(*pModule);
|
||||
rec->next = s->mods[h];
|
||||
s->mods[h] = rec;
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_DestroyShaderModule(VkDevice device, VkShaderModule module, const VkAllocationCallbacks *pAllocator)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
if (module) {
|
||||
shader_state *s = state(e);
|
||||
pthread_mutex_lock(&s->lock);
|
||||
shader_rec **pp = &s->mods[mh(module)];
|
||||
while (*pp && (*pp)->module != module) pp = &(*pp)->next;
|
||||
shader_rec *r = *pp;
|
||||
if (r) *pp = r->next;
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
if (r) {
|
||||
free(r->code);
|
||||
free(r);
|
||||
}
|
||||
}
|
||||
vkb_emu_real()->vkDestroyShaderModule(device, module, pAllocator);
|
||||
}
|
||||
|
||||
/* The SPIR-V of a stage: its module's (kept here) or the inline VkShaderModuleCreateInfo's. */
|
||||
static int stage_code(vkb_emu_device *e, const VkPipelineShaderStageCreateInfo *st, const uint32_t **code, size_t *size)
|
||||
{
|
||||
if (st->module) {
|
||||
const shader_rec *r = find_module(e, st->module);
|
||||
if (!r) return 0;
|
||||
*code = r->code;
|
||||
*size = r->size;
|
||||
return 1;
|
||||
}
|
||||
for (const VkBaseInStructure *b = st->pNext; b; b = b->pNext) {
|
||||
if (b->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) {
|
||||
*code = ((const VkShaderModuleCreateInfo *)b)->pCode;
|
||||
*size = ((const VkShaderModuleCreateInfo *)b)->codeSize;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Replace a stage's shader by a rewritten module (recorded for destruction after the call). */
|
||||
static void set_stage_module(VkDevice device, VkPipelineShaderStageCreateInfo *st, const spv_mod *m, VkShaderModule *mods,
|
||||
uint32_t *nmods, uint32_t cap)
|
||||
{
|
||||
VkShaderModule mod;
|
||||
if (*nmods >= cap || make_module(device, m, &mod) != VK_SUCCESS) return;
|
||||
mods[(*nmods)++] = mod;
|
||||
st->module = mod;
|
||||
vkb_emu_chain_take(st, VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
|
||||
}
|
||||
|
||||
void vkb_emu_shader_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipelineCreateInfo *ci, VkShaderModule *mods,
|
||||
uint32_t *nmods, uint32_t cap)
|
||||
{
|
||||
if (!(e->flags & SHADER_EMU) || !ci->pStages) return;
|
||||
VkPipelineShaderStageCreateInfo *pre = NULL, *frag = NULL;
|
||||
int pre_rank = -1;
|
||||
for (uint32_t s = 0; s < ci->stageCount; s++) {
|
||||
VkPipelineShaderStageCreateInfo *st = (VkPipelineShaderStageCreateInfo *)&ci->pStages[s];
|
||||
int rank = st->stage == VK_SHADER_STAGE_VERTEX_BIT ? 0 : st->stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT ? 1
|
||||
: st->stage == VK_SHADER_STAGE_GEOMETRY_BIT ? 2 : -1;
|
||||
if (rank > pre_rank) {
|
||||
pre_rank = rank;
|
||||
pre = st;
|
||||
}
|
||||
if (st->stage == VK_SHADER_STAGE_FRAGMENT_BIT) frag = st;
|
||||
}
|
||||
if (!pre) return;
|
||||
const uint32_t *code;
|
||||
size_t size;
|
||||
if (!stage_code(e, pre, &code, &size)) return;
|
||||
spv_mod pm;
|
||||
if (spv_parse(&pm, code, size) != 0) return;
|
||||
if (!spv_has_capability(&pm, SpvCapabilityClipDistance) && !spv_has_capability(&pm, SpvCapabilityCullDistance) &&
|
||||
!spv_has_capability(&pm, SpvCapabilityGeometryPointSize) && !spv_has_capability(&pm, SpvCapabilityTessellationPointSize)) {
|
||||
spv_free(&pm);
|
||||
return;
|
||||
}
|
||||
spv_mod fm;
|
||||
int have_frag = 0;
|
||||
const uint32_t *fcode;
|
||||
size_t fsize;
|
||||
if (frag && stage_code(e, frag, &fcode, &fsize) && spv_parse(&fm, fcode, fsize) == 0) have_frag = 1;
|
||||
int loc = spv_max_location(&pm, SpvStorageClassOutput);
|
||||
if (have_frag) {
|
||||
int fl = spv_max_location(&fm, SpvStorageClassInput);
|
||||
if (fl > loc) loc = fl;
|
||||
}
|
||||
int clip = rewrite_pre_raster(&pm, e->flags, (uint32_t)(loc + 1), 1);
|
||||
if (clip >= 0) set_stage_module(device, pre, &pm, mods, nmods, cap);
|
||||
if (clip > 0) {
|
||||
if (have_frag) {
|
||||
if (rewrite_fragment(&fm, (uint32_t)(loc + 1), (uint32_t)clip) == 0) set_stage_module(device, frag, &fm, mods, nmods, cap);
|
||||
} else {
|
||||
VKB_ONCE(VKB_LOG_WARN, "emulation: clip distances in a pipeline without a fragment shader are not applied (logged once)");
|
||||
}
|
||||
}
|
||||
VKB_DBG("emulation: pipeline with %d clip distance(s) rewritten at location %d", clip, loc + 1);
|
||||
spv_free(&pm);
|
||||
if (have_frag) spv_free(&fm);
|
||||
}
|
||||
|
||||
void vkb_emu_shader_install(vkb_srv_table *dev)
|
||||
{
|
||||
vkb_emu_device *e = dev->emu;
|
||||
if (!(e->flags & SHADER_EMU)) return;
|
||||
shader_state *s = calloc(1, sizeof(*s));
|
||||
pthread_mutex_init(&s->lock, NULL);
|
||||
e->shaders = s;
|
||||
dev->dt.vkCreateShaderModule = emu_CreateShaderModule;
|
||||
dev->dt.vkDestroyShaderModule = emu_DestroyShaderModule;
|
||||
}
|
||||
|
||||
void vkb_emu_shader_uninstall(vkb_srv_table *dev)
|
||||
{
|
||||
shader_state *s = dev->emu->shaders;
|
||||
if (!s) return;
|
||||
for (int i = 0; i < 1024; i++) {
|
||||
while (s->mods[i]) {
|
||||
shader_rec *r = s->mods[i];
|
||||
s->mods[i] = r->next;
|
||||
free(r->code);
|
||||
free(r);
|
||||
}
|
||||
}
|
||||
pthread_mutex_destroy(&s->lock);
|
||||
free(s);
|
||||
dev->emu->shaders = NULL;
|
||||
}
|
||||
@@ -119,12 +119,13 @@ void vkb_selftest_all(void)
|
||||
snprintf(k->name, sizeof(k->name), "%s", p2.properties.deviceName);
|
||||
k->info.real_api_version = p2.properties.apiVersion;
|
||||
vkb_mem_selftest(k, inst, &dt, pds[i]);
|
||||
k->info.emu_available = vkb_emu_detect(&dt, pds[i]);
|
||||
k->info.emu_available = vkb_emu_detect(&dt, pds[i], &k->info.missing);
|
||||
k->info.emu = k->info.emu_available;
|
||||
const char *emu_env = getenv("VKBRIDGE_EMULATE");
|
||||
if (emu_env && !strcmp(emu_env, "0")) k->info.emu = 0;
|
||||
k->valid = 1;
|
||||
VKB_INFO("%s: memory sharing = %s, emulating 0x%x", k->name, vkb_mem_strategy_name(k->info.strategy), k->info.emu);
|
||||
VKB_INFO("%s: memory sharing = %s, missing 0x%x, emulating 0x%x", k->name, vkb_mem_strategy_name(k->info.strategy),
|
||||
k->info.missing, k->info.emu);
|
||||
}
|
||||
dt.vkDestroyInstance(inst, NULL);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,328 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later */
|
||||
#include "spirv_edit.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
int spv_parse(spv_mod *m, const uint32_t *code, size_t bytes)
|
||||
{
|
||||
memset(m, 0, sizeof(*m));
|
||||
if (bytes < 20 || (bytes & 3) || code[0] != 0x07230203u) return -1;
|
||||
memcpy(m->header, code, 20);
|
||||
size_t words = bytes / 4, pos = 5;
|
||||
while (pos < words) {
|
||||
uint32_t n = code[pos] >> 16, op = code[pos] & 0xffff;
|
||||
if (n == 0 || pos + n > words) return -1;
|
||||
spv_insert(m, m->count, (uint16_t)op, code + pos + 1, (uint16_t)(n - 1));
|
||||
if (m->err) return -1;
|
||||
pos += n;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t spv_write(const spv_mod *m, uint32_t **out)
|
||||
{
|
||||
size_t words = 5;
|
||||
for (uint32_t i = 0; i < m->count; i++) words += m->ins[i].n;
|
||||
uint32_t *buf = malloc(words * 4);
|
||||
if (!buf) return 0;
|
||||
memcpy(buf, m->header, 20);
|
||||
size_t pos = 5;
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
buf[pos++] = ((uint32_t)in->n << 16) | in->op;
|
||||
memcpy(buf + pos, in->w, (size_t)(in->n - 1) * 4);
|
||||
pos += in->n - 1;
|
||||
}
|
||||
*out = buf;
|
||||
return words * 4;
|
||||
}
|
||||
|
||||
void spv_free(spv_mod *m)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++) free(m->ins[i].w);
|
||||
free(m->ins);
|
||||
memset(m, 0, sizeof(*m));
|
||||
}
|
||||
|
||||
uint32_t spv_insert(spv_mod *m, uint32_t at, uint16_t op, const uint32_t *ops, uint16_t nops)
|
||||
{
|
||||
if (m->count == m->cap) {
|
||||
uint32_t nc = m->cap ? m->cap * 2 : 1024;
|
||||
spv_inst *ni = realloc(m->ins, nc * sizeof(*ni));
|
||||
if (!ni) {
|
||||
m->err = 1;
|
||||
return 0;
|
||||
}
|
||||
m->ins = ni;
|
||||
m->cap = nc;
|
||||
}
|
||||
if (at > m->count) at = m->count;
|
||||
memmove(&m->ins[at + 1], &m->ins[at], (m->count - at) * sizeof(spv_inst));
|
||||
spv_inst *in = &m->ins[at];
|
||||
in->op = op;
|
||||
in->n = (uint16_t)(nops + 1);
|
||||
in->w = malloc((size_t)(nops ? nops : 1) * 4);
|
||||
if (!in->w) m->err = 1;
|
||||
else if (nops) memcpy(in->w, ops, (size_t)nops * 4);
|
||||
m->count++;
|
||||
return at;
|
||||
}
|
||||
|
||||
void spv_remove(spv_mod *m, uint32_t at)
|
||||
{
|
||||
if (at >= m->count) return;
|
||||
free(m->ins[at].w);
|
||||
memmove(&m->ins[at], &m->ins[at + 1], (m->count - at - 1) * sizeof(spv_inst));
|
||||
m->count--;
|
||||
}
|
||||
|
||||
int spv_find_op(const spv_mod *m, uint16_t op, uint32_t from)
|
||||
{
|
||||
for (uint32_t i = from; i < m->count; i++)
|
||||
if (m->ins[i].op == op) return (int)i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int is_type(uint16_t op) { return op >= 19 && op <= 38; }
|
||||
static int is_const(uint16_t op) { return (op >= 41 && op <= 46) || (op >= 48 && op <= 52); }
|
||||
|
||||
uint32_t spv_result_id(const spv_inst *in)
|
||||
{
|
||||
if (in->n < 2) return 0;
|
||||
if (is_type(in->op) || in->op == SpvOpLabel || in->op == SpvOpString || in->op == SpvOpExtInstImport || in->op == 73)
|
||||
return in->w[0];
|
||||
switch (in->op) {
|
||||
case SpvOpName: case SpvOpMemberName: case SpvOpDecorate: case SpvOpMemberDecorate: case SpvOpEntryPoint:
|
||||
case SpvOpExecutionMode: case SpvOpCapability: case SpvOpExtension: case SpvOpMemoryModel: case SpvOpStore:
|
||||
case SpvOpBranch: case SpvOpBranchConditional: case SpvOpSelectionMerge: case SpvOpReturn: case SpvOpKill:
|
||||
case SpvOpFunctionEnd: case SpvOpLine: case SpvOpNoLine: case SpvOpSource: case SpvOpSourceExtension:
|
||||
case SpvOpDecorateId: case SpvOpDecorateString: case SpvOpMemberDecorateString: case SpvOpModuleProcessed:
|
||||
case SpvOpExecutionModeId: case 246 /* LoopMerge */: case 251 /* Switch */: case 254 /* ReturnValue */:
|
||||
case 255 /* Unreachable */: case 74: case 75: case 224 /* ControlBarrier */: case 225 /* MemoryBarrier */:
|
||||
case SpvOpTerminateInvocation:
|
||||
return 0;
|
||||
default:
|
||||
return in->n >= 3 ? in->w[1] : 0;
|
||||
}
|
||||
}
|
||||
|
||||
int spv_find_def(const spv_mod *m, uint32_t id)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (spv_result_id(&m->ins[i]) == id) return (int)i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
uint32_t spv_types_end(const spv_mod *m)
|
||||
{
|
||||
int f = spv_find_op(m, SpvOpFunction, 0);
|
||||
return f < 0 ? m->count : (uint32_t)f;
|
||||
}
|
||||
|
||||
uint32_t spv_annotations_end(const spv_mod *m)
|
||||
{
|
||||
uint32_t end = spv_types_end(m);
|
||||
for (uint32_t i = 0; i < end; i++) {
|
||||
uint16_t op = m->ins[i].op;
|
||||
if (is_type(op) || is_const(op) || op == SpvOpVariable || op == SpvOpUndef) return i;
|
||||
}
|
||||
return end;
|
||||
}
|
||||
|
||||
static uint32_t add_global(spv_mod *m, uint16_t op, const uint32_t *ops, uint16_t n)
|
||||
{
|
||||
uint32_t at = spv_types_end(m);
|
||||
spv_insert(m, at, op, ops, n);
|
||||
return at;
|
||||
}
|
||||
|
||||
uint32_t spv_type_float(spv_mod *m, uint32_t width)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpTypeFloat && m->ins[i].w[1] == width && m->ins[i].n == 3) return m->ins[i].w[0];
|
||||
uint32_t id = spv_new_id(m), ops[2] = {id, width};
|
||||
add_global(m, SpvOpTypeFloat, ops, 2);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_type_int(spv_mod *m, uint32_t width, uint32_t sign)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpTypeInt && m->ins[i].w[1] == width && m->ins[i].w[2] == sign) return m->ins[i].w[0];
|
||||
uint32_t id = spv_new_id(m), ops[3] = {id, width, sign};
|
||||
add_global(m, SpvOpTypeInt, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_type_bool(spv_mod *m)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpTypeBool) return m->ins[i].w[0];
|
||||
uint32_t id = spv_new_id(m);
|
||||
add_global(m, SpvOpTypeBool, &id, 1);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_type_pointer(spv_mod *m, uint32_t storage, uint32_t pointee)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpTypePointer && m->ins[i].w[1] == storage && m->ins[i].w[2] == pointee) return m->ins[i].w[0];
|
||||
uint32_t id = spv_new_id(m), ops[3] = {id, storage, pointee};
|
||||
add_global(m, SpvOpTypePointer, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_type_array(spv_mod *m, uint32_t elem, uint32_t len_const)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
if (m->ins[i].op == SpvOpTypeArray && m->ins[i].w[1] == elem && m->ins[i].w[2] == len_const &&
|
||||
spv_get_decoration(m, m->ins[i].w[0], 6 /* ArrayStride */) < 0)
|
||||
return m->ins[i].w[0];
|
||||
}
|
||||
uint32_t id = spv_new_id(m), ops[3] = {id, elem, len_const};
|
||||
add_global(m, SpvOpTypeArray, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_const_u32(spv_mod *m, uint32_t v)
|
||||
{
|
||||
uint32_t t = spv_type_int(m, 32, 0);
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpConstant && m->ins[i].w[0] == t && m->ins[i].n == 4 && m->ins[i].w[2] == v) return m->ins[i].w[1];
|
||||
uint32_t id = spv_new_id(m), ops[3] = {t, id, v};
|
||||
add_global(m, SpvOpConstant, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_const_f32(spv_mod *m, float v)
|
||||
{
|
||||
uint32_t t = spv_type_float(m, 32), bits;
|
||||
memcpy(&bits, &v, 4);
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpConstant && m->ins[i].w[0] == t && m->ins[i].n == 4 && m->ins[i].w[2] == bits) return m->ins[i].w[1];
|
||||
uint32_t id = spv_new_id(m), ops[3] = {t, id, bits};
|
||||
add_global(m, SpvOpConstant, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
int64_t spv_get_decoration(const spv_mod *m, uint32_t id, uint32_t decoration)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
if (in->op == SpvOpDecorate && in->w[0] == id && in->w[1] == decoration) return in->n > 3 ? (int64_t)in->w[2] : 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
void spv_remove_decoration(spv_mod *m, uint32_t id, uint32_t decoration)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count;) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
if (in->op == SpvOpDecorate && in->w[0] == id && in->w[1] == decoration) spv_remove(m, i);
|
||||
else i++;
|
||||
}
|
||||
}
|
||||
|
||||
int spv_has_capability(const spv_mod *m, uint32_t cap)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpCapability && m->ins[i].w[0] == cap) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void spv_remove_capability(spv_mod *m, uint32_t cap)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count;) {
|
||||
if (m->ins[i].op == SpvOpCapability && m->ins[i].w[0] == cap) spv_remove(m, i);
|
||||
else i++;
|
||||
}
|
||||
}
|
||||
|
||||
void spv_add_capability(spv_mod *m, uint32_t cap)
|
||||
{
|
||||
if (!spv_has_capability(m, cap)) spv_insert(m, 0, SpvOpCapability, &cap, 1);
|
||||
}
|
||||
|
||||
int spv_execution_model(const spv_mod *m)
|
||||
{
|
||||
int e = spv_find_op(m, SpvOpEntryPoint, 0);
|
||||
return e < 0 ? -1 : (int)m->ins[e].w[0];
|
||||
}
|
||||
|
||||
void spv_add_interface(spv_mod *m, uint32_t var)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
spv_inst *in = &m->ins[i];
|
||||
if (in->op != SpvOpEntryPoint) continue;
|
||||
uint32_t *nw = realloc(in->w, (size_t)in->n * 4);
|
||||
if (!nw) {
|
||||
m->err = 1;
|
||||
return;
|
||||
}
|
||||
nw[in->n - 1] = var;
|
||||
in->w = nw;
|
||||
in->n++;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t spv_array_length(const spv_mod *m, uint32_t array_type)
|
||||
{
|
||||
int d = spv_find_def(m, array_type);
|
||||
if (d < 0 || m->ins[d].op != SpvOpTypeArray) return 0;
|
||||
int c = spv_find_def(m, m->ins[d].w[2]);
|
||||
if (c < 0 || m->ins[c].op != SpvOpConstant) return 0;
|
||||
return m->ins[c].w[2];
|
||||
}
|
||||
|
||||
/* Number of locations a type occupies. */
|
||||
static uint32_t loc_count(const spv_mod *m, uint32_t type, int depth)
|
||||
{
|
||||
int d = spv_find_def(m, type);
|
||||
if (d < 0 || depth > 16) return 1;
|
||||
const spv_inst *in = &m->ins[d];
|
||||
switch (in->op) {
|
||||
case SpvOpTypeArray: return spv_array_length(m, type) * loc_count(m, in->w[1], depth + 1);
|
||||
case 24 /* Matrix */: return in->w[2] * loc_count(m, in->w[1], depth + 1);
|
||||
case SpvOpTypeStruct: {
|
||||
uint32_t s = 0;
|
||||
for (uint32_t k = 1; k < (uint32_t)in->n - 1; k++) s += loc_count(m, in->w[k], depth + 1);
|
||||
return s;
|
||||
}
|
||||
case SpvOpTypeVector: {
|
||||
int e = spv_find_def(m, in->w[1]);
|
||||
uint32_t width = e >= 0 ? m->ins[e].w[1] : 32;
|
||||
return (width == 64 && in->w[2] > 2) ? 2 : 1;
|
||||
}
|
||||
default: return 1;
|
||||
}
|
||||
}
|
||||
|
||||
int spv_max_location(const spv_mod *m, uint32_t storage)
|
||||
{
|
||||
int max = -1;
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
if (in->op != SpvOpVariable || in->w[2] != storage) continue;
|
||||
int p = spv_find_def(m, in->w[0]);
|
||||
if (p < 0) continue;
|
||||
uint32_t pointee = m->ins[p].w[2];
|
||||
int64_t loc = spv_get_decoration(m, in->w[1], SpvDecorationLocation);
|
||||
if (loc >= 0) {
|
||||
int top = (int)loc + (int)loc_count(m, pointee, 0) - 1;
|
||||
if (top > max) max = top;
|
||||
continue;
|
||||
}
|
||||
/* A block with member locations. */
|
||||
for (uint32_t k = 0; k < m->count; k++) {
|
||||
const spv_inst *md = &m->ins[k];
|
||||
if (md->op == SpvOpMemberDecorate && md->w[0] == pointee && md->w[2] == SpvDecorationLocation) {
|
||||
int st = spv_find_def(m, pointee);
|
||||
uint32_t mt = st >= 0 && md->w[1] + 1 < m->ins[st].n ? m->ins[st].w[1 + md->w[1]] : 0;
|
||||
int top = (int)md->w[3] + (int)loc_count(m, mt, 0) - 1;
|
||||
if (top > max) max = top;
|
||||
}
|
||||
}
|
||||
}
|
||||
return max;
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* A small SPIR-V editor for the bridge's shader emulations: parse a module into instructions,
|
||||
* look things up, append/insert/remove instructions, and write it back.
|
||||
*/
|
||||
#ifndef VKB_SPIRV_EDIT_H
|
||||
#define VKB_SPIRV_EDIT_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/* Opcodes and enums used (from the SPIR-V spec). */
|
||||
enum {
|
||||
SpvOpName = 5, SpvOpMemberName = 6, SpvOpExtension = 10, SpvOpExtInstImport = 11, SpvOpMemoryModel = 14,
|
||||
SpvOpEntryPoint = 15, SpvOpExecutionMode = 16, SpvOpCapability = 17, SpvOpTypeVoid = 19, SpvOpTypeBool = 20,
|
||||
SpvOpTypeInt = 21, SpvOpTypeFloat = 22, SpvOpTypeVector = 23, SpvOpTypeArray = 28, SpvOpTypeRuntimeArray = 29,
|
||||
SpvOpTypeStruct = 30, SpvOpTypePointer = 32, SpvOpTypeFunction = 33, SpvOpConstantTrue = 41,
|
||||
SpvOpConstantFalse = 42, SpvOpConstant = 43, SpvOpConstantComposite = 44, SpvOpFunction = 54,
|
||||
SpvOpFunctionParameter = 55, SpvOpFunctionEnd = 56, SpvOpVariable = 59, SpvOpLoad = 61, SpvOpStore = 62,
|
||||
SpvOpAccessChain = 65, SpvOpInBoundsAccessChain = 66, SpvOpDecorate = 71, SpvOpMemberDecorate = 72,
|
||||
SpvOpCompositeExtract = 81, SpvOpFOrdLessThan = 184, SpvOpLogicalOr = 166, SpvOpSelectionMerge = 247,
|
||||
SpvOpLabel = 248, SpvOpBranch = 249, SpvOpBranchConditional = 250, SpvOpReturn = 253, SpvOpKill = 252,
|
||||
SpvOpTerminateInvocation = 4416, SpvOpLine = 8, SpvOpNoLine = 317, SpvOpModuleProcessed = 330,
|
||||
SpvOpString = 7, SpvOpSource = 3, SpvOpSourceExtension = 4, SpvOpSourceContinued = 2, SpvOpExecutionModeId = 331,
|
||||
SpvOpDecorateId = 332, SpvOpDecorateString = 5632, SpvOpMemberDecorateString = 5633, SpvOpUndef = 1,
|
||||
SpvOpExtInst = 12, SpvOpIAdd = 128, SpvOpUDiv = 134, SpvOpISub = 130,
|
||||
};
|
||||
enum { SpvDecorationBuiltIn = 11, SpvDecorationLocation = 30, SpvDecorationComponent = 31, SpvDecorationBlock = 2,
|
||||
SpvDecorationFlat = 14, SpvDecorationPatch = 15 };
|
||||
enum { SpvBuiltInPosition = 0, SpvBuiltInPointSize = 1, SpvBuiltInClipDistance = 3, SpvBuiltInCullDistance = 4,
|
||||
SpvBuiltInInstanceIndex = 43, SpvBuiltInBaseInstance = 4425 };
|
||||
enum { SpvStorageClassInput = 1, SpvStorageClassOutput = 3, SpvStorageClassPrivate = 6, SpvStorageClassFunction = 7 };
|
||||
enum { SpvCapabilityClipDistance = 32, SpvCapabilityCullDistance = 33, SpvCapabilityTessellationPointSize = 23,
|
||||
SpvCapabilityGeometryPointSize = 24, SpvCapabilityDrawParameters = 4427 };
|
||||
enum { SpvExecutionModelVertex = 0, SpvExecutionModelTessellationControl = 1, SpvExecutionModelTessellationEvaluation = 2,
|
||||
SpvExecutionModelGeometry = 3, SpvExecutionModelFragment = 4, SpvExecutionModelGLCompute = 5 };
|
||||
|
||||
typedef struct spv_inst {
|
||||
uint16_t op;
|
||||
uint16_t n; /* word count including the first word */
|
||||
uint32_t *w; /* operand words (w[0] = first operand), n - 1 of them */
|
||||
} spv_inst;
|
||||
|
||||
typedef struct spv_mod {
|
||||
uint32_t header[5];
|
||||
spv_inst *ins;
|
||||
uint32_t count, cap;
|
||||
int err;
|
||||
} spv_mod;
|
||||
|
||||
int spv_parse(spv_mod *m, const uint32_t *code, size_t bytes);
|
||||
/* Writes the module into a malloc'd buffer; returns its size in bytes (0 on failure). */
|
||||
size_t spv_write(const spv_mod *m, uint32_t **out);
|
||||
void spv_free(spv_mod *m);
|
||||
|
||||
static inline uint32_t spv_version(const spv_mod *m) { return m->header[1]; }
|
||||
static inline uint32_t spv_new_id(spv_mod *m) { return m->header[3]++; }
|
||||
|
||||
/* Insert an instruction before index `at` (at = count appends). Operands copied. Returns index. */
|
||||
uint32_t spv_insert(spv_mod *m, uint32_t at, uint16_t op, const uint32_t *ops, uint16_t nops);
|
||||
void spv_remove(spv_mod *m, uint32_t at);
|
||||
|
||||
/* Index of the first instruction with this opcode (or of the defining instruction of `id`), or -1. */
|
||||
int spv_find_op(const spv_mod *m, uint16_t op, uint32_t from);
|
||||
int spv_find_def(const spv_mod *m, uint32_t id);
|
||||
/* The id an instruction defines (result id), or 0. */
|
||||
uint32_t spv_result_id(const spv_inst *in);
|
||||
|
||||
/* Section boundaries: index where new decorations / types / function code may be inserted. */
|
||||
uint32_t spv_types_end(const spv_mod *m); /* end of the types/constants/globals section */
|
||||
uint32_t spv_annotations_end(const spv_mod *m); /* end of the decoration section */
|
||||
|
||||
/* Types and constants: found when they already exist (non-aggregate types must be unique). */
|
||||
uint32_t spv_type_float(spv_mod *m, uint32_t width);
|
||||
uint32_t spv_type_int(spv_mod *m, uint32_t width, uint32_t sign);
|
||||
uint32_t spv_type_bool(spv_mod *m);
|
||||
uint32_t spv_type_pointer(spv_mod *m, uint32_t storage, uint32_t pointee);
|
||||
uint32_t spv_type_array(spv_mod *m, uint32_t elem, uint32_t len_const);
|
||||
uint32_t spv_const_u32(spv_mod *m, uint32_t v);
|
||||
uint32_t spv_const_f32(spv_mod *m, float v);
|
||||
|
||||
/* Decorations of an id: returns the operand (after the decoration) or -1. */
|
||||
int64_t spv_get_decoration(const spv_mod *m, uint32_t id, uint32_t decoration);
|
||||
void spv_remove_decoration(spv_mod *m, uint32_t id, uint32_t decoration);
|
||||
int spv_has_capability(const spv_mod *m, uint32_t cap);
|
||||
void spv_remove_capability(spv_mod *m, uint32_t cap);
|
||||
void spv_add_capability(spv_mod *m, uint32_t cap);
|
||||
/* The execution model of the (first) entry point, or -1. */
|
||||
int spv_execution_model(const spv_mod *m);
|
||||
/* Adds an interface variable to every entry point. */
|
||||
void spv_add_interface(spv_mod *m, uint32_t var);
|
||||
/* Highest Location used by variables of a storage class (members included), or -1. */
|
||||
int spv_max_location(const spv_mod *m, uint32_t storage);
|
||||
/* Length of an OpTypeArray (via its constant), or 0. */
|
||||
uint32_t spv_array_length(const spv_mod *m, uint32_t array_type);
|
||||
|
||||
#endif
|
||||
@@ -107,7 +107,7 @@ void vkb_mem_release(vkb_srv_table *dev, vkb_srv_mem *m);
|
||||
void vkb_mem_free_all(vkb_srv_table *dev);
|
||||
|
||||
/* emulation (server_emu*.c) */
|
||||
uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd);
|
||||
uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd, uint32_t *missing);
|
||||
void vkb_emu_device_create_info(vkb_srv_table *inst, VkPhysicalDevice pd, uint32_t emu,
|
||||
VkDeviceCreateInfo *ci, vkb_arena *a);
|
||||
void vkb_emu_device_init(vkb_srv_table *dev, uint32_t emu);
|
||||
|
||||
Reference in new issue
Block a user