vk: Prefix most filenames with anv
[mesa.git] / src / vulkan / anv_entrypoints_gen.py
1 # coding=utf-8
2 #
3 # Copyright © 2015 Intel Corporation
4 #
5 # Permission is hereby granted, free of charge, to any person obtaining a
6 # copy of this software and associated documentation files (the "Software"),
7 # to deal in the Software without restriction, including without limitation
8 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 # and/or sell copies of the Software, and to permit persons to whom the
10 # Software is furnished to do so, subject to the following conditions:
11 #
12 # The above copyright notice and this permission notice (including the next
13 # paragraph) shall be included in all copies or substantial portions of the
14 # Software.
15 #
16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
22 # IN THE SOFTWARE.
23 #
24
25 import fileinput, re, sys
26
27 # Each function typedef in the vulkan.h header is all on one line and matches
28 # this regepx. We hope that won't change.
29
30 p = re.compile('typedef ([^ ]*) *\(VKAPI \*PFN_vk([^(]*)\)(.*);')
31
32 entrypoints = []
33
34 # We generate a static hash table for entry point lookup
35 # (vkGetProcAddress). We use a linear congruential generator for our hash
36 # function and a power-of-two size table. The prime numbers are determined
37 # experimentally.
38
39 none = 0xffff
40 hash_size = 256
41 u32_mask = 2**32 - 1
42 hash_mask = hash_size - 1
43
44 prime_factor = 5024183
45 prime_step = 19
46
47 def hash(name):
48 h = 0;
49 for c in name:
50 h = (h * prime_factor + ord(c)) & u32_mask
51
52 return h
53
54 opt_header = False
55 opt_code = False
56
57 if (sys.argv[1] == "header"):
58 opt_header = True
59 sys.argv.pop()
60 elif (sys.argv[1] == "code"):
61 opt_code = True
62 sys.argv.pop()
63
64 # Parse the entry points in the header
65
66 i = 0
67 for line in fileinput.input():
68 m = p.match(line)
69 if (m):
70 if m.group(2) == 'VoidFunction':
71 continue
72 fullname = "vk" + m.group(2)
73 h = hash(fullname)
74 entrypoints.append((m.group(1), m.group(2), m.group(3), i, h))
75 i = i + 1
76
77 # For outputting entrypoints.h we generate a anv_EntryPoint() prototype
78 # per entry point.
79
80 if opt_header:
81 for type, name, args, num, h in entrypoints:
82 print "%s anv_%s%s;" % (type, name, args)
83 print "%s anv_validate_%s%s;" % (type, name, args)
84 exit()
85
86
87
88 print """/*
89 * Copyright © 2015 Intel Corporation
90 *
91 * Permission is hereby granted, free of charge, to any person obtaining a
92 * copy of this software and associated documentation files (the "Software"),
93 * to deal in the Software without restriction, including without limitation
94 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
95 * and/or sell copies of the Software, and to permit persons to whom the
96 * Software is furnished to do so, subject to the following conditions:
97 *
98 * The above copyright notice and this permission notice (including the next
99 * paragraph) shall be included in all copies or substantial portions of the
100 * Software.
101 *
102 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
103 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
104 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
105 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
106 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
107 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
108 * IN THE SOFTWARE.
109 */
110
111 /* DO NOT EDIT! This is a generated file. */
112
113 #include "anv_private.h"
114
115 struct anv_entrypoint {
116 uint32_t name;
117 uint32_t hash;
118 void *function;
119 void *validate;
120 };
121
122 /* We use a big string constant to avoid lots of reloctions from the entry
123 * point table to lots of little strings. The entries in the entry point table
124 * store the index into this big string.
125 */
126
127 static const char strings[] ="""
128
129 offsets = []
130 i = 0;
131 for type, name, args, num, h in entrypoints:
132 print " \"vk%s\\0\"" % name
133 offsets.append(i)
134 i += 2 + len(name) + 1
135 print """ ;
136
137 /* Weak aliases for all potential validate functions. These will resolve to
138 * NULL if they're not defined, which lets the resolve_entrypoint() function
139 * either pick a validate wrapper if available or just plug in the actual
140 * entry point.
141 */
142 """
143
144 for type, name, args, num, h in entrypoints:
145 print "%s anv_validate_%s%s __attribute__ ((weak));" % (type, name, args)
146
147 # Now generate the table of all entry points and their validation functions
148
149 print "\nstatic const struct anv_entrypoint entrypoints[] = {"
150 for type, name, args, num, h in entrypoints:
151 print " { %5d, 0x%08x, anv_%s, anv_validate_%s }," % (offsets[num], h, name, name)
152 print "};\n"
153
154 print """
155 #ifdef DEBUG
156 static bool enable_validate = true;
157 #else
158 static bool enable_validate = false;
159 #endif
160
161 /* We can't use symbols that need resolving (like, oh, getenv) in the resolve
162 * function. This means that we have to determine whether or not to use the
163 * validation layer sometime before that. The constructor function attribute asks
164 * the dynamic linker to invoke determine_validate() at dlopen() time which
165 * works.
166 */
167 static void __attribute__ ((constructor))
168 determine_validate(void)
169 {
170 const char *s = getenv("ANV_VALIDATE");
171
172 if (s)
173 enable_validate = atoi(s);
174 }
175
176 static void * __attribute__ ((noinline))
177 resolve_entrypoint(uint32_t index)
178 {
179 if (enable_validate && entrypoints[index].validate)
180 return entrypoints[index].validate;
181
182 return entrypoints[index].function;
183 }
184 """
185
186 # Now output ifuncs and their resolve helpers for all entry points. The
187 # resolve helper calls resolve_entrypoint() with the entry point index, which
188 # lets the resolver look it up in the table.
189
190 for type, name, args, num, h in entrypoints:
191 print "static void *resolve_%s(void) { return resolve_entrypoint(%d); }" % (name, num)
192 print "%s vk%s%s\n __attribute__ ((ifunc (\"resolve_%s\"), visibility (\"default\")));\n" % (type, name, args, name)
193
194
195 # Now generate the hash table used for entry point look up. This is a
196 # uint16_t table of entry point indices. We use 0xffff to indicate an entry
197 # in the hash table is empty.
198
199 map = [none for f in xrange(hash_size)]
200 collisions = [0 for f in xrange(10)]
201 for type, name, args, num, h in entrypoints:
202 level = 0
203 while map[h & hash_mask] != none:
204 h = h + prime_step
205 level = level + 1
206 if level > 9:
207 collisions[9] += 1
208 else:
209 collisions[level] += 1
210 map[h & hash_mask] = num
211
212 print "/* Hash table stats:"
213 print " * size %d entries" % hash_size
214 print " * collisions entries"
215 for i in xrange(10):
216 if (i == 9):
217 plus = "+"
218 else:
219 plus = " "
220
221 print " * %2d%s %4d" % (i, plus, collisions[i])
222 print " */\n"
223
224 print "#define none 0x%04x\n" % none
225
226 print "static const uint16_t map[] = {"
227 for i in xrange(0, hash_size, 8):
228 print " ",
229 for j in xrange(i, i + 8):
230 if map[j] & 0xffff == 0xffff:
231 print " none,",
232 else:
233 print "0x%04x," % (map[j] & 0xffff),
234 print
235
236 print "};"
237
238 # Finally we generate the hash table lookup function. The hash function and
239 # linear probing algorithm matches the hash table generated above.
240
241 print """
242 void *
243 anv_lookup_entrypoint(const char *name)
244 {
245 static const uint32_t prime_factor = %d;
246 static const uint32_t prime_step = %d;
247 const struct anv_entrypoint *e;
248 uint32_t hash, h, i;
249 const char *p;
250
251 hash = 0;
252 for (p = name; *p; p++)
253 hash = hash * prime_factor + *p;
254
255 h = hash;
256 do {
257 i = map[h & %d];
258 if (i == none)
259 return NULL;
260 e = &entrypoints[i];
261 h += prime_step;
262 } while (e->hash != hash);
263
264 if (strcmp(name, strings + e->name) != 0)
265 return NULL;
266
267 return resolve_entrypoint(i);
268 }
269 """ % (prime_factor, prime_step, hash_mask)