1 /*
2 * Copyright © 2016 Red Hat.
3 * Copyright © 2016 Bas Nieuwenhuizen
4 * Copyright © 2017 Intel Corporation
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the next
14 * paragraph) shall be included in all copies or substantial portions of the
15 * Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
23 * IN THE SOFTWARE.
24 */
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include "vk_util.h"
30 #include "util/debug.h"
31
32 #include "compiler/spirv/nir_spirv.h"
33
vk_get_driver_version(void)34 uint32_t vk_get_driver_version(void)
35 {
36 const char *minor_string = strchr(PACKAGE_VERSION, '.');
37 const char *patch_string = minor_string ? strchr(minor_string + 1, '.') : NULL;
38 int major = atoi(PACKAGE_VERSION);
39 int minor = minor_string ? atoi(minor_string + 1) : 0;
40 int patch = patch_string ? atoi(patch_string + 1) : 0;
41 if (strstr(PACKAGE_VERSION, "devel")) {
42 if (patch == 0) {
43 patch = 99;
44 if (minor == 0) {
45 minor = 99;
46 --major;
47 } else
48 --minor;
49 } else
50 --patch;
51 }
52 return VK_MAKE_VERSION(major, minor, patch);
53 }
54
vk_get_version_override(void)55 uint32_t vk_get_version_override(void)
56 {
57 const char *str = getenv("MESA_VK_VERSION_OVERRIDE");
58 if (str == NULL)
59 return 0;
60
61 const char *minor_str = strchr(str, '.');
62 const char *patch_str = minor_str ? strchr(minor_str + 1, '.') : NULL;
63
64 int major = atoi(str);
65 int minor = minor_str ? atoi(minor_str + 1) : 0;
66 int patch = patch_str ? atoi(patch_str + 1) : 0;
67
68 /* Do some basic version sanity checking */
69 if (major < 1 || minor < 0 || patch < 0 || minor > 1023 || patch > 4095)
70 return 0;
71
72 return VK_MAKE_VERSION(major, minor, patch);
73 }
74
75 void
vk_warn_non_conformant_implementation(const char * driver_name)76 vk_warn_non_conformant_implementation(const char *driver_name)
77 {
78 if (env_var_as_boolean("MESA_VK_IGNORE_CONFORMANCE_WARNING", false))
79 return;
80
81 fprintf(stderr, "WARNING: %s is not a conformant Vulkan implementation, "
82 "testing use only.\n", driver_name);
83 }
84
85 struct nir_spirv_specialization*
vk_spec_info_to_nir_spirv(const VkSpecializationInfo * spec_info,uint32_t * out_num_spec_entries)86 vk_spec_info_to_nir_spirv(const VkSpecializationInfo *spec_info,
87 uint32_t *out_num_spec_entries)
88 {
89 if (spec_info == NULL || spec_info->mapEntryCount == 0)
90 return NULL;
91
92 uint32_t num_spec_entries = spec_info->mapEntryCount;
93 struct nir_spirv_specialization *spec_entries =
94 calloc(num_spec_entries, sizeof(*spec_entries));
95
96 for (uint32_t i = 0; i < num_spec_entries; i++) {
97 VkSpecializationMapEntry entry = spec_info->pMapEntries[i];
98 const void *data = (uint8_t *)spec_info->pData + entry.offset;
99 assert((uint8_t *)data + entry.size <=
100 (uint8_t *)spec_info->pData + spec_info->dataSize);
101
102 spec_entries[i].id = spec_info->pMapEntries[i].constantID;
103 switch (entry.size) {
104 case 8:
105 spec_entries[i].value.u64 = *(const uint64_t *)data;
106 break;
107 case 4:
108 spec_entries[i].value.u32 = *(const uint32_t *)data;
109 break;
110 case 2:
111 spec_entries[i].value.u16 = *(const uint16_t *)data;
112 break;
113 case 1:
114 spec_entries[i].value.u8 = *(const uint8_t *)data;
115 break;
116 case 0:
117 default:
118 /* The Vulkan spec says:
119 *
120 * "For a constantID specialization constant declared in a
121 * shader, size must match the byte size of the constantID. If
122 * the specialization constant is of type boolean, size must be
123 * the byte size of VkBool32."
124 *
125 * Therefore, since only scalars can be decorated as
126 * specialization constants, we can assume that if it doesn't have
127 * a size of 1, 2, 4, or 8, any use in a shader would be invalid
128 * usage. The spec further says:
129 *
130 * "If a constantID value is not a specialization constant ID
131 * used in the shader, that map entry does not affect the
132 * behavior of the pipeline."
133 *
134 * so we should ignore any invalid specialization constants rather
135 * than crash or error out when we see one.
136 */
137 break;
138 }
139 }
140
141 *out_num_spec_entries = num_spec_entries;
142 return spec_entries;
143 }
144