cc4d24482d9364dbe9678e5c2702a6fc48425917
[mesa.git] / src / compiler / glsl / shader_cache.cpp
1 /*
2 * Copyright © 2014 Intel Corporation
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 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * 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 NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 /**
25 * \file shader_cache.cpp
26 *
27 * GLSL shader cache implementation
28 *
29 * This uses disk_cache.c to write out a serialization of various
30 * state that's required in order to successfully load and use a
31 * binary written out by a drivers backend, this state is referred to as
32 * "metadata" throughout the implementation.
33 *
34 * The hash key for glsl metadata is a hash of the hashes of each GLSL
35 * source string as well as some API settings that change the final program
36 * such as SSO, attribute bindings, frag data bindings, etc.
37 *
38 * In order to avoid caching any actual IR we use the put_key/get_key support
39 * in the disk_cache to put the SHA-1 hash for each successfully compiled
40 * shader into the cache, and optimisticly return early from glCompileShader
41 * (if the identical shader had been successfully compiled in the past),
42 * in the hope that the final linked shader will be found in the cache.
43 * If anything goes wrong (shader variant not found, backend cache item is
44 * corrupt, etc) we will use a fallback path to compile and link the IR.
45 */
46
47 #include "blob.h"
48 #include "compiler/shader_info.h"
49 #include "glsl_symbol_table.h"
50 #include "glsl_parser_extras.h"
51 #include "ir.h"
52 #include "ir_optimization.h"
53 #include "ir_rvalue_visitor.h"
54 #include "ir_uniform.h"
55 #include "linker.h"
56 #include "link_varyings.h"
57 #include "main/core.h"
58 #include "nir.h"
59 #include "program.h"
60 #include "shader_cache.h"
61 #include "util/mesa-sha1.h"
62 #include "util/string_to_uint_map.h"
63
64 extern "C" {
65 #include "main/enums.h"
66 #include "main/shaderobj.h"
67 #include "program/program.h"
68 }
69
70 static void
71 compile_shaders(struct gl_context *ctx, struct gl_shader_program *prog) {
72 for (unsigned i = 0; i < prog->NumShaders; i++) {
73 _mesa_glsl_compile_shader(ctx, prog->Shaders[i], false, false, true);
74 }
75 }
76
77 static void
78 encode_type_to_blob(struct blob *blob, const glsl_type *type)
79 {
80 uint32_t encoding;
81
82 switch (type->base_type) {
83 case GLSL_TYPE_UINT:
84 case GLSL_TYPE_INT:
85 case GLSL_TYPE_FLOAT:
86 case GLSL_TYPE_BOOL:
87 case GLSL_TYPE_DOUBLE:
88 case GLSL_TYPE_UINT64:
89 case GLSL_TYPE_INT64:
90 encoding = (type->base_type << 24) |
91 (type->vector_elements << 4) |
92 (type->matrix_columns);
93 break;
94 case GLSL_TYPE_SAMPLER:
95 encoding = (type->base_type) << 24 |
96 (type->sampler_dimensionality << 4) |
97 (type->sampler_shadow << 3) |
98 (type->sampler_array << 2) |
99 (type->sampled_type);
100 break;
101 case GLSL_TYPE_SUBROUTINE:
102 encoding = type->base_type << 24;
103 blob_write_uint32(blob, encoding);
104 blob_write_string(blob, type->name);
105 return;
106 case GLSL_TYPE_IMAGE:
107 encoding = (type->base_type) << 24 |
108 (type->sampler_dimensionality << 3) |
109 (type->sampler_array << 2) |
110 (type->sampled_type);
111 break;
112 case GLSL_TYPE_ATOMIC_UINT:
113 encoding = (type->base_type << 24);
114 break;
115 case GLSL_TYPE_ARRAY:
116 blob_write_uint32(blob, (type->base_type) << 24);
117 blob_write_uint32(blob, type->length);
118 encode_type_to_blob(blob, type->fields.array);
119 return;
120 case GLSL_TYPE_STRUCT:
121 case GLSL_TYPE_INTERFACE:
122 blob_write_uint32(blob, (type->base_type) << 24);
123 blob_write_string(blob, type->name);
124 blob_write_uint32(blob, type->length);
125 blob_write_bytes(blob, type->fields.structure,
126 sizeof(glsl_struct_field) * type->length);
127 for (unsigned i = 0; i < type->length; i++) {
128 encode_type_to_blob(blob, type->fields.structure[i].type);
129 blob_write_string(blob, type->fields.structure[i].name);
130 }
131
132 if (type->is_interface()) {
133 blob_write_uint32(blob, type->interface_packing);
134 blob_write_uint32(blob, type->interface_row_major);
135 }
136 return;
137 case GLSL_TYPE_VOID:
138 case GLSL_TYPE_ERROR:
139 default:
140 assert(!"Cannot encode type!");
141 encoding = 0;
142 break;
143 }
144
145 blob_write_uint32(blob, encoding);
146 }
147
148 static const glsl_type *
149 decode_type_from_blob(struct blob_reader *blob)
150 {
151 uint32_t u = blob_read_uint32(blob);
152 glsl_base_type base_type = (glsl_base_type) (u >> 24);
153
154 switch (base_type) {
155 case GLSL_TYPE_UINT:
156 case GLSL_TYPE_INT:
157 case GLSL_TYPE_FLOAT:
158 case GLSL_TYPE_BOOL:
159 case GLSL_TYPE_DOUBLE:
160 case GLSL_TYPE_UINT64:
161 case GLSL_TYPE_INT64:
162 return glsl_type::get_instance(base_type, (u >> 4) & 0x0f, u & 0x0f);
163 case GLSL_TYPE_SAMPLER:
164 return glsl_type::get_sampler_instance((enum glsl_sampler_dim) ((u >> 4) & 0x07),
165 (u >> 3) & 0x01,
166 (u >> 2) & 0x01,
167 (glsl_base_type) ((u >> 0) & 0x03));
168 case GLSL_TYPE_SUBROUTINE:
169 return glsl_type::get_subroutine_instance(blob_read_string(blob));
170 case GLSL_TYPE_IMAGE:
171 return glsl_type::get_image_instance((enum glsl_sampler_dim) ((u >> 3) & 0x07),
172 (u >> 2) & 0x01,
173 (glsl_base_type) ((u >> 0) & 0x03));
174 case GLSL_TYPE_ATOMIC_UINT:
175 return glsl_type::atomic_uint_type;
176 case GLSL_TYPE_ARRAY: {
177 unsigned length = blob_read_uint32(blob);
178 return glsl_type::get_array_instance(decode_type_from_blob(blob),
179 length);
180 }
181 case GLSL_TYPE_STRUCT:
182 case GLSL_TYPE_INTERFACE: {
183 char *name = blob_read_string(blob);
184 unsigned num_fields = blob_read_uint32(blob);
185 glsl_struct_field *fields = (glsl_struct_field *)
186 blob_read_bytes(blob, sizeof(glsl_struct_field) * num_fields);
187 for (unsigned i = 0; i < num_fields; i++) {
188 fields[i].type = decode_type_from_blob(blob);
189 fields[i].name = blob_read_string(blob);
190 }
191
192 if (base_type == GLSL_TYPE_INTERFACE) {
193 enum glsl_interface_packing packing =
194 (glsl_interface_packing) blob_read_uint32(blob);
195 bool row_major = blob_read_uint32(blob);
196 return glsl_type::get_interface_instance(fields, num_fields,
197 packing, row_major, name);
198 } else {
199 return glsl_type::get_record_instance(fields, num_fields, name);
200 }
201 }
202 case GLSL_TYPE_VOID:
203 case GLSL_TYPE_ERROR:
204 default:
205 assert(!"Cannot decode type!");
206 return NULL;
207 }
208 }
209
210 static void
211 write_subroutines(struct blob *metadata, struct gl_shader_program *prog)
212 {
213 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
214 struct gl_linked_shader *sh = prog->_LinkedShaders[i];
215 if (!sh)
216 continue;
217
218 struct gl_program *glprog = sh->Program;
219
220 blob_write_uint32(metadata, glprog->sh.NumSubroutineUniforms);
221 blob_write_uint32(metadata, glprog->sh.MaxSubroutineFunctionIndex);
222 blob_write_uint32(metadata, glprog->sh.NumSubroutineFunctions);
223 for (unsigned j = 0; j < glprog->sh.NumSubroutineFunctions; j++) {
224 int num_types = glprog->sh.SubroutineFunctions[j].num_compat_types;
225
226 blob_write_string(metadata, glprog->sh.SubroutineFunctions[j].name);
227 blob_write_uint32(metadata, glprog->sh.SubroutineFunctions[j].index);
228 blob_write_uint32(metadata, num_types);
229
230 for (int k = 0; k < num_types; k++) {
231 encode_type_to_blob(metadata,
232 glprog->sh.SubroutineFunctions[j].types[k]);
233 }
234 }
235 }
236 }
237
238 static void
239 read_subroutines(struct blob_reader *metadata, struct gl_shader_program *prog)
240 {
241 struct gl_subroutine_function *subs;
242
243 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
244 struct gl_linked_shader *sh = prog->_LinkedShaders[i];
245 if (!sh)
246 continue;
247
248 struct gl_program *glprog = sh->Program;
249
250 glprog->sh.NumSubroutineUniforms = blob_read_uint32(metadata);
251 glprog->sh.MaxSubroutineFunctionIndex = blob_read_uint32(metadata);
252 glprog->sh.NumSubroutineFunctions = blob_read_uint32(metadata);
253
254 subs = rzalloc_array(prog, struct gl_subroutine_function,
255 glprog->sh.NumSubroutineFunctions);
256 glprog->sh.SubroutineFunctions = subs;
257
258 for (unsigned j = 0; j < glprog->sh.NumSubroutineFunctions; j++) {
259 subs[j].name = ralloc_strdup(prog, blob_read_string (metadata));
260 subs[j].index = (int) blob_read_uint32(metadata);
261 subs[j].num_compat_types = (int) blob_read_uint32(metadata);
262
263 subs[j].types = rzalloc_array(prog, const struct glsl_type *,
264 subs[j].num_compat_types);
265 for (int k = 0; k < subs[j].num_compat_types; k++) {
266 subs[j].types[k] = decode_type_from_blob(metadata);
267 }
268 }
269 }
270 }
271
272 static void
273 write_buffer_block(struct blob *metadata, struct gl_uniform_block *b)
274 {
275 blob_write_string(metadata, b->Name);
276 blob_write_uint32(metadata, b->NumUniforms);
277 blob_write_uint32(metadata, b->Binding);
278 blob_write_uint32(metadata, b->UniformBufferSize);
279 blob_write_uint32(metadata, b->stageref);
280
281 for (unsigned j = 0; j < b->NumUniforms; j++) {
282 blob_write_string(metadata, b->Uniforms[j].Name);
283 blob_write_string(metadata, b->Uniforms[j].IndexName);
284 encode_type_to_blob(metadata, b->Uniforms[j].Type);
285 blob_write_uint32(metadata, b->Uniforms[j].Offset);
286 }
287 }
288
289 static void
290 write_buffer_blocks(struct blob *metadata, struct gl_shader_program *prog)
291 {
292 blob_write_uint32(metadata, prog->data->NumUniformBlocks);
293 blob_write_uint32(metadata, prog->data->NumShaderStorageBlocks);
294
295 for (unsigned i = 0; i < prog->data->NumUniformBlocks; i++) {
296 write_buffer_block(metadata, &prog->data->UniformBlocks[i]);
297 }
298
299 for (unsigned i = 0; i < prog->data->NumShaderStorageBlocks; i++) {
300 write_buffer_block(metadata, &prog->data->ShaderStorageBlocks[i]);
301 }
302
303 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
304 struct gl_linked_shader *sh = prog->_LinkedShaders[i];
305 if (!sh)
306 continue;
307
308 struct gl_program *glprog = sh->Program;
309
310 blob_write_uint32(metadata, glprog->info.num_ubos);
311 blob_write_uint32(metadata, glprog->info.num_ssbos);
312
313 for (unsigned j = 0; j < glprog->info.num_ubos; j++) {
314 uint32_t offset =
315 glprog->sh.UniformBlocks[j] - prog->data->UniformBlocks;
316 blob_write_uint32(metadata, offset);
317 }
318
319 for (unsigned j = 0; j < glprog->info.num_ssbos; j++) {
320 uint32_t offset = glprog->sh.ShaderStorageBlocks[j] -
321 prog->data->ShaderStorageBlocks;
322 blob_write_uint32(metadata, offset);
323 }
324 }
325 }
326
327 static void
328 read_buffer_block(struct blob_reader *metadata, struct gl_uniform_block *b,
329 struct gl_shader_program *prog)
330 {
331 b->Name = ralloc_strdup(prog->data, blob_read_string (metadata));
332 b->NumUniforms = blob_read_uint32(metadata);
333 b->Binding = blob_read_uint32(metadata);
334 b->UniformBufferSize = blob_read_uint32(metadata);
335 b->stageref = blob_read_uint32(metadata);
336
337 b->Uniforms =
338 rzalloc_array(prog->data, struct gl_uniform_buffer_variable,
339 b->NumUniforms);
340 for (unsigned j = 0; j < b->NumUniforms; j++) {
341 b->Uniforms[j].Name = ralloc_strdup(prog->data,
342 blob_read_string (metadata));
343
344 char *index_name = blob_read_string(metadata);
345 if (strcmp(b->Uniforms[j].Name, index_name) == 0) {
346 b->Uniforms[j].IndexName = b->Uniforms[j].Name;
347 } else {
348 b->Uniforms[j].IndexName = ralloc_strdup(prog->data, index_name);
349 }
350
351 b->Uniforms[j].Type = decode_type_from_blob(metadata);
352 b->Uniforms[j].Offset = blob_read_uint32(metadata);
353 }
354 }
355
356 static void
357 read_buffer_blocks(struct blob_reader *metadata,
358 struct gl_shader_program *prog)
359 {
360 prog->data->NumUniformBlocks = blob_read_uint32(metadata);
361 prog->data->NumShaderStorageBlocks = blob_read_uint32(metadata);
362
363 prog->data->UniformBlocks =
364 rzalloc_array(prog->data, struct gl_uniform_block,
365 prog->data->NumUniformBlocks);
366
367 prog->data->ShaderStorageBlocks =
368 rzalloc_array(prog->data, struct gl_uniform_block,
369 prog->data->NumShaderStorageBlocks);
370
371 for (unsigned i = 0; i < prog->data->NumUniformBlocks; i++) {
372 read_buffer_block(metadata, &prog->data->UniformBlocks[i], prog);
373 }
374
375 for (unsigned i = 0; i < prog->data->NumShaderStorageBlocks; i++) {
376 read_buffer_block(metadata, &prog->data->ShaderStorageBlocks[i], prog);
377 }
378
379 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
380 struct gl_linked_shader *sh = prog->_LinkedShaders[i];
381 if (!sh)
382 continue;
383
384 struct gl_program *glprog = sh->Program;
385
386 glprog->info.num_ubos = blob_read_uint32(metadata);
387 glprog->info.num_ssbos = blob_read_uint32(metadata);
388
389 glprog->sh.UniformBlocks =
390 rzalloc_array(glprog, gl_uniform_block *, glprog->info.num_ubos);
391 glprog->sh.ShaderStorageBlocks =
392 rzalloc_array(glprog, gl_uniform_block *, glprog->info.num_ssbos);
393
394 for (unsigned j = 0; j < glprog->info.num_ubos; j++) {
395 uint32_t offset = blob_read_uint32(metadata);
396 glprog->sh.UniformBlocks[j] = prog->data->UniformBlocks + offset;
397 }
398
399 for (unsigned j = 0; j < glprog->info.num_ssbos; j++) {
400 uint32_t offset = blob_read_uint32(metadata);
401 glprog->sh.ShaderStorageBlocks[j] =
402 prog->data->ShaderStorageBlocks + offset;
403 }
404 }
405 }
406
407 static void
408 write_atomic_buffers(struct blob *metadata, struct gl_shader_program *prog)
409 {
410 blob_write_uint32(metadata, prog->data->NumAtomicBuffers);
411
412 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
413 if (prog->_LinkedShaders[i]) {
414 struct gl_program *glprog = prog->_LinkedShaders[i]->Program;
415 blob_write_uint32(metadata, glprog->info.num_abos);
416 }
417 }
418
419 for (unsigned i = 0; i < prog->data->NumAtomicBuffers; i++) {
420 blob_write_uint32(metadata, prog->data->AtomicBuffers[i].Binding);
421 blob_write_uint32(metadata, prog->data->AtomicBuffers[i].MinimumSize);
422 blob_write_uint32(metadata, prog->data->AtomicBuffers[i].NumUniforms);
423
424 blob_write_bytes(metadata, prog->data->AtomicBuffers[i].StageReferences,
425 sizeof(prog->data->AtomicBuffers[i].StageReferences));
426
427 for (unsigned j = 0; j < prog->data->AtomicBuffers[i].NumUniforms; j++) {
428 blob_write_uint32(metadata, prog->data->AtomicBuffers[i].Uniforms[j]);
429 }
430 }
431 }
432
433 static void
434 read_atomic_buffers(struct blob_reader *metadata,
435 struct gl_shader_program *prog)
436 {
437 prog->data->NumAtomicBuffers = blob_read_uint32(metadata);
438 prog->data->AtomicBuffers =
439 rzalloc_array(prog, gl_active_atomic_buffer,
440 prog->data->NumAtomicBuffers);
441
442 struct gl_active_atomic_buffer **stage_buff_list[MESA_SHADER_STAGES];
443 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
444 if (prog->_LinkedShaders[i]) {
445 struct gl_program *glprog = prog->_LinkedShaders[i]->Program;
446
447 glprog->info.num_abos = blob_read_uint32(metadata);
448 glprog->sh.AtomicBuffers =
449 rzalloc_array(glprog, gl_active_atomic_buffer *,
450 glprog->info.num_abos);
451 stage_buff_list[i] = glprog->sh.AtomicBuffers;
452 }
453 }
454
455 for (unsigned i = 0; i < prog->data->NumAtomicBuffers; i++) {
456 prog->data->AtomicBuffers[i].Binding = blob_read_uint32(metadata);
457 prog->data->AtomicBuffers[i].MinimumSize = blob_read_uint32(metadata);
458 prog->data->AtomicBuffers[i].NumUniforms = blob_read_uint32(metadata);
459
460 blob_copy_bytes(metadata,
461 (uint8_t *) &prog->data->AtomicBuffers[i].StageReferences,
462 sizeof(prog->data->AtomicBuffers[i].StageReferences));
463
464 prog->data->AtomicBuffers[i].Uniforms = rzalloc_array(prog, unsigned,
465 prog->data->AtomicBuffers[i].NumUniforms);
466
467 for (unsigned j = 0; j < prog->data->AtomicBuffers[i].NumUniforms; j++) {
468 prog->data->AtomicBuffers[i].Uniforms[j] = blob_read_uint32(metadata);
469 }
470
471 for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
472 if (prog->data->AtomicBuffers[i].StageReferences[j]) {
473 *stage_buff_list[j] = &prog->data->AtomicBuffers[i];
474 stage_buff_list[j]++;
475 }
476 }
477 }
478 }
479
480 static void
481 write_xfb(struct blob *metadata, struct gl_shader_program *shProg)
482 {
483 struct gl_program *prog = shProg->last_vert_prog;
484
485 if (!prog) {
486 blob_write_uint32(metadata, ~0u);
487 return;
488 }
489
490 struct gl_transform_feedback_info *ltf = prog->sh.LinkedTransformFeedback;
491
492 blob_write_uint32(metadata, prog->info.stage);
493
494 blob_write_uint32(metadata, ltf->NumOutputs);
495 blob_write_uint32(metadata, ltf->ActiveBuffers);
496 blob_write_uint32(metadata, ltf->NumVarying);
497
498 blob_write_bytes(metadata, ltf->Outputs,
499 sizeof(struct gl_transform_feedback_output) *
500 ltf->NumOutputs);
501
502 for (int i = 0; i < ltf->NumVarying; i++) {
503 blob_write_string(metadata, ltf->Varyings[i].Name);
504 blob_write_uint32(metadata, ltf->Varyings[i].Type);
505 blob_write_uint32(metadata, ltf->Varyings[i].BufferIndex);
506 blob_write_uint32(metadata, ltf->Varyings[i].Size);
507 blob_write_uint32(metadata, ltf->Varyings[i].Offset);
508 }
509
510 blob_write_bytes(metadata, ltf->Buffers,
511 sizeof(struct gl_transform_feedback_buffer) *
512 MAX_FEEDBACK_BUFFERS);
513 }
514
515 static void
516 read_xfb(struct blob_reader *metadata, struct gl_shader_program *shProg)
517 {
518 unsigned xfb_stage = blob_read_uint32(metadata);
519
520 if (xfb_stage == ~0u)
521 return;
522
523 struct gl_program *prog = shProg->_LinkedShaders[xfb_stage]->Program;
524 struct gl_transform_feedback_info *ltf =
525 rzalloc(prog, struct gl_transform_feedback_info);
526
527 prog->sh.LinkedTransformFeedback = ltf;
528 shProg->last_vert_prog = prog;
529
530 ltf->NumOutputs = blob_read_uint32(metadata);
531 ltf->ActiveBuffers = blob_read_uint32(metadata);
532 ltf->NumVarying = blob_read_uint32(metadata);
533
534 ltf->Outputs = rzalloc_array(prog, struct gl_transform_feedback_output,
535 ltf->NumOutputs);
536
537 blob_copy_bytes(metadata, (uint8_t *) ltf->Outputs,
538 sizeof(struct gl_transform_feedback_output) *
539 ltf->NumOutputs);
540
541 ltf->Varyings = rzalloc_array(prog,
542 struct gl_transform_feedback_varying_info,
543 ltf->NumVarying);
544
545 for (int i = 0; i < ltf->NumVarying; i++) {
546 ltf->Varyings[i].Name = ralloc_strdup(prog, blob_read_string(metadata));
547 ltf->Varyings[i].Type = blob_read_uint32(metadata);
548 ltf->Varyings[i].BufferIndex = blob_read_uint32(metadata);
549 ltf->Varyings[i].Size = blob_read_uint32(metadata);
550 ltf->Varyings[i].Offset = blob_read_uint32(metadata);
551 }
552
553 blob_copy_bytes(metadata, (uint8_t *) ltf->Buffers,
554 sizeof(struct gl_transform_feedback_buffer) *
555 MAX_FEEDBACK_BUFFERS);
556 }
557
558 static void
559 write_uniforms(struct blob *metadata, struct gl_shader_program *prog)
560 {
561 blob_write_uint32(metadata, prog->SamplersValidated);
562 blob_write_uint32(metadata, prog->data->NumUniformStorage);
563 blob_write_uint32(metadata, prog->data->NumUniformDataSlots);
564
565 for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
566 encode_type_to_blob(metadata, prog->data->UniformStorage[i].type);
567 blob_write_uint32(metadata, prog->data->UniformStorage[i].array_elements);
568 blob_write_string(metadata, prog->data->UniformStorage[i].name);
569 blob_write_uint32(metadata, prog->data->UniformStorage[i].storage -
570 prog->data->UniformDataSlots);
571 blob_write_uint32(metadata, prog->data->UniformStorage[i].builtin);
572 blob_write_uint32(metadata, prog->data->UniformStorage[i].remap_location);
573 blob_write_uint32(metadata, prog->data->UniformStorage[i].block_index);
574 blob_write_uint32(metadata, prog->data->UniformStorage[i].atomic_buffer_index);
575 blob_write_uint32(metadata, prog->data->UniformStorage[i].offset);
576 blob_write_uint32(metadata, prog->data->UniformStorage[i].array_stride);
577 blob_write_uint32(metadata, prog->data->UniformStorage[i].hidden);
578 blob_write_uint32(metadata, prog->data->UniformStorage[i].is_shader_storage);
579 blob_write_uint32(metadata, prog->data->UniformStorage[i].active_shader_mask);
580 blob_write_uint32(metadata, prog->data->UniformStorage[i].matrix_stride);
581 blob_write_uint32(metadata, prog->data->UniformStorage[i].row_major);
582 blob_write_uint32(metadata, prog->data->UniformStorage[i].is_bindless);
583 blob_write_uint32(metadata,
584 prog->data->UniformStorage[i].num_compatible_subroutines);
585 blob_write_uint32(metadata,
586 prog->data->UniformStorage[i].top_level_array_size);
587 blob_write_uint32(metadata,
588 prog->data->UniformStorage[i].top_level_array_stride);
589 blob_write_bytes(metadata, prog->data->UniformStorage[i].opaque,
590 sizeof(prog->data->UniformStorage[i].opaque));
591 }
592
593 /* Here we cache all uniform values. We do this to retain values for
594 * uniforms with initialisers and also hidden uniforms that may be lowered
595 * constant arrays. We could possibly just store the values we need but for
596 * now we just store everything.
597 */
598 blob_write_uint32(metadata, prog->data->NumHiddenUniforms);
599 for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
600 if (!prog->data->UniformStorage[i].builtin &&
601 !prog->data->UniformStorage[i].is_shader_storage &&
602 prog->data->UniformStorage[i].block_index == -1) {
603 unsigned vec_size =
604 prog->data->UniformStorage[i].type->component_slots() *
605 MAX2(prog->data->UniformStorage[i].array_elements, 1);
606 blob_write_bytes(metadata, prog->data->UniformStorage[i].storage,
607 sizeof(union gl_constant_value) * vec_size);
608 }
609 }
610 }
611
612 static void
613 read_uniforms(struct blob_reader *metadata, struct gl_shader_program *prog)
614 {
615 struct gl_uniform_storage *uniforms;
616 union gl_constant_value *data;
617
618 prog->SamplersValidated = blob_read_uint32(metadata);
619 prog->data->NumUniformStorage = blob_read_uint32(metadata);
620 prog->data->NumUniformDataSlots = blob_read_uint32(metadata);
621
622 uniforms = rzalloc_array(prog, struct gl_uniform_storage,
623 prog->data->NumUniformStorage);
624 prog->data->UniformStorage = uniforms;
625
626 data = rzalloc_array(uniforms, union gl_constant_value,
627 prog->data->NumUniformDataSlots);
628 prog->data->UniformDataSlots = data;
629
630 prog->UniformHash = new string_to_uint_map;
631
632 for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
633 uniforms[i].type = decode_type_from_blob(metadata);
634 uniforms[i].array_elements = blob_read_uint32(metadata);
635 uniforms[i].name = ralloc_strdup(prog, blob_read_string (metadata));
636 uniforms[i].storage = data + blob_read_uint32(metadata);
637 uniforms[i].builtin = blob_read_uint32(metadata);
638 uniforms[i].remap_location = blob_read_uint32(metadata);
639 uniforms[i].block_index = blob_read_uint32(metadata);
640 uniforms[i].atomic_buffer_index = blob_read_uint32(metadata);
641 uniforms[i].offset = blob_read_uint32(metadata);
642 uniforms[i].array_stride = blob_read_uint32(metadata);
643 uniforms[i].hidden = blob_read_uint32(metadata);
644 uniforms[i].is_shader_storage = blob_read_uint32(metadata);
645 uniforms[i].active_shader_mask = blob_read_uint32(metadata);
646 uniforms[i].matrix_stride = blob_read_uint32(metadata);
647 uniforms[i].row_major = blob_read_uint32(metadata);
648 uniforms[i].is_bindless = blob_read_uint32(metadata);
649 uniforms[i].num_compatible_subroutines = blob_read_uint32(metadata);
650 uniforms[i].top_level_array_size = blob_read_uint32(metadata);
651 uniforms[i].top_level_array_stride = blob_read_uint32(metadata);
652 prog->UniformHash->put(i, uniforms[i].name);
653
654 memcpy(uniforms[i].opaque,
655 blob_read_bytes(metadata, sizeof(uniforms[i].opaque)),
656 sizeof(uniforms[i].opaque));
657 }
658
659 /* Restore uniform values. */
660 prog->data->NumHiddenUniforms = blob_read_uint32(metadata);
661 for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
662 if (!prog->data->UniformStorage[i].builtin &&
663 !prog->data->UniformStorage[i].is_shader_storage &&
664 prog->data->UniformStorage[i].block_index == -1) {
665 unsigned vec_size =
666 prog->data->UniformStorage[i].type->component_slots() *
667 MAX2(prog->data->UniformStorage[i].array_elements, 1);
668 blob_copy_bytes(metadata,
669 (uint8_t *) prog->data->UniformStorage[i].storage,
670 sizeof(union gl_constant_value) * vec_size);
671
672 assert(vec_size + prog->data->UniformStorage[i].storage <=
673 data + prog->data->NumUniformDataSlots);
674 }
675 }
676 }
677
678 enum uniform_remap_type
679 {
680 remap_type_inactive_explicit_location,
681 remap_type_null_ptr,
682 remap_type_uniform_offset
683 };
684
685 static void
686 write_uniform_remap_table_entry(struct blob *metadata,
687 gl_uniform_storage *uniform_storage,
688 gl_uniform_storage *entry)
689 {
690 if (entry == INACTIVE_UNIFORM_EXPLICIT_LOCATION) {
691 blob_write_uint32(metadata, remap_type_inactive_explicit_location);
692 } else if (entry == NULL) {
693 blob_write_uint32(metadata, remap_type_null_ptr);
694 } else {
695 blob_write_uint32(metadata, remap_type_uniform_offset);
696
697 uint32_t offset = entry - uniform_storage;
698 blob_write_uint32(metadata, offset);
699 }
700 }
701
702 static void
703 write_uniform_remap_tables(struct blob *metadata,
704 struct gl_shader_program *prog)
705 {
706 blob_write_uint32(metadata, prog->NumUniformRemapTable);
707
708 for (unsigned i = 0; i < prog->NumUniformRemapTable; i++) {
709 write_uniform_remap_table_entry(metadata, prog->data->UniformStorage,
710 prog->UniformRemapTable[i]);
711 }
712
713 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
714 struct gl_linked_shader *sh = prog->_LinkedShaders[i];
715 if (sh) {
716 struct gl_program *glprog = sh->Program;
717 blob_write_uint32(metadata, glprog->sh.NumSubroutineUniformRemapTable);
718
719 for (unsigned j = 0; j < glprog->sh.NumSubroutineUniformRemapTable; j++) {
720 write_uniform_remap_table_entry(metadata,
721 prog->data->UniformStorage,
722 glprog->sh.SubroutineUniformRemapTable[j]);
723 }
724 }
725 }
726 }
727
728 static void
729 read_uniform_remap_table_entry(struct blob_reader *metadata,
730 gl_uniform_storage *uniform_storage,
731 gl_uniform_storage **entry,
732 enum uniform_remap_type type)
733 {
734 if (type == remap_type_inactive_explicit_location) {
735 *entry = INACTIVE_UNIFORM_EXPLICIT_LOCATION;
736 } else if (type == remap_type_null_ptr) {
737 *entry = NULL;
738 } else {
739 uint32_t uni_offset = blob_read_uint32(metadata);
740 *entry = uniform_storage + uni_offset;
741 }
742 }
743
744 static void
745 read_uniform_remap_tables(struct blob_reader *metadata,
746 struct gl_shader_program *prog)
747 {
748 prog->NumUniformRemapTable = blob_read_uint32(metadata);
749
750 prog->UniformRemapTable = rzalloc_array(prog, struct gl_uniform_storage *,
751 prog->NumUniformRemapTable);
752
753 for (unsigned i = 0; i < prog->NumUniformRemapTable; i++) {
754 enum uniform_remap_type type =
755 (enum uniform_remap_type) blob_read_uint32(metadata);
756
757 read_uniform_remap_table_entry(metadata, prog->data->UniformStorage,
758 &prog->UniformRemapTable[i], type);
759 }
760
761 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
762 struct gl_linked_shader *sh = prog->_LinkedShaders[i];
763 if (sh) {
764 struct gl_program *glprog = sh->Program;
765 glprog->sh.NumSubroutineUniformRemapTable = blob_read_uint32(metadata);
766
767 glprog->sh.SubroutineUniformRemapTable =
768 rzalloc_array(glprog, struct gl_uniform_storage *,
769 glprog->sh.NumSubroutineUniformRemapTable);
770
771 for (unsigned j = 0; j < glprog->sh.NumSubroutineUniformRemapTable; j++) {
772 enum uniform_remap_type type =
773 (enum uniform_remap_type) blob_read_uint32(metadata);
774
775 read_uniform_remap_table_entry(metadata,
776 prog->data->UniformStorage,
777 &glprog->sh.SubroutineUniformRemapTable[j],
778 type);
779 }
780 }
781 }
782 }
783
784 struct whte_closure
785 {
786 struct blob *blob;
787 size_t num_entries;
788 };
789
790 static void
791 write_hash_table_entry(const char *key, unsigned value, void *closure)
792 {
793 struct whte_closure *whte = (struct whte_closure *) closure;
794
795 blob_write_string(whte->blob, key);
796 blob_write_uint32(whte->blob, value);
797
798 whte->num_entries++;
799 }
800
801 static void
802 write_hash_table(struct blob *metadata, struct string_to_uint_map *hash)
803 {
804 size_t offset;
805 struct whte_closure whte;
806
807 whte.blob = metadata;
808 whte.num_entries = 0;
809
810 offset = metadata->size;
811
812 /* Write a placeholder for the hashtable size. */
813 blob_write_uint32 (metadata, 0);
814
815 hash->iterate(write_hash_table_entry, &whte);
816
817 /* Overwrite with the computed number of entries written. */
818 blob_overwrite_uint32 (metadata, offset, whte.num_entries);
819 }
820
821 static void
822 read_hash_table(struct blob_reader *metadata, struct string_to_uint_map *hash)
823 {
824 size_t i, num_entries;
825 const char *key;
826 uint32_t value;
827
828 num_entries = blob_read_uint32 (metadata);
829
830 for (i = 0; i < num_entries; i++) {
831 key = blob_read_string(metadata);
832 value = blob_read_uint32(metadata);
833
834 hash->put(value, key);
835 }
836 }
837
838 static void
839 write_hash_tables(struct blob *metadata, struct gl_shader_program *prog)
840 {
841 write_hash_table(metadata, prog->AttributeBindings);
842 write_hash_table(metadata, prog->FragDataBindings);
843 write_hash_table(metadata, prog->FragDataIndexBindings);
844 }
845
846 static void
847 read_hash_tables(struct blob_reader *metadata, struct gl_shader_program *prog)
848 {
849 read_hash_table(metadata, prog->AttributeBindings);
850 read_hash_table(metadata, prog->FragDataBindings);
851 read_hash_table(metadata, prog->FragDataIndexBindings);
852 }
853
854 static void
855 write_shader_subroutine_index(struct blob *metadata,
856 struct gl_linked_shader *sh,
857 struct gl_program_resource *res)
858 {
859 assert(sh);
860
861 for (unsigned j = 0; j < sh->Program->sh.NumSubroutineFunctions; j++) {
862 if (strcmp(((gl_subroutine_function *)res->Data)->name,
863 sh->Program->sh.SubroutineFunctions[j].name) == 0) {
864 blob_write_uint32(metadata, j);
865 break;
866 }
867 }
868 }
869
870 static void
871 write_program_resource_data(struct blob *metadata,
872 struct gl_shader_program *prog,
873 struct gl_program_resource *res)
874 {
875 struct gl_linked_shader *sh;
876
877 switch(res->Type) {
878 case GL_PROGRAM_INPUT:
879 case GL_PROGRAM_OUTPUT: {
880 const gl_shader_variable *var = (gl_shader_variable *)res->Data;
881 blob_write_bytes(metadata, var, sizeof(gl_shader_variable));
882 encode_type_to_blob(metadata, var->type);
883
884 if (var->interface_type)
885 encode_type_to_blob(metadata, var->interface_type);
886
887 if (var->outermost_struct_type)
888 encode_type_to_blob(metadata, var->outermost_struct_type);
889
890 blob_write_string(metadata, var->name);
891 break;
892 }
893 case GL_UNIFORM_BLOCK:
894 for (unsigned i = 0; i < prog->data->NumUniformBlocks; i++) {
895 if (strcmp(((gl_uniform_block *)res->Data)->Name,
896 prog->data->UniformBlocks[i].Name) == 0) {
897 blob_write_uint32(metadata, i);
898 break;
899 }
900 }
901 break;
902 case GL_SHADER_STORAGE_BLOCK:
903 for (unsigned i = 0; i < prog->data->NumShaderStorageBlocks; i++) {
904 if (strcmp(((gl_uniform_block *)res->Data)->Name,
905 prog->data->ShaderStorageBlocks[i].Name) == 0) {
906 blob_write_uint32(metadata, i);
907 break;
908 }
909 }
910 break;
911 case GL_BUFFER_VARIABLE:
912 case GL_VERTEX_SUBROUTINE_UNIFORM:
913 case GL_GEOMETRY_SUBROUTINE_UNIFORM:
914 case GL_FRAGMENT_SUBROUTINE_UNIFORM:
915 case GL_COMPUTE_SUBROUTINE_UNIFORM:
916 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
917 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
918 case GL_UNIFORM:
919 for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
920 if (strcmp(((gl_uniform_storage *)res->Data)->name,
921 prog->data->UniformStorage[i].name) == 0) {
922 blob_write_uint32(metadata, i);
923 break;
924 }
925 }
926 break;
927 case GL_ATOMIC_COUNTER_BUFFER:
928 for (unsigned i = 0; i < prog->data->NumAtomicBuffers; i++) {
929 if (((gl_active_atomic_buffer *)res->Data)->Binding ==
930 prog->data->AtomicBuffers[i].Binding) {
931 blob_write_uint32(metadata, i);
932 break;
933 }
934 }
935 break;
936 case GL_TRANSFORM_FEEDBACK_BUFFER:
937 for (unsigned i = 0; i < MAX_FEEDBACK_BUFFERS; i++) {
938 if (((gl_transform_feedback_buffer *)res->Data)->Binding ==
939 prog->last_vert_prog->sh.LinkedTransformFeedback->Buffers[i].Binding) {
940 blob_write_uint32(metadata, i);
941 break;
942 }
943 }
944 break;
945 case GL_TRANSFORM_FEEDBACK_VARYING:
946 for (int i = 0; i < prog->last_vert_prog->sh.LinkedTransformFeedback->NumVarying; i++) {
947 if (strcmp(((gl_transform_feedback_varying_info *)res->Data)->Name,
948 prog->last_vert_prog->sh.LinkedTransformFeedback->Varyings[i].Name) == 0) {
949 blob_write_uint32(metadata, i);
950 break;
951 }
952 }
953 break;
954 case GL_VERTEX_SUBROUTINE:
955 case GL_TESS_CONTROL_SUBROUTINE:
956 case GL_TESS_EVALUATION_SUBROUTINE:
957 case GL_GEOMETRY_SUBROUTINE:
958 case GL_FRAGMENT_SUBROUTINE:
959 case GL_COMPUTE_SUBROUTINE:
960 sh =
961 prog->_LinkedShaders[_mesa_shader_stage_from_subroutine(res->Type)];
962 write_shader_subroutine_index(metadata, sh, res);
963 break;
964 default:
965 assert(!"Support for writing resource not yet implemented.");
966 }
967 }
968
969 static void
970 read_program_resource_data(struct blob_reader *metadata,
971 struct gl_shader_program *prog,
972 struct gl_program_resource *res)
973 {
974 struct gl_linked_shader *sh;
975
976 switch(res->Type) {
977 case GL_PROGRAM_INPUT:
978 case GL_PROGRAM_OUTPUT: {
979 gl_shader_variable *var = ralloc(prog, struct gl_shader_variable);
980
981 blob_copy_bytes(metadata, (uint8_t *) var, sizeof(gl_shader_variable));
982 var->type = decode_type_from_blob(metadata);
983
984 if (var->interface_type)
985 var->interface_type = decode_type_from_blob(metadata);
986
987 if (var->outermost_struct_type)
988 var->outermost_struct_type = decode_type_from_blob(metadata);
989
990 var->name = ralloc_strdup(prog, blob_read_string(metadata));
991
992 res->Data = var;
993 break;
994 }
995 case GL_UNIFORM_BLOCK:
996 res->Data = &prog->data->UniformBlocks[blob_read_uint32(metadata)];
997 break;
998 case GL_SHADER_STORAGE_BLOCK:
999 res->Data = &prog->data->ShaderStorageBlocks[blob_read_uint32(metadata)];
1000 break;
1001 case GL_BUFFER_VARIABLE:
1002 case GL_VERTEX_SUBROUTINE_UNIFORM:
1003 case GL_GEOMETRY_SUBROUTINE_UNIFORM:
1004 case GL_FRAGMENT_SUBROUTINE_UNIFORM:
1005 case GL_COMPUTE_SUBROUTINE_UNIFORM:
1006 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
1007 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
1008 case GL_UNIFORM:
1009 res->Data = &prog->data->UniformStorage[blob_read_uint32(metadata)];
1010 break;
1011 case GL_ATOMIC_COUNTER_BUFFER:
1012 res->Data = &prog->data->AtomicBuffers[blob_read_uint32(metadata)];
1013 break;
1014 case GL_TRANSFORM_FEEDBACK_BUFFER:
1015 res->Data = &prog->last_vert_prog->
1016 sh.LinkedTransformFeedback->Buffers[blob_read_uint32(metadata)];
1017 break;
1018 case GL_TRANSFORM_FEEDBACK_VARYING:
1019 res->Data = &prog->last_vert_prog->
1020 sh.LinkedTransformFeedback->Varyings[blob_read_uint32(metadata)];
1021 break;
1022 case GL_VERTEX_SUBROUTINE:
1023 case GL_TESS_CONTROL_SUBROUTINE:
1024 case GL_TESS_EVALUATION_SUBROUTINE:
1025 case GL_GEOMETRY_SUBROUTINE:
1026 case GL_FRAGMENT_SUBROUTINE:
1027 case GL_COMPUTE_SUBROUTINE:
1028 sh =
1029 prog->_LinkedShaders[_mesa_shader_stage_from_subroutine(res->Type)];
1030 res->Data =
1031 &sh->Program->sh.SubroutineFunctions[blob_read_uint32(metadata)];
1032 break;
1033 default:
1034 assert(!"Support for reading resource not yet implemented.");
1035 }
1036 }
1037
1038 static void
1039 write_program_resource_list(struct blob *metadata,
1040 struct gl_shader_program *prog)
1041 {
1042 blob_write_uint32(metadata, prog->data->NumProgramResourceList);
1043
1044 for (unsigned i = 0; i < prog->data->NumProgramResourceList; i++) {
1045 blob_write_uint32(metadata, prog->data->ProgramResourceList[i].Type);
1046 write_program_resource_data(metadata, prog,
1047 &prog->data->ProgramResourceList[i]);
1048 blob_write_bytes(metadata,
1049 &prog->data->ProgramResourceList[i].StageReferences,
1050 sizeof(prog->data->ProgramResourceList[i].StageReferences));
1051 }
1052 }
1053
1054 static void
1055 read_program_resource_list(struct blob_reader *metadata,
1056 struct gl_shader_program *prog)
1057 {
1058 prog->data->NumProgramResourceList = blob_read_uint32(metadata);
1059
1060 prog->data->ProgramResourceList =
1061 ralloc_array(prog, gl_program_resource,
1062 prog->data->NumProgramResourceList);
1063
1064 for (unsigned i = 0; i < prog->data->NumProgramResourceList; i++) {
1065 prog->data->ProgramResourceList[i].Type = blob_read_uint32(metadata);
1066 read_program_resource_data(metadata, prog,
1067 &prog->data->ProgramResourceList[i]);
1068 blob_copy_bytes(metadata,
1069 (uint8_t *) &prog->data->ProgramResourceList[i].StageReferences,
1070 sizeof(prog->data->ProgramResourceList[i].StageReferences));
1071 }
1072 }
1073
1074 static void
1075 write_shader_parameters(struct blob *metadata,
1076 struct gl_program_parameter_list *params)
1077 {
1078 blob_write_uint32(metadata, params->NumParameters);
1079 uint32_t i = 0;
1080
1081 while (i < params->NumParameters) {
1082 struct gl_program_parameter *param = &params->Parameters[i];
1083
1084 blob_write_uint32(metadata, param->Type);
1085 blob_write_string(metadata, param->Name);
1086 blob_write_uint32(metadata, param->Size);
1087 blob_write_uint32(metadata, param->DataType);
1088 blob_write_bytes(metadata, param->StateIndexes,
1089 sizeof(param->StateIndexes));
1090
1091 i += (param->Size + 3) / 4;
1092 }
1093
1094 blob_write_bytes(metadata, params->ParameterValues,
1095 sizeof(gl_constant_value) * 4 * params->NumParameters);
1096
1097 blob_write_uint32(metadata, params->StateFlags);
1098 }
1099
1100 static void
1101 read_shader_parameters(struct blob_reader *metadata,
1102 struct gl_program_parameter_list *params)
1103 {
1104 gl_state_index state_indexes[STATE_LENGTH];
1105 uint32_t i = 0;
1106 uint32_t num_parameters = blob_read_uint32(metadata);
1107
1108 _mesa_reserve_parameter_storage(params, num_parameters);
1109 while (i < num_parameters) {
1110 gl_register_file type = (gl_register_file) blob_read_uint32(metadata);
1111 const char *name = blob_read_string(metadata);
1112 unsigned size = blob_read_uint32(metadata);
1113 unsigned data_type = blob_read_uint32(metadata);
1114 blob_copy_bytes(metadata, (uint8_t *) state_indexes,
1115 sizeof(state_indexes));
1116
1117 _mesa_add_parameter(params, type, name, size, data_type,
1118 NULL, state_indexes);
1119
1120 i += (size + 3) / 4;
1121 }
1122
1123 blob_copy_bytes(metadata, (uint8_t *) params->ParameterValues,
1124 sizeof(gl_constant_value) * 4 * params->NumParameters);
1125
1126 params->StateFlags = blob_read_uint32(metadata);
1127 }
1128
1129 static void
1130 write_shader_metadata(struct blob *metadata, gl_linked_shader *shader)
1131 {
1132 assert(shader->Program);
1133 struct gl_program *glprog = shader->Program;
1134 unsigned i;
1135
1136 blob_write_bytes(metadata, glprog->TexturesUsed,
1137 sizeof(glprog->TexturesUsed));
1138 blob_write_uint64(metadata, glprog->SamplersUsed);
1139
1140 blob_write_bytes(metadata, glprog->SamplerUnits,
1141 sizeof(glprog->SamplerUnits));
1142 blob_write_bytes(metadata, glprog->sh.SamplerTargets,
1143 sizeof(glprog->sh.SamplerTargets));
1144 blob_write_uint32(metadata, glprog->ShadowSamplers);
1145
1146 blob_write_bytes(metadata, glprog->sh.ImageAccess,
1147 sizeof(glprog->sh.ImageAccess));
1148 blob_write_bytes(metadata, glprog->sh.ImageUnits,
1149 sizeof(glprog->sh.ImageUnits));
1150
1151 blob_write_uint32(metadata, glprog->sh.NumBindlessSamplers);
1152 blob_write_uint32(metadata, glprog->sh.HasBoundBindlessSampler);
1153 for (i = 0; i < glprog->sh.NumBindlessSamplers; i++) {
1154 blob_write_bytes(metadata, &glprog->sh.BindlessSamplers[i],
1155 sizeof(struct gl_bindless_sampler));
1156 }
1157
1158 blob_write_uint32(metadata, glprog->sh.NumBindlessImages);
1159 blob_write_uint32(metadata, glprog->sh.HasBoundBindlessImage);
1160 for (i = 0; i < glprog->sh.NumBindlessImages; i++) {
1161 blob_write_bytes(metadata, &glprog->sh.BindlessImages[i],
1162 sizeof(struct gl_bindless_image));
1163 }
1164
1165 write_shader_parameters(metadata, glprog->Parameters);
1166 }
1167
1168 static void
1169 read_shader_metadata(struct blob_reader *metadata,
1170 struct gl_program *glprog,
1171 gl_linked_shader *linked)
1172 {
1173 unsigned i;
1174
1175 blob_copy_bytes(metadata, (uint8_t *) glprog->TexturesUsed,
1176 sizeof(glprog->TexturesUsed));
1177 glprog->SamplersUsed = blob_read_uint64(metadata);
1178
1179 blob_copy_bytes(metadata, (uint8_t *) glprog->SamplerUnits,
1180 sizeof(glprog->SamplerUnits));
1181 blob_copy_bytes(metadata, (uint8_t *) glprog->sh.SamplerTargets,
1182 sizeof(glprog->sh.SamplerTargets));
1183 glprog->ShadowSamplers = blob_read_uint32(metadata);
1184
1185 blob_copy_bytes(metadata, (uint8_t *) glprog->sh.ImageAccess,
1186 sizeof(glprog->sh.ImageAccess));
1187 blob_copy_bytes(metadata, (uint8_t *) glprog->sh.ImageUnits,
1188 sizeof(glprog->sh.ImageUnits));
1189
1190 glprog->sh.NumBindlessSamplers = blob_read_uint32(metadata);
1191 glprog->sh.HasBoundBindlessSampler = blob_read_uint32(metadata);
1192 if (glprog->sh.NumBindlessSamplers > 0) {
1193 glprog->sh.BindlessSamplers =
1194 rzalloc_array(glprog, gl_bindless_sampler,
1195 glprog->sh.NumBindlessSamplers);
1196
1197 for (i = 0; i < glprog->sh.NumBindlessSamplers; i++) {
1198 blob_copy_bytes(metadata, (uint8_t *) &glprog->sh.BindlessSamplers[i],
1199 sizeof(struct gl_bindless_sampler));
1200 }
1201 }
1202
1203 glprog->sh.NumBindlessImages = blob_read_uint32(metadata);
1204 glprog->sh.HasBoundBindlessImage = blob_read_uint32(metadata);
1205 if (glprog->sh.NumBindlessImages > 0) {
1206 glprog->sh.BindlessImages =
1207 rzalloc_array(glprog, gl_bindless_image,
1208 glprog->sh.NumBindlessImages);
1209
1210 for (i = 0; i < glprog->sh.NumBindlessImages; i++) {
1211 blob_copy_bytes(metadata, (uint8_t *) &glprog->sh.BindlessImages[i],
1212 sizeof(struct gl_bindless_image));
1213 }
1214 }
1215
1216 glprog->Parameters = _mesa_new_parameter_list();
1217 read_shader_parameters(metadata, glprog->Parameters);
1218 }
1219
1220 static void
1221 create_binding_str(const char *key, unsigned value, void *closure)
1222 {
1223 char **bindings_str = (char **) closure;
1224 ralloc_asprintf_append(bindings_str, "%s:%u,", key, value);
1225 }
1226
1227 static void
1228 create_linked_shader_and_program(struct gl_context *ctx,
1229 gl_shader_stage stage,
1230 struct gl_shader_program *prog,
1231 struct blob_reader *metadata)
1232 {
1233 struct gl_program *glprog;
1234
1235 struct gl_linked_shader *linked = rzalloc(NULL, struct gl_linked_shader);
1236 linked->Stage = stage;
1237
1238 glprog = ctx->Driver.NewProgram(ctx, _mesa_shader_stage_to_program(stage),
1239 prog->Name, false);
1240 glprog->info.stage = stage;
1241 linked->Program = glprog;
1242
1243 read_shader_metadata(metadata, glprog, linked);
1244
1245 /* Restore shader info */
1246 blob_copy_bytes(metadata, (uint8_t *) &glprog->info, sizeof(shader_info));
1247 if (glprog->info.name)
1248 glprog->info.name = ralloc_strdup(glprog, blob_read_string(metadata));
1249 if (glprog->info.label)
1250 glprog->info.label = ralloc_strdup(glprog, blob_read_string(metadata));
1251
1252 _mesa_reference_shader_program_data(ctx, &glprog->sh.data, prog->data);
1253 _mesa_reference_program(ctx, &linked->Program, glprog);
1254 prog->_LinkedShaders[stage] = linked;
1255 }
1256
1257 void
1258 shader_cache_write_program_metadata(struct gl_context *ctx,
1259 struct gl_shader_program *prog)
1260 {
1261 struct disk_cache *cache = ctx->Cache;
1262 if (!cache)
1263 return;
1264
1265 /* Exit early when we are dealing with a ff shader with no source file to
1266 * generate a source from.
1267 *
1268 * TODO: In future we should use another method to generate a key for ff
1269 * programs.
1270 */
1271 static const char zero[sizeof(prog->data->sha1)] = {0};
1272 if (memcmp(prog->data->sha1, zero, sizeof(prog->data->sha1)) == 0)
1273 return;
1274
1275 struct blob *metadata = blob_create();
1276
1277 write_uniforms(metadata, prog);
1278
1279 write_hash_tables(metadata, prog);
1280
1281 blob_write_uint32(metadata, prog->data->Version);
1282 blob_write_uint32(metadata, prog->data->linked_stages);
1283
1284 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
1285 struct gl_linked_shader *sh = prog->_LinkedShaders[i];
1286 if (sh) {
1287 write_shader_metadata(metadata, sh);
1288
1289 /* Store nir shader info */
1290 blob_write_bytes(metadata, &sh->Program->info, sizeof(shader_info));
1291
1292 if (sh->Program->info.name)
1293 blob_write_string(metadata, sh->Program->info.name);
1294
1295 if (sh->Program->info.label)
1296 blob_write_string(metadata, sh->Program->info.label);
1297 }
1298 }
1299
1300 write_xfb(metadata, prog);
1301
1302 write_uniform_remap_tables(metadata, prog);
1303
1304 write_atomic_buffers(metadata, prog);
1305
1306 write_buffer_blocks(metadata, prog);
1307
1308 write_subroutines(metadata, prog);
1309
1310 write_program_resource_list(metadata, prog);
1311
1312 char sha1_buf[41];
1313 for (unsigned i = 0; i < prog->NumShaders; i++) {
1314 disk_cache_put_key(cache, prog->Shaders[i]->sha1);
1315 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) {
1316 _mesa_sha1_format(sha1_buf, prog->Shaders[i]->sha1);
1317 fprintf(stderr, "marking shader: %s\n", sha1_buf);
1318 }
1319 }
1320
1321 disk_cache_put(cache, prog->data->sha1, metadata->data, metadata->size);
1322
1323 blob_destroy(metadata);
1324
1325 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) {
1326 _mesa_sha1_format(sha1_buf, prog->data->sha1);
1327 fprintf(stderr, "putting program metadata in cache: %s\n", sha1_buf);
1328 }
1329 }
1330
1331 bool
1332 shader_cache_read_program_metadata(struct gl_context *ctx,
1333 struct gl_shader_program *prog)
1334 {
1335 /* Fixed function programs generated by Mesa are not cached. So don't
1336 * try to read metadata for them from the cache.
1337 */
1338 if (prog->Name == 0)
1339 return false;
1340
1341 struct disk_cache *cache = ctx->Cache;
1342 if (!cache || prog->data->cache_fallback || prog->data->skip_cache)
1343 return false;
1344
1345 /* Include bindings when creating sha1. These bindings change the resulting
1346 * binary so they are just as important as the shader source.
1347 */
1348 char *buf = ralloc_strdup(NULL, "vb: ");
1349 prog->AttributeBindings->iterate(create_binding_str, &buf);
1350 ralloc_strcat(&buf, "fb: ");
1351 prog->FragDataBindings->iterate(create_binding_str, &buf);
1352 ralloc_strcat(&buf, "fbi: ");
1353 prog->FragDataIndexBindings->iterate(create_binding_str, &buf);
1354
1355 /* SSO has an effect on the linked program so include this when generating
1356 * the sha also.
1357 */
1358 ralloc_asprintf_append(&buf, "sso: %s\n",
1359 prog->SeparateShader ? "T" : "F");
1360
1361 /* A shader might end up producing different output depending on the glsl
1362 * version supported by the compiler. For example a different path might be
1363 * taken by the preprocessor, so add the version to the hash input.
1364 */
1365 ralloc_asprintf_append(&buf, "api: %d glsl: %d fglsl: %d\n",
1366 ctx->API, ctx->Const.GLSLVersion,
1367 ctx->Const.ForceGLSLVersion);
1368
1369 /* We run the preprocessor on shaders after hashing them, so we need to
1370 * add any extension override vars to the hash. If we don't do this the
1371 * preprocessor could result in different output and we could load the
1372 * wrong shader.
1373 */
1374 char *ext_override = getenv("MESA_EXTENSION_OVERRIDE");
1375 if (ext_override) {
1376 ralloc_asprintf_append(&buf, "ext:%s", ext_override);
1377 }
1378
1379 /* DRI config options may also change the output from the compiler so
1380 * include them as an input to sha1 creation.
1381 */
1382 char sha1buf[41];
1383 _mesa_sha1_format(sha1buf, ctx->Const.dri_config_options_sha1);
1384 ralloc_strcat(&buf, sha1buf);
1385
1386 for (unsigned i = 0; i < prog->NumShaders; i++) {
1387 struct gl_shader *sh = prog->Shaders[i];
1388 _mesa_sha1_format(sha1buf, sh->sha1);
1389 ralloc_asprintf_append(&buf, "%s: %s\n",
1390 _mesa_shader_stage_to_abbrev(sh->Stage), sha1buf);
1391 }
1392 disk_cache_compute_key(cache, buf, strlen(buf), prog->data->sha1);
1393 ralloc_free(buf);
1394
1395 size_t size;
1396 uint8_t *buffer = (uint8_t *) disk_cache_get(cache, prog->data->sha1,
1397 &size);
1398 if (buffer == NULL) {
1399 /* Cached program not found. We may have seen the individual shaders
1400 * before and skipped compiling but they may not have been used together
1401 * in this combination before. Fall back to linking shaders but first
1402 * re-compile the shaders.
1403 *
1404 * We could probably only compile the shaders which were skipped here
1405 * but we need to be careful because the source may also have been
1406 * changed since the last compile so for now we just recompile
1407 * everything.
1408 */
1409 compile_shaders(ctx, prog);
1410 return false;
1411 }
1412
1413 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) {
1414 _mesa_sha1_format(sha1buf, prog->data->sha1);
1415 fprintf(stderr, "loading shader program meta data from cache: %s\n",
1416 sha1buf);
1417 }
1418
1419 struct blob_reader metadata;
1420 blob_reader_init(&metadata, buffer, size);
1421
1422 assert(prog->data->UniformStorage == NULL);
1423
1424 read_uniforms(&metadata, prog);
1425
1426 read_hash_tables(&metadata, prog);
1427
1428 prog->data->Version = blob_read_uint32(&metadata);
1429 prog->data->linked_stages = blob_read_uint32(&metadata);
1430
1431 unsigned mask = prog->data->linked_stages;
1432 while (mask) {
1433 const int j = u_bit_scan(&mask);
1434 create_linked_shader_and_program(ctx, (gl_shader_stage) j, prog,
1435 &metadata);
1436 }
1437
1438 read_xfb(&metadata, prog);
1439
1440 read_uniform_remap_tables(&metadata, prog);
1441
1442 read_atomic_buffers(&metadata, prog);
1443
1444 read_buffer_blocks(&metadata, prog);
1445
1446 read_subroutines(&metadata, prog);
1447
1448 read_program_resource_list(&metadata, prog);
1449
1450 if (metadata.current != metadata.end || metadata.overrun) {
1451 /* Something has gone wrong discard the item from the cache and rebuild
1452 * from source.
1453 */
1454 assert(!"Invalid GLSL shader disk cache item!");
1455
1456 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) {
1457 fprintf(stderr, "Error reading program from cache (invalid GLSL "
1458 "cache item)\n");
1459 }
1460
1461 disk_cache_remove(cache, prog->data->sha1);
1462 compile_shaders(ctx, prog);
1463 free(buffer);
1464 return false;
1465 }
1466
1467 /* This is used to flag a shader retrieved from cache */
1468 prog->data->LinkStatus = linking_skipped;
1469
1470 /* Since the program load was successful, CompileStatus of all shaders at
1471 * this point should normally be compile_skipped. However because of how
1472 * the eviction works, it may happen that some of the individual shader keys
1473 * have been evicted, resulting in unnecessary recompiles on this load, so
1474 * mark them again to skip such recompiles next time.
1475 */
1476 char sha1_buf[41];
1477 for (unsigned i = 0; i < prog->NumShaders; i++) {
1478 if (prog->Shaders[i]->CompileStatus == compiled_no_opts) {
1479 disk_cache_put_key(cache, prog->Shaders[i]->sha1);
1480 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) {
1481 _mesa_sha1_format(sha1_buf, prog->Shaders[i]->sha1);
1482 fprintf(stderr, "re-marking shader: %s\n", sha1_buf);
1483 }
1484 }
1485 }
1486
1487 free (buffer);
1488
1489 return true;
1490 }