2 * Copyright © 2014 Intel Corporation
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:
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
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.
29 * Supports serializing and deserializing glsl programs using a blob.
32 #include "compiler/glsl_types.h"
33 #include "compiler/shader_info.h"
34 #include "ir_uniform.h"
35 #include "main/mtypes.h"
36 #include "main/shaderobj.h"
37 #include "program/program.h"
38 #include "string_to_uint_map.h"
39 #include "util/bitscan.h"
43 write_subroutines(struct blob
*metadata
, struct gl_shader_program
*prog
)
45 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
46 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
50 struct gl_program
*glprog
= sh
->Program
;
52 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniforms
);
53 blob_write_uint32(metadata
, glprog
->sh
.MaxSubroutineFunctionIndex
);
54 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineFunctions
);
55 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
56 int num_types
= glprog
->sh
.SubroutineFunctions
[j
].num_compat_types
;
58 blob_write_string(metadata
, glprog
->sh
.SubroutineFunctions
[j
].name
);
59 blob_write_uint32(metadata
, glprog
->sh
.SubroutineFunctions
[j
].index
);
60 blob_write_uint32(metadata
, num_types
);
62 for (int k
= 0; k
< num_types
; k
++) {
63 encode_type_to_blob(metadata
,
64 glprog
->sh
.SubroutineFunctions
[j
].types
[k
]);
71 read_subroutines(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
73 struct gl_subroutine_function
*subs
;
75 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
76 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
80 struct gl_program
*glprog
= sh
->Program
;
82 glprog
->sh
.NumSubroutineUniforms
= blob_read_uint32(metadata
);
83 glprog
->sh
.MaxSubroutineFunctionIndex
= blob_read_uint32(metadata
);
84 glprog
->sh
.NumSubroutineFunctions
= blob_read_uint32(metadata
);
86 subs
= rzalloc_array(prog
, struct gl_subroutine_function
,
87 glprog
->sh
.NumSubroutineFunctions
);
88 glprog
->sh
.SubroutineFunctions
= subs
;
90 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
91 subs
[j
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
92 subs
[j
].index
= (int) blob_read_uint32(metadata
);
93 subs
[j
].num_compat_types
= (int) blob_read_uint32(metadata
);
95 subs
[j
].types
= rzalloc_array(prog
, const struct glsl_type
*,
96 subs
[j
].num_compat_types
);
97 for (int k
= 0; k
< subs
[j
].num_compat_types
; k
++) {
98 subs
[j
].types
[k
] = decode_type_from_blob(metadata
);
105 write_buffer_block(struct blob
*metadata
, struct gl_uniform_block
*b
)
107 blob_write_string(metadata
, b
->Name
);
108 blob_write_uint32(metadata
, b
->NumUniforms
);
109 blob_write_uint32(metadata
, b
->Binding
);
110 blob_write_uint32(metadata
, b
->UniformBufferSize
);
111 blob_write_uint32(metadata
, b
->stageref
);
113 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
114 blob_write_string(metadata
, b
->Uniforms
[j
].Name
);
115 blob_write_string(metadata
, b
->Uniforms
[j
].IndexName
);
116 encode_type_to_blob(metadata
, b
->Uniforms
[j
].Type
);
117 blob_write_uint32(metadata
, b
->Uniforms
[j
].Offset
);
122 write_buffer_blocks(struct blob
*metadata
, struct gl_shader_program
*prog
)
124 blob_write_uint32(metadata
, prog
->data
->NumUniformBlocks
);
125 blob_write_uint32(metadata
, prog
->data
->NumShaderStorageBlocks
);
127 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
128 write_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
]);
131 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
132 write_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
]);
135 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
136 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
140 struct gl_program
*glprog
= sh
->Program
;
142 blob_write_uint32(metadata
, glprog
->info
.num_ubos
);
143 blob_write_uint32(metadata
, glprog
->info
.num_ssbos
);
145 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
147 glprog
->sh
.UniformBlocks
[j
] - prog
->data
->UniformBlocks
;
148 blob_write_uint32(metadata
, offset
);
151 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
152 uint32_t offset
= glprog
->sh
.ShaderStorageBlocks
[j
] -
153 prog
->data
->ShaderStorageBlocks
;
154 blob_write_uint32(metadata
, offset
);
160 read_buffer_block(struct blob_reader
*metadata
, struct gl_uniform_block
*b
,
161 struct gl_shader_program
*prog
)
163 b
->Name
= ralloc_strdup(prog
->data
, blob_read_string (metadata
));
164 b
->NumUniforms
= blob_read_uint32(metadata
);
165 b
->Binding
= blob_read_uint32(metadata
);
166 b
->UniformBufferSize
= blob_read_uint32(metadata
);
167 b
->stageref
= blob_read_uint32(metadata
);
170 rzalloc_array(prog
->data
, struct gl_uniform_buffer_variable
,
172 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
173 b
->Uniforms
[j
].Name
= ralloc_strdup(prog
->data
,
174 blob_read_string (metadata
));
176 char *index_name
= blob_read_string(metadata
);
177 if (strcmp(b
->Uniforms
[j
].Name
, index_name
) == 0) {
178 b
->Uniforms
[j
].IndexName
= b
->Uniforms
[j
].Name
;
180 b
->Uniforms
[j
].IndexName
= ralloc_strdup(prog
->data
, index_name
);
183 b
->Uniforms
[j
].Type
= decode_type_from_blob(metadata
);
184 b
->Uniforms
[j
].Offset
= blob_read_uint32(metadata
);
189 read_buffer_blocks(struct blob_reader
*metadata
,
190 struct gl_shader_program
*prog
)
192 prog
->data
->NumUniformBlocks
= blob_read_uint32(metadata
);
193 prog
->data
->NumShaderStorageBlocks
= blob_read_uint32(metadata
);
195 prog
->data
->UniformBlocks
=
196 rzalloc_array(prog
->data
, struct gl_uniform_block
,
197 prog
->data
->NumUniformBlocks
);
199 prog
->data
->ShaderStorageBlocks
=
200 rzalloc_array(prog
->data
, struct gl_uniform_block
,
201 prog
->data
->NumShaderStorageBlocks
);
203 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
204 read_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
], prog
);
207 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
208 read_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
], prog
);
211 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
212 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
216 struct gl_program
*glprog
= sh
->Program
;
218 glprog
->info
.num_ubos
= blob_read_uint32(metadata
);
219 glprog
->info
.num_ssbos
= blob_read_uint32(metadata
);
221 glprog
->sh
.UniformBlocks
=
222 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ubos
);
223 glprog
->sh
.ShaderStorageBlocks
=
224 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ssbos
);
226 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
227 uint32_t offset
= blob_read_uint32(metadata
);
228 glprog
->sh
.UniformBlocks
[j
] = prog
->data
->UniformBlocks
+ offset
;
231 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
232 uint32_t offset
= blob_read_uint32(metadata
);
233 glprog
->sh
.ShaderStorageBlocks
[j
] =
234 prog
->data
->ShaderStorageBlocks
+ offset
;
240 write_atomic_buffers(struct blob
*metadata
, struct gl_shader_program
*prog
)
242 blob_write_uint32(metadata
, prog
->data
->NumAtomicBuffers
);
244 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
245 if (prog
->_LinkedShaders
[i
]) {
246 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
247 blob_write_uint32(metadata
, glprog
->info
.num_abos
);
251 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
252 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Binding
);
253 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].MinimumSize
);
254 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].NumUniforms
);
256 blob_write_bytes(metadata
, prog
->data
->AtomicBuffers
[i
].StageReferences
,
257 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
259 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
260 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Uniforms
[j
]);
266 read_atomic_buffers(struct blob_reader
*metadata
,
267 struct gl_shader_program
*prog
)
269 prog
->data
->NumAtomicBuffers
= blob_read_uint32(metadata
);
270 prog
->data
->AtomicBuffers
=
271 rzalloc_array(prog
, gl_active_atomic_buffer
,
272 prog
->data
->NumAtomicBuffers
);
274 struct gl_active_atomic_buffer
**stage_buff_list
[MESA_SHADER_STAGES
];
275 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
276 if (prog
->_LinkedShaders
[i
]) {
277 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
279 glprog
->info
.num_abos
= blob_read_uint32(metadata
);
280 glprog
->sh
.AtomicBuffers
=
281 rzalloc_array(glprog
, gl_active_atomic_buffer
*,
282 glprog
->info
.num_abos
);
283 stage_buff_list
[i
] = glprog
->sh
.AtomicBuffers
;
287 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
288 prog
->data
->AtomicBuffers
[i
].Binding
= blob_read_uint32(metadata
);
289 prog
->data
->AtomicBuffers
[i
].MinimumSize
= blob_read_uint32(metadata
);
290 prog
->data
->AtomicBuffers
[i
].NumUniforms
= blob_read_uint32(metadata
);
292 blob_copy_bytes(metadata
,
293 (uint8_t *) &prog
->data
->AtomicBuffers
[i
].StageReferences
,
294 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
296 prog
->data
->AtomicBuffers
[i
].Uniforms
= rzalloc_array(prog
, unsigned,
297 prog
->data
->AtomicBuffers
[i
].NumUniforms
);
299 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
300 prog
->data
->AtomicBuffers
[i
].Uniforms
[j
] = blob_read_uint32(metadata
);
303 for (unsigned j
= 0; j
< MESA_SHADER_STAGES
; j
++) {
304 if (prog
->data
->AtomicBuffers
[i
].StageReferences
[j
]) {
305 *stage_buff_list
[j
] = &prog
->data
->AtomicBuffers
[i
];
306 stage_buff_list
[j
]++;
313 write_xfb(struct blob
*metadata
, struct gl_shader_program
*shProg
)
315 struct gl_program
*prog
= shProg
->last_vert_prog
;
318 blob_write_uint32(metadata
, ~0u);
322 struct gl_transform_feedback_info
*ltf
= prog
->sh
.LinkedTransformFeedback
;
324 blob_write_uint32(metadata
, prog
->info
.stage
);
326 /* Data set by glTransformFeedbackVaryings. */
327 blob_write_uint32(metadata
, shProg
->TransformFeedback
.BufferMode
);
328 blob_write_bytes(metadata
, shProg
->TransformFeedback
.BufferStride
,
329 sizeof(shProg
->TransformFeedback
.BufferStride
));
330 blob_write_uint32(metadata
, shProg
->TransformFeedback
.NumVarying
);
331 for (unsigned i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++)
332 blob_write_string(metadata
, shProg
->TransformFeedback
.VaryingNames
[i
]);
334 blob_write_uint32(metadata
, ltf
->NumOutputs
);
335 blob_write_uint32(metadata
, ltf
->ActiveBuffers
);
336 blob_write_uint32(metadata
, ltf
->NumVarying
);
338 blob_write_bytes(metadata
, ltf
->Outputs
,
339 sizeof(struct gl_transform_feedback_output
) *
342 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
343 blob_write_string(metadata
, ltf
->Varyings
[i
].Name
);
344 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Type
);
345 blob_write_uint32(metadata
, ltf
->Varyings
[i
].BufferIndex
);
346 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Size
);
347 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Offset
);
350 blob_write_bytes(metadata
, ltf
->Buffers
,
351 sizeof(struct gl_transform_feedback_buffer
) *
352 MAX_FEEDBACK_BUFFERS
);
356 read_xfb(struct blob_reader
*metadata
, struct gl_shader_program
*shProg
)
358 unsigned xfb_stage
= blob_read_uint32(metadata
);
360 if (xfb_stage
== ~0u)
363 /* Data set by glTransformFeedbackVaryings. */
364 shProg
->TransformFeedback
.BufferMode
= blob_read_uint32(metadata
);
365 blob_copy_bytes(metadata
, &shProg
->TransformFeedback
.BufferStride
,
366 sizeof(shProg
->TransformFeedback
.BufferStride
));
367 shProg
->TransformFeedback
.NumVarying
= blob_read_uint32(metadata
);
368 shProg
->TransformFeedback
.VaryingNames
= (char **)
369 malloc(shProg
->TransformFeedback
.NumVarying
* sizeof(GLchar
*));
370 /* Note, malloc used with VaryingNames. */
371 for (unsigned i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++)
372 shProg
->TransformFeedback
.VaryingNames
[i
] =
373 strdup(blob_read_string(metadata
));
375 struct gl_program
*prog
= shProg
->_LinkedShaders
[xfb_stage
]->Program
;
376 struct gl_transform_feedback_info
*ltf
=
377 rzalloc(prog
, struct gl_transform_feedback_info
);
379 prog
->sh
.LinkedTransformFeedback
= ltf
;
380 shProg
->last_vert_prog
= prog
;
382 ltf
->NumOutputs
= blob_read_uint32(metadata
);
383 ltf
->ActiveBuffers
= blob_read_uint32(metadata
);
384 ltf
->NumVarying
= blob_read_uint32(metadata
);
386 ltf
->Outputs
= rzalloc_array(prog
, struct gl_transform_feedback_output
,
389 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Outputs
,
390 sizeof(struct gl_transform_feedback_output
) *
393 ltf
->Varyings
= rzalloc_array(prog
,
394 struct gl_transform_feedback_varying_info
,
397 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
398 ltf
->Varyings
[i
].Name
= ralloc_strdup(prog
, blob_read_string(metadata
));
399 ltf
->Varyings
[i
].Type
= blob_read_uint32(metadata
);
400 ltf
->Varyings
[i
].BufferIndex
= blob_read_uint32(metadata
);
401 ltf
->Varyings
[i
].Size
= blob_read_uint32(metadata
);
402 ltf
->Varyings
[i
].Offset
= blob_read_uint32(metadata
);
405 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Buffers
,
406 sizeof(struct gl_transform_feedback_buffer
) *
407 MAX_FEEDBACK_BUFFERS
);
411 has_uniform_storage(struct gl_shader_program
*prog
, unsigned idx
)
413 if (!prog
->data
->UniformStorage
[idx
].builtin
&&
414 !prog
->data
->UniformStorage
[idx
].is_shader_storage
&&
415 prog
->data
->UniformStorage
[idx
].block_index
== -1)
422 write_uniforms(struct blob
*metadata
, struct gl_shader_program
*prog
)
424 blob_write_uint32(metadata
, prog
->SamplersValidated
);
425 blob_write_uint32(metadata
, prog
->data
->NumUniformStorage
);
426 blob_write_uint32(metadata
, prog
->data
->NumUniformDataSlots
);
428 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
429 encode_type_to_blob(metadata
, prog
->data
->UniformStorage
[i
].type
);
430 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_elements
);
431 blob_write_string(metadata
, prog
->data
->UniformStorage
[i
].name
);
432 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].builtin
);
433 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].remap_location
);
434 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].block_index
);
435 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].atomic_buffer_index
);
436 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].offset
);
437 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_stride
);
438 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].hidden
);
439 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_shader_storage
);
440 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].active_shader_mask
);
441 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].matrix_stride
);
442 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].row_major
);
443 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_bindless
);
444 blob_write_uint32(metadata
,
445 prog
->data
->UniformStorage
[i
].num_compatible_subroutines
);
446 blob_write_uint32(metadata
,
447 prog
->data
->UniformStorage
[i
].top_level_array_size
);
448 blob_write_uint32(metadata
,
449 prog
->data
->UniformStorage
[i
].top_level_array_stride
);
451 if (has_uniform_storage(prog
, i
)) {
452 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].storage
-
453 prog
->data
->UniformDataSlots
);
456 blob_write_bytes(metadata
, prog
->data
->UniformStorage
[i
].opaque
,
457 sizeof(prog
->data
->UniformStorage
[i
].opaque
));
460 /* Here we cache all uniform values. We do this to retain values for
461 * uniforms with initialisers and also hidden uniforms that may be lowered
462 * constant arrays. We could possibly just store the values we need but for
463 * now we just store everything.
465 blob_write_uint32(metadata
, prog
->data
->NumHiddenUniforms
);
466 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
467 if (has_uniform_storage(prog
, i
)) {
469 prog
->data
->UniformStorage
[i
].type
->component_slots() *
470 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
472 prog
->data
->UniformStorage
[i
].storage
-
473 prog
->data
->UniformDataSlots
;
474 blob_write_bytes(metadata
, &prog
->data
->UniformDataDefaults
[slot
],
475 sizeof(union gl_constant_value
) * vec_size
);
481 read_uniforms(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
483 struct gl_uniform_storage
*uniforms
;
484 union gl_constant_value
*data
;
486 prog
->SamplersValidated
= blob_read_uint32(metadata
);
487 prog
->data
->NumUniformStorage
= blob_read_uint32(metadata
);
488 prog
->data
->NumUniformDataSlots
= blob_read_uint32(metadata
);
490 uniforms
= rzalloc_array(prog
->data
, struct gl_uniform_storage
,
491 prog
->data
->NumUniformStorage
);
492 prog
->data
->UniformStorage
= uniforms
;
494 data
= rzalloc_array(uniforms
, union gl_constant_value
,
495 prog
->data
->NumUniformDataSlots
);
496 prog
->data
->UniformDataSlots
= data
;
497 prog
->data
->UniformDataDefaults
=
498 rzalloc_array(uniforms
, union gl_constant_value
,
499 prog
->data
->NumUniformDataSlots
);
501 prog
->UniformHash
= new string_to_uint_map
;
503 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
504 uniforms
[i
].type
= decode_type_from_blob(metadata
);
505 uniforms
[i
].array_elements
= blob_read_uint32(metadata
);
506 uniforms
[i
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
507 uniforms
[i
].builtin
= blob_read_uint32(metadata
);
508 uniforms
[i
].remap_location
= blob_read_uint32(metadata
);
509 uniforms
[i
].block_index
= blob_read_uint32(metadata
);
510 uniforms
[i
].atomic_buffer_index
= blob_read_uint32(metadata
);
511 uniforms
[i
].offset
= blob_read_uint32(metadata
);
512 uniforms
[i
].array_stride
= blob_read_uint32(metadata
);
513 uniforms
[i
].hidden
= blob_read_uint32(metadata
);
514 uniforms
[i
].is_shader_storage
= blob_read_uint32(metadata
);
515 uniforms
[i
].active_shader_mask
= blob_read_uint32(metadata
);
516 uniforms
[i
].matrix_stride
= blob_read_uint32(metadata
);
517 uniforms
[i
].row_major
= blob_read_uint32(metadata
);
518 uniforms
[i
].is_bindless
= blob_read_uint32(metadata
);
519 uniforms
[i
].num_compatible_subroutines
= blob_read_uint32(metadata
);
520 uniforms
[i
].top_level_array_size
= blob_read_uint32(metadata
);
521 uniforms
[i
].top_level_array_stride
= blob_read_uint32(metadata
);
522 prog
->UniformHash
->put(i
, uniforms
[i
].name
);
524 if (has_uniform_storage(prog
, i
)) {
525 uniforms
[i
].storage
= data
+ blob_read_uint32(metadata
);
528 memcpy(uniforms
[i
].opaque
,
529 blob_read_bytes(metadata
, sizeof(uniforms
[i
].opaque
)),
530 sizeof(uniforms
[i
].opaque
));
533 /* Restore uniform values. */
534 prog
->data
->NumHiddenUniforms
= blob_read_uint32(metadata
);
535 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
536 if (has_uniform_storage(prog
, i
)) {
538 prog
->data
->UniformStorage
[i
].type
->component_slots() *
539 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
541 prog
->data
->UniformStorage
[i
].storage
-
542 prog
->data
->UniformDataSlots
;
543 blob_copy_bytes(metadata
,
544 (uint8_t *) &prog
->data
->UniformDataSlots
[slot
],
545 sizeof(union gl_constant_value
) * vec_size
);
547 assert(vec_size
+ prog
->data
->UniformStorage
[i
].storage
<=
548 data
+ prog
->data
->NumUniformDataSlots
);
552 memcpy(prog
->data
->UniformDataDefaults
, prog
->data
->UniformDataSlots
,
553 sizeof(union gl_constant_value
) * prog
->data
->NumUniformDataSlots
);
556 enum uniform_remap_type
558 remap_type_inactive_explicit_location
,
560 remap_type_uniform_offset
564 write_uniform_remap_table_entry(struct blob
*metadata
,
565 gl_uniform_storage
*uniform_storage
,
566 gl_uniform_storage
*entry
)
568 if (entry
== INACTIVE_UNIFORM_EXPLICIT_LOCATION
) {
569 blob_write_uint32(metadata
, remap_type_inactive_explicit_location
);
570 } else if (entry
== NULL
) {
571 blob_write_uint32(metadata
, remap_type_null_ptr
);
573 blob_write_uint32(metadata
, remap_type_uniform_offset
);
575 uint32_t offset
= entry
- uniform_storage
;
576 blob_write_uint32(metadata
, offset
);
581 write_uniform_remap_tables(struct blob
*metadata
,
582 struct gl_shader_program
*prog
)
584 blob_write_uint32(metadata
, prog
->NumUniformRemapTable
);
586 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
587 write_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
588 prog
->UniformRemapTable
[i
]);
591 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
592 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
594 struct gl_program
*glprog
= sh
->Program
;
595 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniformRemapTable
);
597 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
598 write_uniform_remap_table_entry(metadata
,
599 prog
->data
->UniformStorage
,
600 glprog
->sh
.SubroutineUniformRemapTable
[j
]);
607 read_uniform_remap_table_entry(struct blob_reader
*metadata
,
608 gl_uniform_storage
*uniform_storage
,
609 gl_uniform_storage
**entry
,
610 enum uniform_remap_type type
)
612 if (type
== remap_type_inactive_explicit_location
) {
613 *entry
= INACTIVE_UNIFORM_EXPLICIT_LOCATION
;
614 } else if (type
== remap_type_null_ptr
) {
617 uint32_t uni_offset
= blob_read_uint32(metadata
);
618 *entry
= uniform_storage
+ uni_offset
;
623 read_uniform_remap_tables(struct blob_reader
*metadata
,
624 struct gl_shader_program
*prog
)
626 prog
->NumUniformRemapTable
= blob_read_uint32(metadata
);
628 prog
->UniformRemapTable
= rzalloc_array(prog
, struct gl_uniform_storage
*,
629 prog
->NumUniformRemapTable
);
631 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
632 enum uniform_remap_type type
=
633 (enum uniform_remap_type
) blob_read_uint32(metadata
);
635 read_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
636 &prog
->UniformRemapTable
[i
], type
);
639 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
640 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
642 struct gl_program
*glprog
= sh
->Program
;
643 glprog
->sh
.NumSubroutineUniformRemapTable
= blob_read_uint32(metadata
);
645 glprog
->sh
.SubroutineUniformRemapTable
=
646 rzalloc_array(glprog
, struct gl_uniform_storage
*,
647 glprog
->sh
.NumSubroutineUniformRemapTable
);
649 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
650 enum uniform_remap_type type
=
651 (enum uniform_remap_type
) blob_read_uint32(metadata
);
653 read_uniform_remap_table_entry(metadata
,
654 prog
->data
->UniformStorage
,
655 &glprog
->sh
.SubroutineUniformRemapTable
[j
],
669 write_hash_table_entry(const char *key
, unsigned value
, void *closure
)
671 struct whte_closure
*whte
= (struct whte_closure
*) closure
;
673 blob_write_string(whte
->blob
, key
);
674 blob_write_uint32(whte
->blob
, value
);
680 write_hash_table(struct blob
*metadata
, struct string_to_uint_map
*hash
)
683 struct whte_closure whte
;
685 whte
.blob
= metadata
;
686 whte
.num_entries
= 0;
688 offset
= metadata
->size
;
690 /* Write a placeholder for the hashtable size. */
691 blob_write_uint32 (metadata
, 0);
693 hash
->iterate(write_hash_table_entry
, &whte
);
695 /* Overwrite with the computed number of entries written. */
696 blob_overwrite_uint32 (metadata
, offset
, whte
.num_entries
);
700 read_hash_table(struct blob_reader
*metadata
, struct string_to_uint_map
*hash
)
702 size_t i
, num_entries
;
706 num_entries
= blob_read_uint32 (metadata
);
708 for (i
= 0; i
< num_entries
; i
++) {
709 key
= blob_read_string(metadata
);
710 value
= blob_read_uint32(metadata
);
712 hash
->put(value
, key
);
717 write_hash_tables(struct blob
*metadata
, struct gl_shader_program
*prog
)
719 write_hash_table(metadata
, prog
->AttributeBindings
);
720 write_hash_table(metadata
, prog
->FragDataBindings
);
721 write_hash_table(metadata
, prog
->FragDataIndexBindings
);
725 read_hash_tables(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
727 read_hash_table(metadata
, prog
->AttributeBindings
);
728 read_hash_table(metadata
, prog
->FragDataBindings
);
729 read_hash_table(metadata
, prog
->FragDataIndexBindings
);
733 write_shader_subroutine_index(struct blob
*metadata
,
734 struct gl_linked_shader
*sh
,
735 struct gl_program_resource
*res
)
739 for (unsigned j
= 0; j
< sh
->Program
->sh
.NumSubroutineFunctions
; j
++) {
740 if (strcmp(((gl_subroutine_function
*)res
->Data
)->name
,
741 sh
->Program
->sh
.SubroutineFunctions
[j
].name
) == 0) {
742 blob_write_uint32(metadata
, j
);
749 get_shader_var_and_pointer_sizes(size_t *s_var_size
, size_t *s_var_ptrs
,
750 const gl_shader_variable
*var
)
752 *s_var_size
= sizeof(gl_shader_variable
);
755 sizeof(var
->interface_type
) +
756 sizeof(var
->outermost_struct_type
) +
761 write_program_resource_data(struct blob
*metadata
,
762 struct gl_shader_program
*prog
,
763 struct gl_program_resource
*res
)
765 struct gl_linked_shader
*sh
;
768 case GL_PROGRAM_INPUT
:
769 case GL_PROGRAM_OUTPUT
: {
770 const gl_shader_variable
*var
= (gl_shader_variable
*)res
->Data
;
772 encode_type_to_blob(metadata
, var
->type
);
773 encode_type_to_blob(metadata
, var
->interface_type
);
774 encode_type_to_blob(metadata
, var
->outermost_struct_type
);
776 blob_write_string(metadata
, var
->name
);
778 size_t s_var_size
, s_var_ptrs
;
779 get_shader_var_and_pointer_sizes(&s_var_size
, &s_var_ptrs
, var
);
781 /* Write gl_shader_variable skipping over the pointers */
782 blob_write_bytes(metadata
, ((char *)var
) + s_var_ptrs
,
783 s_var_size
- s_var_ptrs
);
786 case GL_UNIFORM_BLOCK
:
787 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
788 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
789 prog
->data
->UniformBlocks
[i
].Name
) == 0) {
790 blob_write_uint32(metadata
, i
);
795 case GL_SHADER_STORAGE_BLOCK
:
796 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
797 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
798 prog
->data
->ShaderStorageBlocks
[i
].Name
) == 0) {
799 blob_write_uint32(metadata
, i
);
804 case GL_BUFFER_VARIABLE
:
805 case GL_VERTEX_SUBROUTINE_UNIFORM
:
806 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
807 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
808 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
809 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
810 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
812 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
813 if (strcmp(((gl_uniform_storage
*)res
->Data
)->name
,
814 prog
->data
->UniformStorage
[i
].name
) == 0) {
815 blob_write_uint32(metadata
, i
);
820 case GL_ATOMIC_COUNTER_BUFFER
:
821 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
822 if (((gl_active_atomic_buffer
*)res
->Data
)->Binding
==
823 prog
->data
->AtomicBuffers
[i
].Binding
) {
824 blob_write_uint32(metadata
, i
);
829 case GL_TRANSFORM_FEEDBACK_BUFFER
:
830 for (unsigned i
= 0; i
< MAX_FEEDBACK_BUFFERS
; i
++) {
831 if (((gl_transform_feedback_buffer
*)res
->Data
)->Binding
==
832 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Buffers
[i
].Binding
) {
833 blob_write_uint32(metadata
, i
);
838 case GL_TRANSFORM_FEEDBACK_VARYING
:
839 for (int i
= 0; i
< prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
; i
++) {
840 if (strcmp(((gl_transform_feedback_varying_info
*)res
->Data
)->Name
,
841 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Varyings
[i
].Name
) == 0) {
842 blob_write_uint32(metadata
, i
);
847 case GL_VERTEX_SUBROUTINE
:
848 case GL_TESS_CONTROL_SUBROUTINE
:
849 case GL_TESS_EVALUATION_SUBROUTINE
:
850 case GL_GEOMETRY_SUBROUTINE
:
851 case GL_FRAGMENT_SUBROUTINE
:
852 case GL_COMPUTE_SUBROUTINE
:
854 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
855 write_shader_subroutine_index(metadata
, sh
, res
);
858 assert(!"Support for writing resource not yet implemented.");
863 read_program_resource_data(struct blob_reader
*metadata
,
864 struct gl_shader_program
*prog
,
865 struct gl_program_resource
*res
)
867 struct gl_linked_shader
*sh
;
870 case GL_PROGRAM_INPUT
:
871 case GL_PROGRAM_OUTPUT
: {
872 gl_shader_variable
*var
= ralloc(prog
, struct gl_shader_variable
);
874 var
->type
= decode_type_from_blob(metadata
);
875 var
->interface_type
= decode_type_from_blob(metadata
);
876 var
->outermost_struct_type
= decode_type_from_blob(metadata
);
878 var
->name
= ralloc_strdup(prog
, blob_read_string(metadata
));
880 size_t s_var_size
, s_var_ptrs
;
881 get_shader_var_and_pointer_sizes(&s_var_size
, &s_var_ptrs
, var
);
883 blob_copy_bytes(metadata
, ((uint8_t *) var
) + s_var_ptrs
,
884 s_var_size
- s_var_ptrs
);
889 case GL_UNIFORM_BLOCK
:
890 res
->Data
= &prog
->data
->UniformBlocks
[blob_read_uint32(metadata
)];
892 case GL_SHADER_STORAGE_BLOCK
:
893 res
->Data
= &prog
->data
->ShaderStorageBlocks
[blob_read_uint32(metadata
)];
895 case GL_BUFFER_VARIABLE
:
896 case GL_VERTEX_SUBROUTINE_UNIFORM
:
897 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
898 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
899 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
900 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
901 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
903 res
->Data
= &prog
->data
->UniformStorage
[blob_read_uint32(metadata
)];
905 case GL_ATOMIC_COUNTER_BUFFER
:
906 res
->Data
= &prog
->data
->AtomicBuffers
[blob_read_uint32(metadata
)];
908 case GL_TRANSFORM_FEEDBACK_BUFFER
:
909 res
->Data
= &prog
->last_vert_prog
->
910 sh
.LinkedTransformFeedback
->Buffers
[blob_read_uint32(metadata
)];
912 case GL_TRANSFORM_FEEDBACK_VARYING
:
913 res
->Data
= &prog
->last_vert_prog
->
914 sh
.LinkedTransformFeedback
->Varyings
[blob_read_uint32(metadata
)];
916 case GL_VERTEX_SUBROUTINE
:
917 case GL_TESS_CONTROL_SUBROUTINE
:
918 case GL_TESS_EVALUATION_SUBROUTINE
:
919 case GL_GEOMETRY_SUBROUTINE
:
920 case GL_FRAGMENT_SUBROUTINE
:
921 case GL_COMPUTE_SUBROUTINE
:
923 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
925 &sh
->Program
->sh
.SubroutineFunctions
[blob_read_uint32(metadata
)];
928 assert(!"Support for reading resource not yet implemented.");
933 write_program_resource_list(struct blob
*metadata
,
934 struct gl_shader_program
*prog
)
936 blob_write_uint32(metadata
, prog
->data
->NumProgramResourceList
);
938 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
939 blob_write_uint32(metadata
, prog
->data
->ProgramResourceList
[i
].Type
);
940 write_program_resource_data(metadata
, prog
,
941 &prog
->data
->ProgramResourceList
[i
]);
942 blob_write_bytes(metadata
,
943 &prog
->data
->ProgramResourceList
[i
].StageReferences
,
944 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
949 read_program_resource_list(struct blob_reader
*metadata
,
950 struct gl_shader_program
*prog
)
952 prog
->data
->NumProgramResourceList
= blob_read_uint32(metadata
);
954 prog
->data
->ProgramResourceList
=
955 ralloc_array(prog
->data
, gl_program_resource
,
956 prog
->data
->NumProgramResourceList
);
958 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
959 prog
->data
->ProgramResourceList
[i
].Type
= blob_read_uint32(metadata
);
960 read_program_resource_data(metadata
, prog
,
961 &prog
->data
->ProgramResourceList
[i
]);
962 blob_copy_bytes(metadata
,
963 (uint8_t *) &prog
->data
->ProgramResourceList
[i
].StageReferences
,
964 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
969 write_shader_parameters(struct blob
*metadata
,
970 struct gl_program_parameter_list
*params
)
972 blob_write_uint32(metadata
, params
->NumParameters
);
973 blob_write_uint32(metadata
, params
->NumParameterValues
);
976 while (i
< params
->NumParameters
) {
977 struct gl_program_parameter
*param
= ¶ms
->Parameters
[i
];
979 blob_write_uint32(metadata
, param
->Type
);
980 blob_write_string(metadata
, param
->Name
);
981 blob_write_uint32(metadata
, param
->Size
);
982 blob_write_uint32(metadata
, param
->DataType
);
983 blob_write_bytes(metadata
, param
->StateIndexes
,
984 sizeof(param
->StateIndexes
));
989 blob_write_bytes(metadata
, params
->ParameterValues
,
990 sizeof(gl_constant_value
) * params
->NumParameterValues
);
992 blob_write_bytes(metadata
, params
->ParameterValueOffset
,
993 sizeof(uint32_t) * params
->NumParameters
);
995 blob_write_uint32(metadata
, params
->StateFlags
);
999 read_shader_parameters(struct blob_reader
*metadata
,
1000 struct gl_program_parameter_list
*params
)
1002 gl_state_index16 state_indexes
[STATE_LENGTH
];
1004 uint32_t num_parameters
= blob_read_uint32(metadata
);
1005 uint32_t num_parameters_values
= blob_read_uint32(metadata
);
1007 _mesa_reserve_parameter_storage(params
, num_parameters
);
1008 while (i
< num_parameters
) {
1009 gl_register_file type
= (gl_register_file
) blob_read_uint32(metadata
);
1010 const char *name
= blob_read_string(metadata
);
1011 unsigned size
= blob_read_uint32(metadata
);
1012 unsigned data_type
= blob_read_uint32(metadata
);
1013 blob_copy_bytes(metadata
, (uint8_t *) state_indexes
,
1014 sizeof(state_indexes
));
1016 _mesa_add_parameter(params
, type
, name
, size
, data_type
,
1017 NULL
, state_indexes
, false);
1022 blob_copy_bytes(metadata
, (uint8_t *) params
->ParameterValues
,
1023 sizeof(gl_constant_value
) * num_parameters_values
);
1025 blob_copy_bytes(metadata
, (uint8_t *) params
->ParameterValueOffset
,
1026 sizeof(uint32_t) * num_parameters
);
1028 params
->StateFlags
= blob_read_uint32(metadata
);
1032 write_shader_metadata(struct blob
*metadata
, gl_linked_shader
*shader
)
1034 assert(shader
->Program
);
1035 struct gl_program
*glprog
= shader
->Program
;
1038 blob_write_uint64(metadata
, glprog
->DualSlotInputs
);
1039 blob_write_bytes(metadata
, glprog
->TexturesUsed
,
1040 sizeof(glprog
->TexturesUsed
));
1041 blob_write_uint64(metadata
, glprog
->SamplersUsed
);
1043 blob_write_bytes(metadata
, glprog
->SamplerUnits
,
1044 sizeof(glprog
->SamplerUnits
));
1045 blob_write_bytes(metadata
, glprog
->sh
.SamplerTargets
,
1046 sizeof(glprog
->sh
.SamplerTargets
));
1047 blob_write_uint32(metadata
, glprog
->ShadowSamplers
);
1048 blob_write_uint32(metadata
, glprog
->ExternalSamplersUsed
);
1050 blob_write_bytes(metadata
, glprog
->sh
.ImageAccess
,
1051 sizeof(glprog
->sh
.ImageAccess
));
1052 blob_write_bytes(metadata
, glprog
->sh
.ImageUnits
,
1053 sizeof(glprog
->sh
.ImageUnits
));
1055 size_t ptr_size
= sizeof(GLvoid
*);
1057 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessSamplers
);
1058 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessSampler
);
1059 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1060 blob_write_bytes(metadata
, &glprog
->sh
.BindlessSamplers
[i
],
1061 sizeof(struct gl_bindless_sampler
) - ptr_size
);
1064 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessImages
);
1065 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessImage
);
1066 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1067 blob_write_bytes(metadata
, &glprog
->sh
.BindlessImages
[i
],
1068 sizeof(struct gl_bindless_image
) - ptr_size
);
1071 blob_write_bytes(metadata
, &glprog
->sh
.fs
.BlendSupport
,
1072 sizeof(glprog
->sh
.fs
.BlendSupport
));
1074 write_shader_parameters(metadata
, glprog
->Parameters
);
1076 assert((glprog
->driver_cache_blob
== NULL
) ==
1077 (glprog
->driver_cache_blob_size
== 0));
1078 blob_write_uint32(metadata
, (uint32_t)glprog
->driver_cache_blob_size
);
1079 if (glprog
->driver_cache_blob_size
> 0) {
1080 blob_write_bytes(metadata
, glprog
->driver_cache_blob
,
1081 glprog
->driver_cache_blob_size
);
1086 read_shader_metadata(struct blob_reader
*metadata
,
1087 struct gl_program
*glprog
,
1088 gl_linked_shader
*linked
)
1092 glprog
->DualSlotInputs
= blob_read_uint64(metadata
);
1093 blob_copy_bytes(metadata
, (uint8_t *) glprog
->TexturesUsed
,
1094 sizeof(glprog
->TexturesUsed
));
1095 glprog
->SamplersUsed
= blob_read_uint64(metadata
);
1097 blob_copy_bytes(metadata
, (uint8_t *) glprog
->SamplerUnits
,
1098 sizeof(glprog
->SamplerUnits
));
1099 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.SamplerTargets
,
1100 sizeof(glprog
->sh
.SamplerTargets
));
1101 glprog
->ShadowSamplers
= blob_read_uint32(metadata
);
1102 glprog
->ExternalSamplersUsed
= blob_read_uint32(metadata
);
1104 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageAccess
,
1105 sizeof(glprog
->sh
.ImageAccess
));
1106 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageUnits
,
1107 sizeof(glprog
->sh
.ImageUnits
));
1109 size_t ptr_size
= sizeof(GLvoid
*);
1111 glprog
->sh
.NumBindlessSamplers
= blob_read_uint32(metadata
);
1112 glprog
->sh
.HasBoundBindlessSampler
= blob_read_uint32(metadata
);
1113 if (glprog
->sh
.NumBindlessSamplers
> 0) {
1114 glprog
->sh
.BindlessSamplers
=
1115 rzalloc_array(glprog
, gl_bindless_sampler
,
1116 glprog
->sh
.NumBindlessSamplers
);
1118 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1119 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessSamplers
[i
],
1120 sizeof(struct gl_bindless_sampler
) - ptr_size
);
1124 glprog
->sh
.NumBindlessImages
= blob_read_uint32(metadata
);
1125 glprog
->sh
.HasBoundBindlessImage
= blob_read_uint32(metadata
);
1126 if (glprog
->sh
.NumBindlessImages
> 0) {
1127 glprog
->sh
.BindlessImages
=
1128 rzalloc_array(glprog
, gl_bindless_image
,
1129 glprog
->sh
.NumBindlessImages
);
1131 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1132 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessImages
[i
],
1133 sizeof(struct gl_bindless_image
) - ptr_size
);
1137 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.fs
.BlendSupport
,
1138 sizeof(glprog
->sh
.fs
.BlendSupport
));
1140 glprog
->Parameters
= _mesa_new_parameter_list();
1141 read_shader_parameters(metadata
, glprog
->Parameters
);
1143 glprog
->driver_cache_blob_size
= (size_t)blob_read_uint32(metadata
);
1144 if (glprog
->driver_cache_blob_size
> 0) {
1145 glprog
->driver_cache_blob
=
1146 (uint8_t*)ralloc_size(glprog
, glprog
->driver_cache_blob_size
);
1147 blob_copy_bytes(metadata
, glprog
->driver_cache_blob
,
1148 glprog
->driver_cache_blob_size
);
1153 get_shader_info_and_pointer_sizes(size_t *s_info_size
, size_t *s_info_ptrs
,
1156 *s_info_size
= sizeof(shader_info
);
1157 *s_info_ptrs
= sizeof(info
->name
) + sizeof(info
->label
);
1161 create_linked_shader_and_program(struct gl_context
*ctx
,
1162 gl_shader_stage stage
,
1163 struct gl_shader_program
*prog
,
1164 struct blob_reader
*metadata
)
1166 struct gl_program
*glprog
;
1168 struct gl_linked_shader
*linked
= rzalloc(NULL
, struct gl_linked_shader
);
1169 linked
->Stage
= stage
;
1171 glprog
= ctx
->Driver
.NewProgram(ctx
, _mesa_shader_stage_to_program(stage
),
1173 glprog
->info
.stage
= stage
;
1174 linked
->Program
= glprog
;
1176 read_shader_metadata(metadata
, glprog
, linked
);
1178 glprog
->info
.name
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1179 glprog
->info
.label
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1181 size_t s_info_size
, s_info_ptrs
;
1182 get_shader_info_and_pointer_sizes(&s_info_size
, &s_info_ptrs
,
1185 /* Restore shader info */
1186 blob_copy_bytes(metadata
, ((uint8_t *) &glprog
->info
) + s_info_ptrs
,
1187 s_info_size
- s_info_ptrs
);
1189 _mesa_reference_shader_program_data(ctx
, &glprog
->sh
.data
, prog
->data
);
1190 _mesa_reference_program(ctx
, &linked
->Program
, glprog
);
1191 prog
->_LinkedShaders
[stage
] = linked
;
1195 serialize_glsl_program(struct blob
*blob
, struct gl_context
*ctx
,
1196 struct gl_shader_program
*prog
)
1198 blob_write_bytes(blob
, prog
->data
->sha1
, sizeof(prog
->data
->sha1
));
1200 write_uniforms(blob
, prog
);
1202 write_hash_tables(blob
, prog
);
1204 blob_write_uint32(blob
, prog
->data
->Version
);
1205 blob_write_uint32(blob
, prog
->data
->linked_stages
);
1207 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1208 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
1210 write_shader_metadata(blob
, sh
);
1212 if (sh
->Program
->info
.name
)
1213 blob_write_string(blob
, sh
->Program
->info
.name
);
1215 blob_write_string(blob
, "");
1217 if (sh
->Program
->info
.label
)
1218 blob_write_string(blob
, sh
->Program
->info
.label
);
1220 blob_write_string(blob
, "");
1222 size_t s_info_size
, s_info_ptrs
;
1223 get_shader_info_and_pointer_sizes(&s_info_size
, &s_info_ptrs
,
1224 &sh
->Program
->info
);
1226 /* Store shader info */
1227 blob_write_bytes(blob
,
1228 ((char *) &sh
->Program
->info
) + s_info_ptrs
,
1229 s_info_size
- s_info_ptrs
);
1233 write_xfb(blob
, prog
);
1235 write_uniform_remap_tables(blob
, prog
);
1237 write_atomic_buffers(blob
, prog
);
1239 write_buffer_blocks(blob
, prog
);
1241 write_subroutines(blob
, prog
);
1243 write_program_resource_list(blob
, prog
);
1247 deserialize_glsl_program(struct blob_reader
*blob
, struct gl_context
*ctx
,
1248 struct gl_shader_program
*prog
)
1250 /* Fixed function programs generated by Mesa can't be serialized. */
1251 if (prog
->Name
== 0)
1254 assert(prog
->data
->UniformStorage
== NULL
);
1256 blob_copy_bytes(blob
, prog
->data
->sha1
, sizeof(prog
->data
->sha1
));
1258 read_uniforms(blob
, prog
);
1260 read_hash_tables(blob
, prog
);
1262 prog
->data
->Version
= blob_read_uint32(blob
);
1263 prog
->data
->linked_stages
= blob_read_uint32(blob
);
1265 unsigned mask
= prog
->data
->linked_stages
;
1267 const int j
= u_bit_scan(&mask
);
1268 create_linked_shader_and_program(ctx
, (gl_shader_stage
) j
, prog
,
1272 read_xfb(blob
, prog
);
1274 read_uniform_remap_tables(blob
, prog
);
1276 read_atomic_buffers(blob
, prog
);
1278 read_buffer_blocks(blob
, prog
);
1280 read_subroutines(blob
, prog
);
1282 read_program_resource_list(blob
, prog
);
1284 return !blob
->overrun
;