1 /*
2  * Copyright 2018 Collabora Ltd.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * on the rights to use, copy, modify, merge, publish, distribute, sub
8  * license, and/or sell copies of the Software, and to permit persons to whom
9  * the Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
22  */
23 
24 #ifndef SPIRV_BUILDER_H
25 #define SPIRV_BUILDER_H
26 
27 #include "compiler/spirv/spirv.h"
28 #include "compiler/spirv/GLSL.std.450.h"
29 
30 #include <stdbool.h>
31 #include <stdint.h>
32 #include <stdlib.h>
33 
34 struct hash_table;
35 
36 struct spirv_buffer {
37    uint32_t *words;
38    size_t num_words, room;
39 };
40 
41 struct spirv_builder {
42    void *mem_ctx;
43 
44    struct spirv_buffer capabilities;
45    struct spirv_buffer extensions;
46    struct spirv_buffer imports;
47    struct spirv_buffer memory_model;
48    struct spirv_buffer entry_points;
49    struct spirv_buffer exec_modes;
50    struct spirv_buffer debug_names;
51    struct spirv_buffer decorations;
52 
53    struct spirv_buffer types_const_defs;
54    struct hash_table *types;
55    struct hash_table *consts;
56 
57    struct spirv_buffer instructions;
58    SpvId prev_id;
59 };
60 
61 static inline SpvId
spirv_builder_new_id(struct spirv_builder * b)62 spirv_builder_new_id(struct spirv_builder *b)
63 {
64    return ++b->prev_id;
65 }
66 
67 void
68 spirv_builder_emit_cap(struct spirv_builder *b, SpvCapability cap);
69 
70 void
71 spirv_builder_emit_extension(struct spirv_builder *b, const char *ext);
72 
73 void
74 spirv_builder_emit_source(struct spirv_builder *b, SpvSourceLanguage lang,
75                           uint32_t version);
76 
77 void
78 spirv_builder_emit_mem_model(struct spirv_builder *b,
79                              SpvAddressingModel addr_model,
80                              SpvMemoryModel mem_model);
81 
82 void
83 spirv_builder_emit_name(struct spirv_builder *b, SpvId target,
84                         const char *name);
85 
86 void
87 spirv_builder_emit_decoration(struct spirv_builder *b, SpvId target,
88                               SpvDecoration decoration);
89 
90 void
91 spirv_builder_emit_location(struct spirv_builder *b, SpvId target,
92                             uint32_t location);
93 
94 void
95 spirv_builder_emit_component(struct spirv_builder *b, SpvId target,
96                              uint32_t component);
97 
98 void
99 spirv_builder_emit_builtin(struct spirv_builder *b, SpvId target,
100                            SpvBuiltIn builtin);
101 
102 void
103 spirv_builder_emit_index(struct spirv_builder *b, SpvId target, int index);
104 
105 void
106 spirv_builder_emit_descriptor_set(struct spirv_builder *b, SpvId target,
107                                   uint32_t descriptor_set);
108 
109 void
110 spirv_builder_emit_binding(struct spirv_builder *b, SpvId target,
111                            uint32_t binding);
112 
113 void
114 spirv_builder_emit_array_stride(struct spirv_builder *b, SpvId target,
115                                 uint32_t stride);
116 
117 void
118 spirv_builder_emit_offset(struct spirv_builder *b, SpvId target,
119                           uint32_t offset);
120 
121 void
122 spirv_builder_emit_xfb_buffer(struct spirv_builder *b, SpvId target,
123                               uint32_t buffer);
124 
125 void
126 spirv_builder_emit_xfb_stride(struct spirv_builder *b, SpvId target,
127                               uint32_t stride);
128 
129 void
130 spirv_builder_emit_member_offset(struct spirv_builder *b, SpvId target,
131                                  uint32_t member, uint32_t offset);
132 
133 void
134 spirv_builder_emit_entry_point(struct spirv_builder *b,
135                                SpvExecutionModel exec_model, SpvId entry_point,
136                                const char *name, const SpvId interfaces[],
137                                size_t num_interfaces);
138 
139 void
140 spirv_builder_emit_exec_mode(struct spirv_builder *b, SpvId entry_point,
141                              SpvExecutionMode exec_mode);
142 
143 void
144 spirv_builder_function(struct spirv_builder *b, SpvId result,
145                        SpvId return_type,
146                        SpvFunctionControlMask function_control,
147                        SpvId function_type);
148 
149 void
150 spirv_builder_function_end(struct spirv_builder *b);
151 
152 void
153 spirv_builder_label(struct spirv_builder *b, SpvId label);
154 
155 void
156 spirv_builder_return(struct spirv_builder *b);
157 
158 SpvId
159 spirv_builder_emit_undef(struct spirv_builder *b, SpvId result_type);
160 
161 SpvId
162 spirv_builder_emit_load(struct spirv_builder *b, SpvId result_type,
163                         SpvId pointer);
164 
165 void
166 spirv_builder_emit_store(struct spirv_builder *b, SpvId pointer, SpvId object);
167 
168 SpvId
169 spirv_builder_emit_access_chain(struct spirv_builder *b, SpvId result_type,
170                                 SpvId base, const SpvId indexes[],
171                                 size_t num_indexes);
172 
173 SpvId
174 spirv_builder_emit_unop(struct spirv_builder *b, SpvOp op, SpvId result_type,
175                         SpvId operand);
176 
177 SpvId
178 spirv_builder_emit_binop(struct spirv_builder *b, SpvOp op, SpvId result_type,
179                          SpvId operand0, SpvId operand1);
180 
181 SpvId
182 spirv_builder_emit_triop(struct spirv_builder *b, SpvOp op, SpvId result_type,
183                          SpvId operand0, SpvId operand1, SpvId operand2);
184 
185 SpvId
186 spirv_builder_emit_composite_extract(struct spirv_builder *b, SpvId result_type,
187                                      SpvId composite, const uint32_t indexes[],
188                                      size_t num_indexes);
189 
190 SpvId
191 spirv_builder_emit_composite_construct(struct spirv_builder *b,
192                                        SpvId result_type,
193                                        const SpvId constituents[],
194                                        size_t num_constituents);
195 
196 SpvId
197 spirv_builder_emit_vector_shuffle(struct spirv_builder *b, SpvId result_type,
198                                   SpvId vector_1, SpvId vector_2,
199                                   const uint32_t components[],
200                                   size_t num_components);
201 SpvId
202 spirv_builder_emit_vector_extract(struct spirv_builder *b, SpvId result_type,
203                                   SpvId vector_1,
204                                   uint32_t component);
205 SpvId
206 spirv_builder_emit_vector_insert(struct spirv_builder *b, SpvId result_type,
207                                   SpvId vector_1,
208                                   SpvId component,
209                                   uint32_t index);
210 void
211 spirv_builder_emit_branch(struct spirv_builder *b, SpvId label);
212 
213 void
214 spirv_builder_emit_selection_merge(struct spirv_builder *b, SpvId merge_block,
215                                    SpvSelectionControlMask selection_control);
216 
217 void
218 spirv_builder_loop_merge(struct spirv_builder *b, SpvId merge_block,
219                          SpvId cont_target, SpvLoopControlMask loop_control);
220 
221 void
222 spirv_builder_emit_branch_conditional(struct spirv_builder *b, SpvId condition,
223                                       SpvId true_label, SpvId false_label);
224 
225 SpvId
226 spirv_builder_emit_phi(struct spirv_builder *b, SpvId result_type,
227                        size_t num_vars, size_t *position);
228 
229 void
230 spirv_builder_set_phi_operand(struct spirv_builder *b, size_t position,
231                               size_t index, SpvId variable, SpvId parent);
232 
233 void
234 spirv_builder_emit_kill(struct spirv_builder *b);
235 
236 
237 SpvId
238 spirv_builder_emit_image_sample(struct spirv_builder *b,
239                                 SpvId result_type,
240                                 SpvId sampled_image,
241                                 SpvId coordinate,
242                                 bool proj,
243                                 SpvId lod,
244                                 SpvId bias,
245                                 SpvId dref,
246                                 SpvId dx,
247                                 SpvId dy,
248                                 SpvId offset);
249 
250 SpvId
251 spirv_builder_emit_image(struct spirv_builder *b, SpvId result_type,
252                          SpvId sampled_image);
253 
254 SpvId
255 spirv_builder_emit_image_fetch(struct spirv_builder *b,
256                                SpvId result_type,
257                                SpvId image,
258                                SpvId coordinate,
259                                SpvId lod,
260                                SpvId sample);
261 
262 SpvId
263 spirv_builder_emit_image_query_size(struct spirv_builder *b,
264                                     SpvId result_type,
265                                     SpvId image,
266                                     SpvId lod);
267 
268 SpvId
269 spirv_builder_emit_ext_inst(struct spirv_builder *b, SpvId result_type,
270                             SpvId set, uint32_t instruction,
271                             const SpvId args[], size_t num_args);
272 
273 SpvId
274 spirv_builder_type_void(struct spirv_builder *b);
275 
276 SpvId
277 spirv_builder_type_bool(struct spirv_builder *b);
278 
279 SpvId
280 spirv_builder_type_int(struct spirv_builder *b, unsigned width);
281 
282 SpvId
283 spirv_builder_type_uint(struct spirv_builder *b, unsigned width);
284 
285 SpvId
286 spirv_builder_type_float(struct spirv_builder *b, unsigned width);
287 
288 SpvId
289 spirv_builder_type_image(struct spirv_builder *b, SpvId sampled_type,
290                          SpvDim dim, bool depth, bool arrayed, bool ms,
291                          unsigned sampled, SpvImageFormat image_format);
292 
293 SpvId
294 spirv_builder_type_sampled_image(struct spirv_builder *b, SpvId image_type);
295 
296 SpvId
297 spirv_builder_type_pointer(struct spirv_builder *b,
298                            SpvStorageClass storage_class, SpvId type);
299 
300 SpvId
301 spirv_builder_type_vector(struct spirv_builder *b, SpvId component_type,
302                           unsigned component_count);
303 
304 SpvId
305 spirv_builder_type_array(struct spirv_builder *b, SpvId component_type,
306                          SpvId length);
307 
308 SpvId
309 spirv_builder_type_struct(struct spirv_builder *b, const SpvId member_types[],
310                           size_t num_member_types);
311 
312 SpvId
313 spirv_builder_type_function(struct spirv_builder *b, SpvId return_type,
314                             const SpvId parameter_types[],
315                             size_t num_parameter_types);
316 
317 SpvId
318 spirv_builder_const_bool(struct spirv_builder *b, bool val);
319 
320 SpvId
321 spirv_builder_const_int(struct spirv_builder *b, int width, int32_t val);
322 
323 SpvId
324 spirv_builder_const_uint(struct spirv_builder *b, int width, uint32_t val);
325 
326 SpvId
327 spirv_builder_const_float(struct spirv_builder *b, int width, float val);
328 
329 SpvId
330 spirv_builder_const_composite(struct spirv_builder *b, SpvId result_type,
331                               const SpvId constituents[],
332                               size_t num_constituents);
333 
334 SpvId
335 spirv_builder_emit_var(struct spirv_builder *b, SpvId type,
336                        SpvStorageClass storage_class);
337 
338 SpvId
339 spirv_builder_import(struct spirv_builder *b, const char *name);
340 
341 size_t
342 spirv_builder_get_num_words(struct spirv_builder *b);
343 
344 size_t
345 spirv_builder_get_words(struct spirv_builder *b, uint32_t *words,
346                         size_t num_words);
347 
348 #endif
349