/* * Copyright 2020-2021 Zebediah Figura for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ /* * This application contains code derived from piglit, the license for which * follows: * * Copyright © 2010 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. */ #ifdef __MINGW32__ # define _HRESULT_DEFINED typedef int HRESULT; #endif #define COBJMACROS #define CONST_VTABLE #include "config.h" #include #include #include #include #include #include "vkd3d_windows.h" #include "vkd3d_d3dcommon.h" #include "vkd3d_d3dcompiler.h" #include "vkd3d_test.h" #include "shader_runner.h" #include "dxcompiler.h" struct test_options test_options = {0}; void fatal_error(const char *format, ...) { va_list args; va_start(args, format); vfprintf(stderr, format, args); va_end(args); exit(1); } enum parse_state { STATE_NONE, STATE_INPUT_LAYOUT, STATE_PREPROC, STATE_PREPROC_INVALID, STATE_REQUIRE, STATE_RESOURCE, STATE_SAMPLER, STATE_SHADER_COMPUTE, STATE_SHADER_COMPUTE_TODO, STATE_SHADER_PIXEL, STATE_SHADER_PIXEL_TODO, STATE_SHADER_VERTEX, STATE_SHADER_VERTEX_TODO, STATE_SHADER_EFFECT, STATE_SHADER_EFFECT_TODO, STATE_TEST, }; static bool match_string(const char *line, const char *token, const char **const rest) { size_t len = strlen(token); while (isspace(*line)) ++line; if (strncmp(line, token, len) || !isspace(line[len])) return false; if (rest) { *rest = line + len; while (isspace(**rest)) ++*rest; } return true; } static bool match_directive_substring(const char *line, const char *token, const char **const rest) { size_t len = strlen(token); while (isspace(*line) || *line == ']') ++line; if (strncmp(line, token, len) || !(isspace(line[len]) || line[len] == ']')) return false; if (rest) { *rest = line + len; while (isspace(**rest)) ++*rest; } return true; } static void parse_require_directive(struct shader_runner *runner, const char *line) { bool less_than = false; unsigned int i; if (match_string(line, "shader model >=", &line) || (less_than = match_string(line, "shader model <", &line))) { static const char *const model_strings[] = { [SHADER_MODEL_2_0] = "2.0", [SHADER_MODEL_3_0] = "3.0", [SHADER_MODEL_4_0] = "4.0", [SHADER_MODEL_4_1] = "4.1", [SHADER_MODEL_5_0] = "5.0", [SHADER_MODEL_5_1] = "5.1", [SHADER_MODEL_6_0] = "6.0", }; for (i = 0; i < ARRAY_SIZE(model_strings); ++i) { if (match_string(line, model_strings[i], &line)) { if (less_than) { if (!i) fatal_error("Shader model < '%s' is invalid.\n", line); runner->maximum_shader_model = min(runner->maximum_shader_model, i - 1); } else { runner->minimum_shader_model = max(runner->minimum_shader_model, i); } return; } } fatal_error("Unknown shader model '%s'.\n", line); } else if (match_string(line, "options:", &line)) { static const struct option { unsigned int option; const char *name; } options[] = { { 0, "none" }, { D3DCOMPILE_PACK_MATRIX_ROW_MAJOR, "row-major" }, { D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR, "column-major" }, { D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY, "backcompat" }, }; runner->compile_options = 0; for (i = 0; i < ARRAY_SIZE(options); ++i) { if (match_string(line, options[i].name, &line)) runner->compile_options |= options[i].option; } } else { fatal_error("Unknown require directive '%s'.\n", line); } } static DXGI_FORMAT parse_format(const char *line, enum texture_data_type *data_type, unsigned int *texel_size, const char **rest) { static const struct { const char *string; enum texture_data_type data_type; unsigned int texel_size; DXGI_FORMAT format; } formats[] = { {"r32g32b32a32 float", TEXTURE_DATA_FLOAT, 16, DXGI_FORMAT_R32G32B32A32_FLOAT}, {"r32g32b32a32 uint", TEXTURE_DATA_UINT, 16, DXGI_FORMAT_R32G32B32A32_UINT}, {"r32g32 float", TEXTURE_DATA_FLOAT, 8, DXGI_FORMAT_R32G32_FLOAT}, {"r32g32 int", TEXTURE_DATA_SINT, 8, DXGI_FORMAT_R32G32_SINT}, {"r32g32 uint", TEXTURE_DATA_UINT, 8, DXGI_FORMAT_R32G32_UINT}, {"r32 float", TEXTURE_DATA_FLOAT, 4, DXGI_FORMAT_R32_FLOAT}, {"r32 sint", TEXTURE_DATA_SINT, 4, DXGI_FORMAT_R32_SINT}, {"r32 uint", TEXTURE_DATA_UINT, 4, DXGI_FORMAT_R32_UINT}, }; unsigned int i; for (i = 0; i < ARRAY_SIZE(formats); ++i) { if (match_string(line, formats[i].string, rest)) { if (data_type) *data_type = formats[i].data_type; *texel_size = formats[i].texel_size; return formats[i].format; } } fatal_error("Unknown format '%s'.\n", line); } static D3D12_TEXTURE_ADDRESS_MODE parse_sampler_address_mode(const char *line, const char **rest) { if (match_string(line, "border", rest)) return D3D12_TEXTURE_ADDRESS_MODE_BORDER; if (match_string(line, "clamp", rest)) return D3D12_TEXTURE_ADDRESS_MODE_CLAMP; if (match_string(line, "mirror_once", rest)) return D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE; if (match_string(line, "mirror", rest)) return D3D12_TEXTURE_ADDRESS_MODE_MIRROR; if (match_string(line, "wrap", rest)) return D3D12_TEXTURE_ADDRESS_MODE_WRAP; fatal_error("Unknown sampler address mode '%s'.\n", line); } static void parse_sampler_directive(struct sampler *sampler, const char *line) { if (match_string(line, "address", &line)) { sampler->u_address = parse_sampler_address_mode(line, &line); sampler->v_address = parse_sampler_address_mode(line, &line); sampler->w_address = parse_sampler_address_mode(line, &line); } else if (match_string(line, "filter", &line)) { static const struct { const char *string; D3D12_FILTER filter; } filters[] = { {"point point point", D3D12_FILTER_MIN_MAG_MIP_POINT}, {"point point linear", D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR}, {"point linear point", D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT}, {"point linear linear", D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR}, {"linear point point", D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT}, {"linear point linear", D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR}, {"linear linear point", D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT}, {"linear linear linear", D3D12_FILTER_MIN_MAG_MIP_LINEAR}, }; unsigned int i; for (i = 0; i < ARRAY_SIZE(filters); ++i) { if (match_string(line, filters[i].string, &line)) { sampler->filter = filters[i].filter; return; } } fatal_error("Unknown sampler filter '%s'.\n", line); } else { fatal_error("Unknown sampler directive '%s'.\n", line); } } static void parse_resource_directive(struct resource_params *resource, const char *line) { int ret; if (match_string(line, "format", &line)) { resource->format = parse_format(line, &resource->data_type, &resource->texel_size, &line); } else if (match_string(line, "size", &line)) { ret = sscanf(line, "( %u , %u )", &resource->width, &resource->height); if (ret < 2) fatal_error("Malformed texture size '%s'.\n", line); } else if (match_string(line, "levels", &line)) { char *rest; resource->level_count = strtoul(line, &rest, 10); if (rest == line) fatal_error("Malformed texture directive '%s'.\n", line); } else { union { float f; int32_t i; uint32_t u; } u; char *rest; u.u = 0; for (;;) { switch (resource->data_type) { case TEXTURE_DATA_FLOAT: u.f = strtof(line, &rest); break; case TEXTURE_DATA_SINT: u.i = strtol(line, &rest, 0); break; case TEXTURE_DATA_UINT: u.u = strtoul(line, &rest, 0); break; } if (rest == line) break; vkd3d_array_reserve((void **)&resource->data, &resource->data_capacity, resource->data_size + sizeof(u), 1); memcpy(resource->data + resource->data_size, &u, sizeof(u)); resource->data_size += sizeof(u); line = rest; } } } static void parse_input_layout_directive(struct shader_runner *runner, const char *line) { struct input_element *element; const char *rest; vkd3d_array_reserve((void **)&runner->input_elements, &runner->input_element_capacity, runner->input_element_count + 1, sizeof(*runner->input_elements)); element = &runner->input_elements[runner->input_element_count++]; element->slot = strtoul(line, (char **)&rest, 10); if (rest == line) fatal_error("Malformed input layout directive '%s'.\n", line); line = rest; element->format = parse_format(line, NULL, &element->texel_size, &line); if (!(rest = strpbrk(line, " \n"))) rest = line + strlen(line); element->name = malloc(rest - line + 1); memcpy(element->name, line, rest - line); element->name[rest - line] = 0; line = rest; element->index = strtoul(line, (char **)&rest, 10); if (rest == line) element->index = 0; } void init_resource(struct resource *resource, const struct resource_params *params) { resource->type = params->type; resource->slot = params->slot; resource->format = params->format; resource->size = params->data_size; resource->texel_size = params->texel_size; resource->width = params->width; resource->height = params->height; } static struct resource *get_resource(struct shader_runner *runner, enum resource_type type, unsigned int slot) { struct resource *resource; size_t i; for (i = 0; i < runner->resource_count; ++i) { resource = runner->resources[i]; if (resource->type == type && resource->slot == slot) return resource; } return NULL; } static void set_resource(struct shader_runner *runner, struct resource *resource) { size_t i; for (i = 0; i < runner->resource_count; ++i) { if (runner->resources[i]->slot == resource->slot && runner->resources[i]->type == resource->type) { runner->ops->destroy_resource(runner, runner->resources[i]); runner->resources[i] = resource; return; } } if (runner->resource_count == MAX_RESOURCES) fatal_error("Too many resources declared.\n"); runner->resources[runner->resource_count++] = resource; } static void set_uniforms(struct shader_runner *runner, size_t offset, size_t count, const void *uniforms) { runner->uniform_count = align(max(runner->uniform_count, offset + count), 4); vkd3d_array_reserve((void **)&runner->uniforms, &runner->uniform_capacity, runner->uniform_count, sizeof(*runner->uniforms)); memcpy(runner->uniforms + offset, uniforms, count * sizeof(*runner->uniforms)); } static void read_int(const char **line, int *i) { char *rest; long val; errno = 0; val = strtol(*line, &rest, 0); if (errno != 0 || (*rest != '\0' && !isspace((unsigned char)*rest))) fatal_error("Malformed int constant '%s'.\n", *line); *i = val; if (*i != val) fatal_error("Out of range int constant '%.*s'.\n", (int)(rest - *line), *line); *line = rest; } static void read_uint(const char **line, unsigned int *u) { char *rest; unsigned long val; errno = 0; val = strtoul(*line, &rest, 0); if (errno != 0 || (*rest != '\0' && !isspace((unsigned char)*rest))) fatal_error("Malformed uint constant '%s'.\n", *line); *u = val; if (*u != val) fatal_error("Out of range uint constant '%.*s'.\n", (int)(rest - *line), *line); *line = rest; } static void read_int4(const char **line, struct ivec4 *v) { read_int(line, &v->x); read_int(line, &v->y); read_int(line, &v->z); read_int(line, &v->w); } static void read_uint4(const char **line, struct uvec4 *v) { read_uint(line, &v->x); read_uint(line, &v->y); read_uint(line, &v->z); read_uint(line, &v->w); } static void parse_test_directive(struct shader_runner *runner, const char *line) { char *rest; int ret; runner->is_todo = false; if (match_string(line, "todo", &line)) runner->is_todo = true; else if (match_string(line, "todo(sm<6)", &line)) runner->is_todo = runner->minimum_shader_model < SHADER_MODEL_6_0; else if (match_string(line, "todo(sm>=6)", &line)) runner->is_todo = runner->minimum_shader_model >= SHADER_MODEL_6_0; if (match_string(line, "dispatch", &line)) { unsigned int x, y, z; ret = sscanf(line, "%u %u %u", &x, &y, &z); if (ret < 3) fatal_error("Malformed dispatch arguments '%s'.\n", line); runner->last_render_failed = !runner->ops->dispatch(runner, x, y, z); } else if (match_string(line, "draw quad", &line)) { struct resource_params params; struct input_element *element; /* For simplicity, draw a large triangle instead. */ static const struct vec2 quad[] = { {-2.0f, -2.0f}, {-2.0f, 4.0f}, { 4.0f, -2.0f}, }; static const char vs_source[] = "void main(inout float4 position : sv_position)\n" "{\n" "}"; if (!get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0)) { memset(¶ms, 0, sizeof(params)); params.slot = 0; params.type = RESOURCE_TYPE_RENDER_TARGET; params.format = DXGI_FORMAT_R32G32B32A32_FLOAT; params.data_type = TEXTURE_DATA_FLOAT; params.texel_size = 16; params.width = RENDER_TARGET_WIDTH; params.height = RENDER_TARGET_HEIGHT; params.level_count = 1; set_resource(runner, runner->ops->create_resource(runner, ¶ms)); } vkd3d_array_reserve((void **)&runner->input_elements, &runner->input_element_capacity, 1, sizeof(*runner->input_elements)); element = &runner->input_elements[0]; element->name = strdup("sv_position"); element->slot = 0; element->format = DXGI_FORMAT_R32G32_FLOAT; element->texel_size = sizeof(*quad); element->index = 0; runner->input_element_count = 1; memset(¶ms, 0, sizeof(params)); params.slot = 0; params.type = RESOURCE_TYPE_VERTEX_BUFFER; params.data = malloc(sizeof(quad)); memcpy(params.data, quad, sizeof(quad)); params.data_size = sizeof(quad); set_resource(runner, runner->ops->create_resource(runner, ¶ms)); if (!runner->vs_source) runner->vs_source = strdup(vs_source); runner->last_render_failed = !runner->ops->draw(runner, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, 3); } else if (match_string(line, "draw", &line)) { D3D_PRIMITIVE_TOPOLOGY topology; struct resource_params params; unsigned int vertex_count; char *rest; if (!get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0)) { memset(¶ms, 0, sizeof(params)); params.slot = 0; params.type = RESOURCE_TYPE_RENDER_TARGET; params.format = DXGI_FORMAT_R32G32B32A32_FLOAT; params.data_type = TEXTURE_DATA_FLOAT; params.texel_size = 16; params.width = RENDER_TARGET_WIDTH; params.height = RENDER_TARGET_HEIGHT; params.level_count = 1; set_resource(runner, runner->ops->create_resource(runner, ¶ms)); } if (match_string(line, "triangle list", &line)) topology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; else if (match_string(line, "triangle strip", &line)) topology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; else fatal_error("Unknown primitive topology '%s'.\n", line); vertex_count = strtoul(line, &rest, 10); if (line == rest) fatal_error("Malformed vertex count '%s'.\n", line); runner->last_render_failed = !runner->ops->draw(runner, topology, vertex_count); } else if (match_string(line, "probe", &line)) { unsigned int left, top, right, bottom, ulps, slot; struct resource_readback *rb; struct resource *resource; RECT rect; int len; if (runner->last_render_failed) return; if (match_string(line, "uav", &line)) { slot = strtoul(line, &rest, 10); if (rest == line) fatal_error("Malformed UAV index '%s'.\n", line); line = rest; resource = get_resource(runner, RESOURCE_TYPE_UAV, slot); } else if (match_string(line, "buffer uav", &line)) { slot = strtoul(line, &rest, 10); if (rest == line) fatal_error("Malformed buffer UAV index '%s'.\n", line); line = rest; resource = get_resource(runner, RESOURCE_TYPE_BUFFER_UAV, slot); } else if (match_string(line, "render target", &line)) { slot = strtoul(line, &rest, 10); if (rest == line) fatal_error("Malformed render target index '%s'.\n", line); line = rest; resource = get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, slot); } else { resource = get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0); } rb = runner->ops->get_resource_readback(runner, resource); if (match_string(line, "all", &line)) { set_rect(&rect, 0, 0, resource->width, resource->height); } else if (sscanf(line, " ( %d , %d , %d , %d )%n", &left, &top, &right, &bottom, &len) == 4) { set_rect(&rect, left, top, right, bottom); line += len; } else if (sscanf(line, " ( %u , %u )%n", &left, &top, &len) == 2) { set_rect(&rect, left, top, left + 1, top + 1); line += len; } else { fatal_error("Malformed probe arguments '%s'.\n", line); } if (match_string(line, "rgba", &line)) { struct vec4 v; ret = sscanf(line, "( %f , %f , %f , %f ) %u", &v.x, &v.y, &v.z, &v.w, &ulps); if (ret < 4) fatal_error("Malformed probe arguments '%s'.\n", line); if (ret < 5) ulps = 0; todo_if(runner->is_todo) check_readback_data_vec4(rb, &rect, &v, ulps); } else if (match_string(line, "r", &line)) { float expect; ret = sscanf(line, "( %f ) %u", &expect, &ulps); if (ret < 1) fatal_error("Malformed probe arguments '%s'.\n", line); if (ret < 2) ulps = 0; todo_if(runner->is_todo) check_readback_data_float(rb, &rect, expect, ulps); } else { fatal_error("Malformed probe arguments '%s'.\n", line); } runner->ops->release_readback(runner, rb); } else if (match_string(line, "uniform", &line)) { unsigned int offset; if (!sscanf(line, "%u", &offset)) fatal_error("Malformed uniform offset '%s'.\n", line); line = strchr(line, ' ') + 1; if (match_string(line, "float4", &line)) { struct vec4 v; if (sscanf(line, "%f %f %f %f", &v.x, &v.y, &v.z, &v.w) < 4) fatal_error("Malformed float4 constant '%s'.\n", line); set_uniforms(runner, offset, 4, &v); } else if (match_string(line, "float", &line)) { float f; if (sscanf(line, "%f", &f) < 1) fatal_error("Malformed float constant '%s'.\n", line); set_uniforms(runner, offset, 1, &f); } else if (match_string(line, "int4", &line)) { struct ivec4 v; read_int4(&line, &v); set_uniforms(runner, offset, 4, &v); } else if (match_string(line, "uint4", &line)) { struct uvec4 v; read_uint4(&line, &v); set_uniforms(runner, offset, 4, &v); } else if (match_string(line, "int", &line)) { int i; read_int(&line, &i); set_uniforms(runner, offset, 1, &i); } else if (match_string(line, "uint", &line)) { unsigned int u; read_uint(&line, &u); set_uniforms(runner, offset, 1, &u); } else { fatal_error("Unknown uniform type '%s'.\n", line); } } else { fatal_error("Unknown test directive '%s'.\n", line); } } static struct sampler *get_sampler(struct shader_runner *runner, unsigned int slot) { struct sampler *sampler; size_t i; for (i = 0; i < runner->sampler_count; ++i) { sampler = &runner->samplers[i]; if (sampler->slot == slot) return sampler; } return NULL; } unsigned int get_vb_stride(const struct shader_runner *runner, unsigned int slot) { unsigned int stride = 0; size_t i; /* We currently don't deal with vertex formats less than 32 bits, so don't * bother with alignment. */ for (i = 0; i < runner->input_element_count; ++i) { const struct input_element *element = &runner->input_elements[i]; if (element->slot == slot) stride += element->texel_size; } return stride; } static HRESULT map_unidentified_hrs(HRESULT hr) { if (hr == 0x80010064) { trace("Mapping unindentified hr %#x as %#x.\n", hr, E_FAIL); return E_FAIL; } return hr; } const char *shader_type_string(enum shader_type type) { static const char *const shader_types[] = { [SHADER_TYPE_CS] = "cs", [SHADER_TYPE_PS] = "ps", [SHADER_TYPE_VS] = "vs", [SHADER_TYPE_FX] = "fx", }; assert(type < ARRAY_SIZE(shader_types)); return shader_types[type]; } /* Avoid issues with calling convention mismatch and different methods for string * retrieval by copying all IDxcBlob objects to a new ID3D10Blob. */ static void d3d10_blob_from_dxc_blob_utf8(IDxcBlobUtf8 *blob, ID3D10Blob **blob_out) { ID3D10Blob *d3d_blob; size_t size; HRESULT hr; size = IDxcBlobUtf8_GetStringLength(blob) + 1; if (FAILED(hr = D3DCreateBlob(size, (ID3DBlob **)&d3d_blob))) { trace("Failed to create blob, hr %#x.\n", hr); return; } memcpy(ID3D10Blob_GetBufferPointer(d3d_blob), IDxcBlobUtf8_GetStringPointer(blob), size); *blob_out = d3d_blob; } static HRESULT d3d10_blob_from_dxc_blob(IDxcBlob *blob, ID3D10Blob **blob_out) { ID3D10Blob *d3d_blob; size_t size; HRESULT hr; size = IDxcBlob_GetBufferSize(blob); if (FAILED(hr = D3DCreateBlob(size, (ID3DBlob **)&d3d_blob))) { trace("Failed to create blob, hr %#x.\n", hr); return hr; } memcpy(ID3D10Blob_GetBufferPointer(d3d_blob), IDxcBlob_GetBufferPointer(blob), size); *blob_out = d3d_blob; return S_OK; } HRESULT dxc_compiler_compile_shader(void *dxc_compiler, enum shader_type type, unsigned int compile_options, const char *hlsl, ID3D10Blob **blob_out, ID3D10Blob **errors_out) { DxcBuffer src_buf = {hlsl, strlen(hlsl), 65001}; IDxcCompiler3 *compiler = dxc_compiler; HRESULT hr, compile_hr; IDxcBlobUtf8 *errors; IDxcResult *result; size_t arg_count; IDxcBlob *blob; static const WCHAR *const shader_profiles[] = { [SHADER_TYPE_CS] = L"cs_6_0", [SHADER_TYPE_PS] = L"ps_6_0", [SHADER_TYPE_VS] = L"vs_6_0", }; const WCHAR *args[] = { L"/T", shader_profiles[type], L"/Qstrip_reflect", L"/Qstrip_debug", L"/flegacy-macro-expansion", L"/flegacy-resource-reservation", NULL, NULL, NULL, }; *blob_out = NULL; *errors_out = NULL; arg_count = ARRAY_SIZE(args) - 3; if (compile_options & D3DCOMPILE_PACK_MATRIX_ROW_MAJOR) args[arg_count++] = L"/Zpr"; if (compile_options & D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR) args[arg_count++] = L"/Zpc"; if (compile_options & D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY) args[arg_count++] = L"/Gec"; if (FAILED(hr = IDxcCompiler3_Compile(compiler, &src_buf, args, arg_count, NULL, &IID_IDxcResult, (void **)&result))) { trace("Failed to compile shader, hr %#x.\n", hr); return hr; } if (IDxcResult_HasOutput(result, DXC_OUT_ERRORS) && SUCCEEDED(hr = IDxcResult_GetOutput(result, DXC_OUT_ERRORS, &IID_IDxcBlobUtf8, (void **)&errors, NULL))) { if (IDxcBlobUtf8_GetStringLength(errors)) d3d10_blob_from_dxc_blob_utf8(errors, errors_out); IDxcBlobUtf8_Release(errors); } if (FAILED(hr = IDxcResult_GetStatus(result, &compile_hr)) || FAILED((hr = compile_hr))) { if (hr == DXC_E_LLVM_CAST_ERROR) hr = E_FAIL; goto result_release; } if (FAILED(hr = IDxcResult_GetOutput(result, DXC_OUT_OBJECT, &IID_IDxcBlob, (void **)&blob, NULL))) goto result_release; IDxcResult_Release(result); hr = d3d10_blob_from_dxc_blob(blob, blob_out); IDxcBlob_Release(blob); return hr; result_release: IDxcResult_Release(result); return hr; } static void compile_shader(struct shader_runner *runner, IDxcCompiler3 *dxc_compiler, const char *source, size_t len, enum shader_type type, HRESULT expect) { bool use_dxcompiler = runner->minimum_shader_model >= SHADER_MODEL_6_0; ID3D10Blob *blob = NULL, *errors = NULL; char profile[7]; HRESULT hr; static const char *const shader_models[] = { [SHADER_MODEL_2_0] = "4_0", [SHADER_MODEL_3_0] = "4_0", [SHADER_MODEL_4_0] = "4_0", [SHADER_MODEL_4_1] = "4_1", [SHADER_MODEL_5_0] = "5_0", [SHADER_MODEL_5_1] = "5_1", [SHADER_MODEL_6_0] = "6_0", }; static const char *const effect_models[] = { [SHADER_MODEL_2_0] = "2_0", [SHADER_MODEL_4_0] = "4_0", [SHADER_MODEL_4_1] = "4_1", [SHADER_MODEL_5_0] = "5_0", }; if (use_dxcompiler) { assert(dxc_compiler); hr = dxc_compiler_compile_shader(dxc_compiler, type, runner->compile_options, source, &blob, &errors); } else { if (type == SHADER_TYPE_FX) sprintf(profile, "%s_%s", shader_type_string(type), effect_models[runner->minimum_shader_model]); else sprintf(profile, "%s_%s", shader_type_string(type), shader_models[runner->minimum_shader_model]); hr = D3DCompile(source, len, NULL, NULL, NULL, "main", profile, runner->compile_options, 0, &blob, &errors); } hr = map_unidentified_hrs(hr); ok(hr == expect, "Got unexpected hr %#x.\n", hr); if (hr == S_OK) { ID3D10Blob_Release(blob); } else { assert_that(!blob, "Expected no compiled shader blob.\n"); assert_that(!!errors, "Expected non-NULL error blob.\n"); } if (errors) { if (vkd3d_test_state.debug_level) trace("%s\n", (char *)ID3D10Blob_GetBufferPointer(errors)); ID3D10Blob_Release(errors); } } static enum parse_state read_shader_directive(struct shader_runner *runner, enum parse_state state, const char *line, const char *src, HRESULT *expect_hr) { while (*src && *src != ']') { /* 'todo' is not meaningful when dxcompiler is in use, so it has no '(sm<6) qualifier. */ if (match_directive_substring(src, "todo", &src)) { if (runner->minimum_shader_model >= SHADER_MODEL_6_0) continue; if (state == STATE_SHADER_COMPUTE) state = STATE_SHADER_COMPUTE_TODO; else if (state == STATE_SHADER_PIXEL) state = STATE_SHADER_PIXEL_TODO; else if (state == STATE_SHADER_VERTEX) state = STATE_SHADER_VERTEX_TODO; else state = STATE_SHADER_EFFECT_TODO; } else if (match_directive_substring(src, "fail", &src)) { *expect_hr = E_FAIL; } else if (match_directive_substring(src, "fail(sm<6)", &src)) { if (runner->minimum_shader_model < SHADER_MODEL_6_0) *expect_hr = E_FAIL; } else if (match_directive_substring(src, "fail(sm>=6)", &src)) { if (runner->minimum_shader_model >= SHADER_MODEL_6_0) *expect_hr = E_FAIL; } else if (match_directive_substring(src, "notimpl(sm<6)", &src)) { if (runner->minimum_shader_model < SHADER_MODEL_6_0) *expect_hr = E_NOTIMPL; } else { fatal_error("Malformed line '%s'.\n", line); } } if (strcmp(src, "]\n")) fatal_error("Malformed line '%s'.\n", line); return state; } void run_shader_tests(struct shader_runner *runner, const struct shader_runner_ops *ops, void *dxc_compiler, enum shader_model minimum_shader_model, enum shader_model maximum_shader_model) { size_t shader_source_size = 0, shader_source_len = 0; struct resource_params current_resource; struct sampler *current_sampler = NULL; enum parse_state state = STATE_NONE; unsigned int i, line_number = 0; char *shader_source = NULL; HRESULT expect_hr = S_OK; bool skip_tests = false; char line_buffer[256]; FILE *f; if (!test_options.filename) fatal_error("No filename specified.\n"); if (!(f = fopen(test_options.filename, "r"))) fatal_error("Unable to open '%s' for reading: %s\n", test_options.filename, strerror(errno)); memset(runner, 0, sizeof(*runner)); runner->ops = ops; runner->minimum_shader_model = minimum_shader_model; runner->maximum_shader_model = maximum_shader_model; for (;;) { char *ret = fgets(line_buffer, sizeof(line_buffer), f); const char *line = line_buffer; ++line_number; if (!ret || line[0] == '[') { switch (state) { case STATE_INPUT_LAYOUT: case STATE_NONE: case STATE_SAMPLER: case STATE_TEST: break; case STATE_REQUIRE: if (runner->maximum_shader_model < runner->minimum_shader_model || (runner->ops->check_requirements && !runner->ops->check_requirements(runner))) { skip_tests = true; } break; case STATE_RESOURCE: /* Not every backend supports every resource type * (specifically, D3D9 doesn't support UAVs and * textures with data type other than float). */ if (!skip_tests) { set_resource(runner, runner->ops->create_resource(runner, ¤t_resource)); } free(current_resource.data); break; case STATE_SHADER_COMPUTE: case STATE_SHADER_COMPUTE_TODO: if (!skip_tests) { todo_if (state == STATE_SHADER_COMPUTE_TODO) compile_shader(runner, dxc_compiler, shader_source, shader_source_len, SHADER_TYPE_CS, expect_hr); } free(runner->cs_source); runner->cs_source = shader_source; shader_source = NULL; shader_source_len = 0; shader_source_size = 0; break; case STATE_SHADER_PIXEL: case STATE_SHADER_PIXEL_TODO: if (!skip_tests) { todo_if (state == STATE_SHADER_PIXEL_TODO) compile_shader(runner, dxc_compiler, shader_source, shader_source_len, SHADER_TYPE_PS, expect_hr); } free(runner->ps_source); runner->ps_source = shader_source; shader_source = NULL; shader_source_len = 0; shader_source_size = 0; break; case STATE_SHADER_VERTEX: case STATE_SHADER_VERTEX_TODO: if (!skip_tests) { todo_if (state == STATE_SHADER_VERTEX_TODO) compile_shader(runner, dxc_compiler, shader_source, shader_source_len, SHADER_TYPE_VS, expect_hr); } free(runner->vs_source); runner->vs_source = shader_source; shader_source = NULL; shader_source_len = 0; shader_source_size = 0; break; case STATE_SHADER_EFFECT: case STATE_SHADER_EFFECT_TODO: if (!skip_tests) { todo_if (state == STATE_SHADER_EFFECT_TODO) compile_shader(runner, dxc_compiler, shader_source, shader_source_len, SHADER_TYPE_FX, expect_hr); } free(runner->fx_source); runner->fx_source = shader_source; shader_source = NULL; shader_source_len = 0; shader_source_size = 0; break; case STATE_PREPROC_INVALID: { ID3D10Blob *blob = NULL, *errors = NULL; HRESULT hr; if (skip_tests) break; hr = D3DPreprocess(shader_source, strlen(shader_source), NULL, NULL, NULL, &blob, &errors); ok(hr == E_FAIL, "Got unexpected hr %#x.\n", hr); ok(!blob, "Expected no compiled shader blob.\n"); ok(!!errors, "Expected non-NULL error blob.\n"); if (errors) { if (vkd3d_test_state.debug_level) trace("%s\n", (char *)ID3D10Blob_GetBufferPointer(errors)); ID3D10Blob_Release(errors); } shader_source_len = 0; break; } case STATE_PREPROC: { ID3D10Blob *blob = NULL, *errors = NULL; SIZE_T size; HRESULT hr; char *text; if (skip_tests) break; hr = D3DPreprocess(shader_source, strlen(shader_source), NULL, NULL, NULL, &blob, &errors); ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); if (hr == S_OK) { if (errors) { if (vkd3d_test_state.debug_level) trace("%s\n", (char *)ID3D10Blob_GetBufferPointer(errors)); ID3D10Blob_Release(errors); } text = ID3D10Blob_GetBufferPointer(blob); size = ID3D10Blob_GetBufferSize(blob); ok(vkd3d_memmem(text, size, "pass", strlen("pass")), "'pass' not found in preprocessed shader.\n"); ok(!vkd3d_memmem(text, size, "fail", strlen("fail")), "'fail' found in preprocessed shader.\n"); ID3D10Blob_Release(blob); } shader_source_len = 0; break; } } if (state != STATE_NONE) vkd3d_test_pop_context(); if (!ret) break; } if (line[0] == '[') { unsigned int index; if (match_directive_substring(line, "[compute shader", &line)) { state = STATE_SHADER_COMPUTE; expect_hr = S_OK; state = read_shader_directive(runner, state, line_buffer, line, &expect_hr); } else if (!strcmp(line, "[require]\n")) { state = STATE_REQUIRE; runner->minimum_shader_model = minimum_shader_model; runner->maximum_shader_model = maximum_shader_model; runner->compile_options = 0; skip_tests = false; } else if (match_directive_substring(line, "[pixel shader", &line)) { state = STATE_SHADER_PIXEL; expect_hr = S_OK; state = read_shader_directive(runner, state, line_buffer, line, &expect_hr); } else if (sscanf(line, "[sampler %u]\n", &index)) { state = STATE_SAMPLER; if (!(current_sampler = get_sampler(runner, index))) { if (runner->sampler_count == MAX_SAMPLERS) fatal_error("Too many samplers declared.\n"); current_sampler = &runner->samplers[runner->sampler_count++]; } memset(current_sampler, 0, sizeof(*current_sampler)); current_sampler->slot = index; current_sampler->filter = D3D12_FILTER_MIN_MAG_MIP_POINT; current_sampler->u_address = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; current_sampler->v_address = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; current_sampler->w_address = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; } else if (sscanf(line, "[render target %u]\n", &index)) { state = STATE_RESOURCE; memset(¤t_resource, 0, sizeof(current_resource)); current_resource.slot = index; current_resource.type = RESOURCE_TYPE_RENDER_TARGET; current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT; current_resource.data_type = TEXTURE_DATA_FLOAT; current_resource.texel_size = 16; current_resource.level_count = 1; } else if (sscanf(line, "[texture %u]\n", &index)) { state = STATE_RESOURCE; memset(¤t_resource, 0, sizeof(current_resource)); current_resource.slot = index; current_resource.type = RESOURCE_TYPE_TEXTURE; current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT; current_resource.data_type = TEXTURE_DATA_FLOAT; current_resource.texel_size = 16; current_resource.level_count = 1; } else if (sscanf(line, "[uav %u]\n", &index)) { state = STATE_RESOURCE; memset(¤t_resource, 0, sizeof(current_resource)); current_resource.slot = index; current_resource.type = RESOURCE_TYPE_UAV; current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT; current_resource.data_type = TEXTURE_DATA_FLOAT; current_resource.texel_size = 16; current_resource.level_count = 1; } else if (sscanf(line, "[buffer uav %u]\n", &index)) { state = STATE_RESOURCE; memset(¤t_resource, 0, sizeof(current_resource)); current_resource.slot = index; current_resource.type = RESOURCE_TYPE_BUFFER_UAV; current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT; current_resource.data_type = TEXTURE_DATA_FLOAT; current_resource.texel_size = 16; current_resource.level_count = 1; } else if (sscanf(line, "[vertex buffer %u]\n", &index)) { state = STATE_RESOURCE; memset(¤t_resource, 0, sizeof(current_resource)); current_resource.slot = index; current_resource.type = RESOURCE_TYPE_VERTEX_BUFFER; current_resource.data_type = TEXTURE_DATA_FLOAT; } else if (!strcmp(line, "[test]\n")) { state = STATE_TEST; } else if (!strcmp(line, "[preproc]\n")) { state = STATE_PREPROC; } else if (!strcmp(line, "[preproc fail]\n")) { state = STATE_PREPROC_INVALID; } else if (match_directive_substring(line, "[vertex shader", &line)) { state = STATE_SHADER_VERTEX; expect_hr = S_OK; state = read_shader_directive(runner, state, line_buffer, line, &expect_hr); } else if (match_directive_substring(line, "[effect", &line)) { state = STATE_SHADER_EFFECT; expect_hr = S_OK; state = read_shader_directive(runner, state, line_buffer, line, &expect_hr); } else if (!strcmp(line, "[input layout]\n")) { state = STATE_INPUT_LAYOUT; for (i = 0; i < runner->input_element_count; ++i) free(runner->input_elements[i].name); runner->input_element_count = 0; } vkd3d_test_push_context("Section %.*s, line %u", strlen(line_buffer) - 1, line_buffer, line_number); } else if (line[0] != '%' && line[0] != '\n') { switch (state) { case STATE_NONE: fatal_error("Malformed line '%s'.\n", line); break; case STATE_INPUT_LAYOUT: parse_input_layout_directive(runner, line); break; case STATE_PREPROC: case STATE_PREPROC_INVALID: case STATE_SHADER_COMPUTE: case STATE_SHADER_COMPUTE_TODO: case STATE_SHADER_PIXEL: case STATE_SHADER_PIXEL_TODO: case STATE_SHADER_VERTEX: case STATE_SHADER_VERTEX_TODO: case STATE_SHADER_EFFECT: case STATE_SHADER_EFFECT_TODO: { size_t len = strlen(line); vkd3d_array_reserve((void **)&shader_source, &shader_source_size, shader_source_len + len + 1, 1); memcpy(shader_source + shader_source_len, line, len + 1); shader_source_len += len; break; } case STATE_REQUIRE: parse_require_directive(runner, line); break; case STATE_RESOURCE: parse_resource_directive(¤t_resource, line); break; case STATE_SAMPLER: parse_sampler_directive(current_sampler, line); break; case STATE_TEST: /* Compilation which fails with dxcompiler is not 'todo', therefore the tests are * not 'todo' either. They cannot run, so skip them entirely. */ if (!skip_tests && SUCCEEDED(expect_hr)) parse_test_directive(runner, line); break; } } } for (i = 0; i < runner->input_element_count; ++i) free(runner->input_elements[i].name); free(runner->input_elements); free(runner->vs_source); free(runner->ps_source); for (i = 0; i < runner->resource_count; ++i) { if (runner->resources[i]) runner->ops->destroy_resource(runner, runner->resources[i]); } fclose(f); } #ifdef _WIN32 static void print_dll_version(const char *file_name) { BOOL (WINAPI *GetFileVersionInfoA)(const char *, DWORD, DWORD, void *); BOOL (WINAPI *VerQueryValueA)(void *, char *, void **, UINT*); DWORD (WINAPI *GetFileVersionInfoSizeA)(const char *, DWORD *); HMODULE version_module; DWORD size, handle; bool done = false; version_module = LoadLibraryA("version.dll"); if (!version_module) goto out; #define X(name) name = (void *)GetProcAddress(version_module, #name); X(GetFileVersionInfoSizeA); X(GetFileVersionInfoA); X(VerQueryValueA); #undef X if (!GetFileVersionInfoSizeA || !GetFileVersionInfoA || !VerQueryValueA) { FreeLibrary(version_module); goto out; } size = GetFileVersionInfoSizeA(file_name, &handle); if (size) { char *data = malloc(size); if (GetFileVersionInfoA(file_name, handle, size, data)) { VS_FIXEDFILEINFO *info; UINT len; if (VerQueryValueA(data, "\\", (void **)&info, &len)) { trace("%s version: %lu.%lu.%lu.%lu\n", file_name, info->dwFileVersionMS >> 16, info->dwFileVersionMS & 0xffff, info->dwFileVersionLS >> 16, info->dwFileVersionLS & 0xffff); done = true; } } free(data); } FreeLibrary(version_module); out: if (!done) trace("%s version: unknown\n", file_name); } #endif #if defined(SONAME_LIBDXCOMPILER) && !defined(VKD3D_CROSSTEST) static IDxcCompiler3 *dxcompiler_create(void) { DxcCreateInstanceProc create_instance; IDxcCompiler3 *compiler; HRESULT hr; void *dll; dll = vkd3d_dlopen(SONAME_LIBDXCOMPILER); ok(dll, "Failed to load dxcompiler library, %s.\n", vkd3d_dlerror()); if (!dll) return NULL; create_instance = (DxcCreateInstanceProc)vkd3d_dlsym(dll, "DxcCreateInstance"); ok(create_instance, "Failed to get DxcCreateInstance() pointer.\n"); if (!create_instance) return NULL; hr = create_instance(&CLSID_DxcCompiler, &IID_IDxcCompiler3, (void **)&compiler); ok(SUCCEEDED(hr), "Failed to create instance, hr %#x.\n", hr); if (FAILED(hr)) return NULL; return compiler; } #elif !defined(VKD3D_CROSSTEST) static IDxcCompiler3 *dxcompiler_create(void) { return NULL; } #endif START_TEST(shader_runner) { #ifndef VKD3D_CROSSTEST IDxcCompiler3 *dxc_compiler; #endif parse_args(argc, argv); #if defined(VKD3D_CROSSTEST) trace("Running tests from a Windows cross build\n"); trace("Compiling shaders with d3dcompiler_47.dll and executing with d3d9.dll\n"); run_shader_tests_d3d9(); trace("Compiling shaders with d3dcompiler_47.dll and executing with d3d11.dll\n"); run_shader_tests_d3d11(); trace("Compiling shaders with d3dcompiler_47.dll and executing with d3d12.dll\n"); run_shader_tests_d3d12(NULL, SHADER_MODEL_4_0, SHADER_MODEL_5_1); print_dll_version("d3dcompiler_47.dll"); print_dll_version("dxgi.dll"); print_dll_version("d3d9.dll"); print_dll_version("d3d11.dll"); print_dll_version("d3d12.dll"); #elif defined(_WIN32) trace("Running tests from a Windows non-cross build\n"); trace("Compiling shaders with vkd3d-shader and executing with d3d9.dll\n"); run_shader_tests_d3d9(); trace("Compiling shaders with vkd3d-shader and executing with d3d11.dll\n"); run_shader_tests_d3d11(); trace("Compiling shaders with vkd3d-shader and executing with vkd3d\n"); run_shader_tests_d3d12(NULL, SHADER_MODEL_4_0, SHADER_MODEL_5_1); if ((dxc_compiler = dxcompiler_create())) { trace("Compiling shaders with dxcompiler and executing with vkd3d\n"); run_shader_tests_d3d12(dxc_compiler, SHADER_MODEL_6_0, SHADER_MODEL_6_0); IDxcCompiler3_Release(dxc_compiler); print_dll_version(SONAME_LIBDXCOMPILER); } print_dll_version("d3d9.dll"); print_dll_version("d3d11.dll"); #else trace("Running tests from a Unix build\n"); trace("Compiling shaders with vkd3d-shader and executing with Vulkan\n"); run_shader_tests_vulkan(); trace("Compiling shaders with vkd3d-shader and executing with vkd3d\n"); run_shader_tests_d3d12(NULL, SHADER_MODEL_4_0, SHADER_MODEL_5_1); if ((dxc_compiler = dxcompiler_create())) { trace("Compiling shaders with dxcompiler and executing with vkd3d\n"); run_shader_tests_d3d12(dxc_compiler, SHADER_MODEL_6_0, SHADER_MODEL_6_0); IDxcCompiler3_Release(dxc_compiler); } #endif }