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 "string_to_uint_map.h"
37 #include "util/bitscan.h"
40 #include "main/shaderobj.h"
41 #include "program/program.h"
45 write_subroutines(struct blob
*metadata
, struct gl_shader_program
*prog
)
47 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
48 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
52 struct gl_program
*glprog
= sh
->Program
;
54 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniforms
);
55 blob_write_uint32(metadata
, glprog
->sh
.MaxSubroutineFunctionIndex
);
56 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineFunctions
);
57 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
58 int num_types
= glprog
->sh
.SubroutineFunctions
[j
].num_compat_types
;
60 blob_write_string(metadata
, glprog
->sh
.SubroutineFunctions
[j
].name
);
61 blob_write_uint32(metadata
, glprog
->sh
.SubroutineFunctions
[j
].index
);
62 blob_write_uint32(metadata
, num_types
);
64 for (int k
= 0; k
< num_types
; k
++) {
65 encode_type_to_blob(metadata
,
66 glprog
->sh
.SubroutineFunctions
[j
].types
[k
]);
73 read_subroutines(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
75 struct gl_subroutine_function
*subs
;
77 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
78 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
82 struct gl_program
*glprog
= sh
->Program
;
84 glprog
->sh
.NumSubroutineUniforms
= blob_read_uint32(metadata
);
85 glprog
->sh
.MaxSubroutineFunctionIndex
= blob_read_uint32(metadata
);
86 glprog
->sh
.NumSubroutineFunctions
= blob_read_uint32(metadata
);
88 subs
= rzalloc_array(prog
, struct gl_subroutine_function
,
89 glprog
->sh
.NumSubroutineFunctions
);
90 glprog
->sh
.SubroutineFunctions
= subs
;
92 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
93 subs
[j
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
94 subs
[j
].index
= (int) blob_read_uint32(metadata
);
95 subs
[j
].num_compat_types
= (int) blob_read_uint32(metadata
);
97 subs
[j
].types
= rzalloc_array(prog
, const struct glsl_type
*,
98 subs
[j
].num_compat_types
);
99 for (int k
= 0; k
< subs
[j
].num_compat_types
; k
++) {
100 subs
[j
].types
[k
] = decode_type_from_blob(metadata
);
107 write_buffer_block(struct blob
*metadata
, struct gl_uniform_block
*b
)
109 blob_write_string(metadata
, b
->Name
);
110 blob_write_uint32(metadata
, b
->NumUniforms
);
111 blob_write_uint32(metadata
, b
->Binding
);
112 blob_write_uint32(metadata
, b
->UniformBufferSize
);
113 blob_write_uint32(metadata
, b
->stageref
);
115 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
116 blob_write_string(metadata
, b
->Uniforms
[j
].Name
);
117 blob_write_string(metadata
, b
->Uniforms
[j
].IndexName
);
118 encode_type_to_blob(metadata
, b
->Uniforms
[j
].Type
);
119 blob_write_uint32(metadata
, b
->Uniforms
[j
].Offset
);
124 write_buffer_blocks(struct blob
*metadata
, struct gl_shader_program
*prog
)
126 blob_write_uint32(metadata
, prog
->data
->NumUniformBlocks
);
127 blob_write_uint32(metadata
, prog
->data
->NumShaderStorageBlocks
);
129 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
130 write_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
]);
133 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
134 write_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
]);
137 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
138 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
142 struct gl_program
*glprog
= sh
->Program
;
144 blob_write_uint32(metadata
, glprog
->info
.num_ubos
);
145 blob_write_uint32(metadata
, glprog
->info
.num_ssbos
);
147 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
149 glprog
->sh
.UniformBlocks
[j
] - prog
->data
->UniformBlocks
;
150 blob_write_uint32(metadata
, offset
);
153 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
154 uint32_t offset
= glprog
->sh
.ShaderStorageBlocks
[j
] -
155 prog
->data
->ShaderStorageBlocks
;
156 blob_write_uint32(metadata
, offset
);
162 read_buffer_block(struct blob_reader
*metadata
, struct gl_uniform_block
*b
,
163 struct gl_shader_program
*prog
)
165 b
->Name
= ralloc_strdup(prog
->data
, blob_read_string (metadata
));
166 b
->NumUniforms
= blob_read_uint32(metadata
);
167 b
->Binding
= blob_read_uint32(metadata
);
168 b
->UniformBufferSize
= blob_read_uint32(metadata
);
169 b
->stageref
= blob_read_uint32(metadata
);
172 rzalloc_array(prog
->data
, struct gl_uniform_buffer_variable
,
174 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
175 b
->Uniforms
[j
].Name
= ralloc_strdup(prog
->data
,
176 blob_read_string (metadata
));
178 char *index_name
= blob_read_string(metadata
);
179 if (strcmp(b
->Uniforms
[j
].Name
, index_name
) == 0) {
180 b
->Uniforms
[j
].IndexName
= b
->Uniforms
[j
].Name
;
182 b
->Uniforms
[j
].IndexName
= ralloc_strdup(prog
->data
, index_name
);
185 b
->Uniforms
[j
].Type
= decode_type_from_blob(metadata
);
186 b
->Uniforms
[j
].Offset
= blob_read_uint32(metadata
);
191 read_buffer_blocks(struct blob_reader
*metadata
,
192 struct gl_shader_program
*prog
)
194 prog
->data
->NumUniformBlocks
= blob_read_uint32(metadata
);
195 prog
->data
->NumShaderStorageBlocks
= blob_read_uint32(metadata
);
197 prog
->data
->UniformBlocks
=
198 rzalloc_array(prog
->data
, struct gl_uniform_block
,
199 prog
->data
->NumUniformBlocks
);
201 prog
->data
->ShaderStorageBlocks
=
202 rzalloc_array(prog
->data
, struct gl_uniform_block
,
203 prog
->data
->NumShaderStorageBlocks
);
205 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
206 read_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
], prog
);
209 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
210 read_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
], prog
);
213 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
214 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
218 struct gl_program
*glprog
= sh
->Program
;
220 glprog
->info
.num_ubos
= blob_read_uint32(metadata
);
221 glprog
->info
.num_ssbos
= blob_read_uint32(metadata
);
223 glprog
->sh
.UniformBlocks
=
224 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ubos
);
225 glprog
->sh
.ShaderStorageBlocks
=
226 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ssbos
);
228 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
229 uint32_t offset
= blob_read_uint32(metadata
);
230 glprog
->sh
.UniformBlocks
[j
] = prog
->data
->UniformBlocks
+ offset
;
233 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
234 uint32_t offset
= blob_read_uint32(metadata
);
235 glprog
->sh
.ShaderStorageBlocks
[j
] =
236 prog
->data
->ShaderStorageBlocks
+ offset
;
242 write_atomic_buffers(struct blob
*metadata
, struct gl_shader_program
*prog
)
244 blob_write_uint32(metadata
, prog
->data
->NumAtomicBuffers
);
246 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
247 if (prog
->_LinkedShaders
[i
]) {
248 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
249 blob_write_uint32(metadata
, glprog
->info
.num_abos
);
253 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
254 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Binding
);
255 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].MinimumSize
);
256 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].NumUniforms
);
258 blob_write_bytes(metadata
, prog
->data
->AtomicBuffers
[i
].StageReferences
,
259 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
261 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
262 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Uniforms
[j
]);
268 read_atomic_buffers(struct blob_reader
*metadata
,
269 struct gl_shader_program
*prog
)
271 prog
->data
->NumAtomicBuffers
= blob_read_uint32(metadata
);
272 prog
->data
->AtomicBuffers
=
273 rzalloc_array(prog
, gl_active_atomic_buffer
,
274 prog
->data
->NumAtomicBuffers
);
276 struct gl_active_atomic_buffer
**stage_buff_list
[MESA_SHADER_STAGES
];
277 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
278 if (prog
->_LinkedShaders
[i
]) {
279 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
281 glprog
->info
.num_abos
= blob_read_uint32(metadata
);
282 glprog
->sh
.AtomicBuffers
=
283 rzalloc_array(glprog
, gl_active_atomic_buffer
*,
284 glprog
->info
.num_abos
);
285 stage_buff_list
[i
] = glprog
->sh
.AtomicBuffers
;
289 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
290 prog
->data
->AtomicBuffers
[i
].Binding
= blob_read_uint32(metadata
);
291 prog
->data
->AtomicBuffers
[i
].MinimumSize
= blob_read_uint32(metadata
);
292 prog
->data
->AtomicBuffers
[i
].NumUniforms
= blob_read_uint32(metadata
);
294 blob_copy_bytes(metadata
,
295 (uint8_t *) &prog
->data
->AtomicBuffers
[i
].StageReferences
,
296 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
298 prog
->data
->AtomicBuffers
[i
].Uniforms
= rzalloc_array(prog
, unsigned,
299 prog
->data
->AtomicBuffers
[i
].NumUniforms
);
301 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
302 prog
->data
->AtomicBuffers
[i
].Uniforms
[j
] = blob_read_uint32(metadata
);
305 for (unsigned j
= 0; j
< MESA_SHADER_STAGES
; j
++) {
306 if (prog
->data
->AtomicBuffers
[i
].StageReferences
[j
]) {
307 *stage_buff_list
[j
] = &prog
->data
->AtomicBuffers
[i
];
308 stage_buff_list
[j
]++;
315 write_xfb(struct blob
*metadata
, struct gl_shader_program
*shProg
)
317 struct gl_program
*prog
= shProg
->last_vert_prog
;
320 blob_write_uint32(metadata
, ~0u);
324 struct gl_transform_feedback_info
*ltf
= prog
->sh
.LinkedTransformFeedback
;
326 blob_write_uint32(metadata
, prog
->info
.stage
);
328 blob_write_uint32(metadata
, ltf
->NumOutputs
);
329 blob_write_uint32(metadata
, ltf
->ActiveBuffers
);
330 blob_write_uint32(metadata
, ltf
->NumVarying
);
332 blob_write_bytes(metadata
, ltf
->Outputs
,
333 sizeof(struct gl_transform_feedback_output
) *
336 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
337 blob_write_string(metadata
, ltf
->Varyings
[i
].Name
);
338 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Type
);
339 blob_write_uint32(metadata
, ltf
->Varyings
[i
].BufferIndex
);
340 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Size
);
341 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Offset
);
344 blob_write_bytes(metadata
, ltf
->Buffers
,
345 sizeof(struct gl_transform_feedback_buffer
) *
346 MAX_FEEDBACK_BUFFERS
);
350 read_xfb(struct blob_reader
*metadata
, struct gl_shader_program
*shProg
)
352 unsigned xfb_stage
= blob_read_uint32(metadata
);
354 if (xfb_stage
== ~0u)
357 struct gl_program
*prog
= shProg
->_LinkedShaders
[xfb_stage
]->Program
;
358 struct gl_transform_feedback_info
*ltf
=
359 rzalloc(prog
, struct gl_transform_feedback_info
);
361 prog
->sh
.LinkedTransformFeedback
= ltf
;
362 shProg
->last_vert_prog
= prog
;
364 ltf
->NumOutputs
= blob_read_uint32(metadata
);
365 ltf
->ActiveBuffers
= blob_read_uint32(metadata
);
366 ltf
->NumVarying
= blob_read_uint32(metadata
);
368 ltf
->Outputs
= rzalloc_array(prog
, struct gl_transform_feedback_output
,
371 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Outputs
,
372 sizeof(struct gl_transform_feedback_output
) *
375 ltf
->Varyings
= rzalloc_array(prog
,
376 struct gl_transform_feedback_varying_info
,
379 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
380 ltf
->Varyings
[i
].Name
= ralloc_strdup(prog
, blob_read_string(metadata
));
381 ltf
->Varyings
[i
].Type
= blob_read_uint32(metadata
);
382 ltf
->Varyings
[i
].BufferIndex
= blob_read_uint32(metadata
);
383 ltf
->Varyings
[i
].Size
= blob_read_uint32(metadata
);
384 ltf
->Varyings
[i
].Offset
= blob_read_uint32(metadata
);
387 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Buffers
,
388 sizeof(struct gl_transform_feedback_buffer
) *
389 MAX_FEEDBACK_BUFFERS
);
393 has_uniform_storage(struct gl_shader_program
*prog
, unsigned idx
)
395 if (!prog
->data
->UniformStorage
[idx
].builtin
&&
396 !prog
->data
->UniformStorage
[idx
].is_shader_storage
&&
397 prog
->data
->UniformStorage
[idx
].block_index
== -1)
404 write_uniforms(struct blob
*metadata
, struct gl_shader_program
*prog
)
406 blob_write_uint32(metadata
, prog
->SamplersValidated
);
407 blob_write_uint32(metadata
, prog
->data
->NumUniformStorage
);
408 blob_write_uint32(metadata
, prog
->data
->NumUniformDataSlots
);
410 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
411 encode_type_to_blob(metadata
, prog
->data
->UniformStorage
[i
].type
);
412 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_elements
);
413 blob_write_string(metadata
, prog
->data
->UniformStorage
[i
].name
);
414 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].builtin
);
415 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].remap_location
);
416 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].block_index
);
417 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].atomic_buffer_index
);
418 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].offset
);
419 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_stride
);
420 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].hidden
);
421 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_shader_storage
);
422 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].active_shader_mask
);
423 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].matrix_stride
);
424 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].row_major
);
425 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_bindless
);
426 blob_write_uint32(metadata
,
427 prog
->data
->UniformStorage
[i
].num_compatible_subroutines
);
428 blob_write_uint32(metadata
,
429 prog
->data
->UniformStorage
[i
].top_level_array_size
);
430 blob_write_uint32(metadata
,
431 prog
->data
->UniformStorage
[i
].top_level_array_stride
);
433 if (has_uniform_storage(prog
, i
)) {
434 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].storage
-
435 prog
->data
->UniformDataSlots
);
438 blob_write_bytes(metadata
, prog
->data
->UniformStorage
[i
].opaque
,
439 sizeof(prog
->data
->UniformStorage
[i
].opaque
));
442 /* Here we cache all uniform values. We do this to retain values for
443 * uniforms with initialisers and also hidden uniforms that may be lowered
444 * constant arrays. We could possibly just store the values we need but for
445 * now we just store everything.
447 blob_write_uint32(metadata
, prog
->data
->NumHiddenUniforms
);
448 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
449 if (has_uniform_storage(prog
, i
)) {
451 prog
->data
->UniformStorage
[i
].type
->component_slots() *
452 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
454 prog
->data
->UniformStorage
[i
].storage
-
455 prog
->data
->UniformDataSlots
;
456 blob_write_bytes(metadata
, &prog
->data
->UniformDataDefaults
[slot
],
457 sizeof(union gl_constant_value
) * vec_size
);
463 read_uniforms(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
465 struct gl_uniform_storage
*uniforms
;
466 union gl_constant_value
*data
;
468 prog
->SamplersValidated
= blob_read_uint32(metadata
);
469 prog
->data
->NumUniformStorage
= blob_read_uint32(metadata
);
470 prog
->data
->NumUniformDataSlots
= blob_read_uint32(metadata
);
472 uniforms
= rzalloc_array(prog
->data
, struct gl_uniform_storage
,
473 prog
->data
->NumUniformStorage
);
474 prog
->data
->UniformStorage
= uniforms
;
476 data
= rzalloc_array(uniforms
, union gl_constant_value
,
477 prog
->data
->NumUniformDataSlots
);
478 prog
->data
->UniformDataSlots
= data
;
479 prog
->data
->UniformDataDefaults
=
480 rzalloc_array(uniforms
, union gl_constant_value
,
481 prog
->data
->NumUniformDataSlots
);
483 prog
->UniformHash
= new string_to_uint_map
;
485 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
486 uniforms
[i
].type
= decode_type_from_blob(metadata
);
487 uniforms
[i
].array_elements
= blob_read_uint32(metadata
);
488 uniforms
[i
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
489 uniforms
[i
].builtin
= blob_read_uint32(metadata
);
490 uniforms
[i
].remap_location
= blob_read_uint32(metadata
);
491 uniforms
[i
].block_index
= blob_read_uint32(metadata
);
492 uniforms
[i
].atomic_buffer_index
= blob_read_uint32(metadata
);
493 uniforms
[i
].offset
= blob_read_uint32(metadata
);
494 uniforms
[i
].array_stride
= blob_read_uint32(metadata
);
495 uniforms
[i
].hidden
= blob_read_uint32(metadata
);
496 uniforms
[i
].is_shader_storage
= blob_read_uint32(metadata
);
497 uniforms
[i
].active_shader_mask
= blob_read_uint32(metadata
);
498 uniforms
[i
].matrix_stride
= blob_read_uint32(metadata
);
499 uniforms
[i
].row_major
= blob_read_uint32(metadata
);
500 uniforms
[i
].is_bindless
= blob_read_uint32(metadata
);
501 uniforms
[i
].num_compatible_subroutines
= blob_read_uint32(metadata
);
502 uniforms
[i
].top_level_array_size
= blob_read_uint32(metadata
);
503 uniforms
[i
].top_level_array_stride
= blob_read_uint32(metadata
);
504 prog
->UniformHash
->put(i
, uniforms
[i
].name
);
506 if (has_uniform_storage(prog
, i
)) {
507 uniforms
[i
].storage
= data
+ blob_read_uint32(metadata
);
510 memcpy(uniforms
[i
].opaque
,
511 blob_read_bytes(metadata
, sizeof(uniforms
[i
].opaque
)),
512 sizeof(uniforms
[i
].opaque
));
515 /* Restore uniform values. */
516 prog
->data
->NumHiddenUniforms
= blob_read_uint32(metadata
);
517 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
518 if (has_uniform_storage(prog
, i
)) {
520 prog
->data
->UniformStorage
[i
].type
->component_slots() *
521 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
523 prog
->data
->UniformStorage
[i
].storage
-
524 prog
->data
->UniformDataSlots
;
525 blob_copy_bytes(metadata
,
526 (uint8_t *) &prog
->data
->UniformDataSlots
[slot
],
527 sizeof(union gl_constant_value
) * vec_size
);
529 assert(vec_size
+ prog
->data
->UniformStorage
[i
].storage
<=
530 data
+ prog
->data
->NumUniformDataSlots
);
534 memcpy(prog
->data
->UniformDataDefaults
, prog
->data
->UniformDataSlots
,
535 sizeof(union gl_constant_value
) * prog
->data
->NumUniformDataSlots
);
538 enum uniform_remap_type
540 remap_type_inactive_explicit_location
,
542 remap_type_uniform_offset
546 write_uniform_remap_table_entry(struct blob
*metadata
,
547 gl_uniform_storage
*uniform_storage
,
548 gl_uniform_storage
*entry
)
550 if (entry
== INACTIVE_UNIFORM_EXPLICIT_LOCATION
) {
551 blob_write_uint32(metadata
, remap_type_inactive_explicit_location
);
552 } else if (entry
== NULL
) {
553 blob_write_uint32(metadata
, remap_type_null_ptr
);
555 blob_write_uint32(metadata
, remap_type_uniform_offset
);
557 uint32_t offset
= entry
- uniform_storage
;
558 blob_write_uint32(metadata
, offset
);
563 write_uniform_remap_tables(struct blob
*metadata
,
564 struct gl_shader_program
*prog
)
566 blob_write_uint32(metadata
, prog
->NumUniformRemapTable
);
568 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
569 write_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
570 prog
->UniformRemapTable
[i
]);
573 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
574 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
576 struct gl_program
*glprog
= sh
->Program
;
577 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniformRemapTable
);
579 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
580 write_uniform_remap_table_entry(metadata
,
581 prog
->data
->UniformStorage
,
582 glprog
->sh
.SubroutineUniformRemapTable
[j
]);
589 read_uniform_remap_table_entry(struct blob_reader
*metadata
,
590 gl_uniform_storage
*uniform_storage
,
591 gl_uniform_storage
**entry
,
592 enum uniform_remap_type type
)
594 if (type
== remap_type_inactive_explicit_location
) {
595 *entry
= INACTIVE_UNIFORM_EXPLICIT_LOCATION
;
596 } else if (type
== remap_type_null_ptr
) {
599 uint32_t uni_offset
= blob_read_uint32(metadata
);
600 *entry
= uniform_storage
+ uni_offset
;
605 read_uniform_remap_tables(struct blob_reader
*metadata
,
606 struct gl_shader_program
*prog
)
608 prog
->NumUniformRemapTable
= blob_read_uint32(metadata
);
610 prog
->UniformRemapTable
= rzalloc_array(prog
, struct gl_uniform_storage
*,
611 prog
->NumUniformRemapTable
);
613 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
614 enum uniform_remap_type type
=
615 (enum uniform_remap_type
) blob_read_uint32(metadata
);
617 read_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
618 &prog
->UniformRemapTable
[i
], type
);
621 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
622 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
624 struct gl_program
*glprog
= sh
->Program
;
625 glprog
->sh
.NumSubroutineUniformRemapTable
= blob_read_uint32(metadata
);
627 glprog
->sh
.SubroutineUniformRemapTable
=
628 rzalloc_array(glprog
, struct gl_uniform_storage
*,
629 glprog
->sh
.NumSubroutineUniformRemapTable
);
631 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
632 enum uniform_remap_type type
=
633 (enum uniform_remap_type
) blob_read_uint32(metadata
);
635 read_uniform_remap_table_entry(metadata
,
636 prog
->data
->UniformStorage
,
637 &glprog
->sh
.SubroutineUniformRemapTable
[j
],
651 write_hash_table_entry(const char *key
, unsigned value
, void *closure
)
653 struct whte_closure
*whte
= (struct whte_closure
*) closure
;
655 blob_write_string(whte
->blob
, key
);
656 blob_write_uint32(whte
->blob
, value
);
662 write_hash_table(struct blob
*metadata
, struct string_to_uint_map
*hash
)
665 struct whte_closure whte
;
667 whte
.blob
= metadata
;
668 whte
.num_entries
= 0;
670 offset
= metadata
->size
;
672 /* Write a placeholder for the hashtable size. */
673 blob_write_uint32 (metadata
, 0);
675 hash
->iterate(write_hash_table_entry
, &whte
);
677 /* Overwrite with the computed number of entries written. */
678 blob_overwrite_uint32 (metadata
, offset
, whte
.num_entries
);
682 read_hash_table(struct blob_reader
*metadata
, struct string_to_uint_map
*hash
)
684 size_t i
, num_entries
;
688 num_entries
= blob_read_uint32 (metadata
);
690 for (i
= 0; i
< num_entries
; i
++) {
691 key
= blob_read_string(metadata
);
692 value
= blob_read_uint32(metadata
);
694 hash
->put(value
, key
);
699 write_hash_tables(struct blob
*metadata
, struct gl_shader_program
*prog
)
701 write_hash_table(metadata
, prog
->AttributeBindings
);
702 write_hash_table(metadata
, prog
->FragDataBindings
);
703 write_hash_table(metadata
, prog
->FragDataIndexBindings
);
707 read_hash_tables(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
709 read_hash_table(metadata
, prog
->AttributeBindings
);
710 read_hash_table(metadata
, prog
->FragDataBindings
);
711 read_hash_table(metadata
, prog
->FragDataIndexBindings
);
715 write_shader_subroutine_index(struct blob
*metadata
,
716 struct gl_linked_shader
*sh
,
717 struct gl_program_resource
*res
)
721 for (unsigned j
= 0; j
< sh
->Program
->sh
.NumSubroutineFunctions
; j
++) {
722 if (strcmp(((gl_subroutine_function
*)res
->Data
)->name
,
723 sh
->Program
->sh
.SubroutineFunctions
[j
].name
) == 0) {
724 blob_write_uint32(metadata
, j
);
731 get_shader_var_and_pointer_sizes(size_t *s_var_size
, size_t *s_var_ptrs
,
732 const gl_shader_variable
*var
)
734 *s_var_size
= sizeof(gl_shader_variable
);
737 sizeof(var
->interface_type
) +
738 sizeof(var
->outermost_struct_type
) +
743 write_program_resource_data(struct blob
*metadata
,
744 struct gl_shader_program
*prog
,
745 struct gl_program_resource
*res
)
747 struct gl_linked_shader
*sh
;
750 case GL_PROGRAM_INPUT
:
751 case GL_PROGRAM_OUTPUT
: {
752 const gl_shader_variable
*var
= (gl_shader_variable
*)res
->Data
;
754 encode_type_to_blob(metadata
, var
->type
);
755 encode_type_to_blob(metadata
, var
->interface_type
);
756 encode_type_to_blob(metadata
, var
->outermost_struct_type
);
758 blob_write_string(metadata
, var
->name
);
760 size_t s_var_size
, s_var_ptrs
;
761 get_shader_var_and_pointer_sizes(&s_var_size
, &s_var_ptrs
, var
);
763 /* Write gl_shader_variable skipping over the pointers */
764 blob_write_bytes(metadata
, ((char *)var
) + s_var_ptrs
,
765 s_var_size
- s_var_ptrs
);
768 case GL_UNIFORM_BLOCK
:
769 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
770 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
771 prog
->data
->UniformBlocks
[i
].Name
) == 0) {
772 blob_write_uint32(metadata
, i
);
777 case GL_SHADER_STORAGE_BLOCK
:
778 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
779 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
780 prog
->data
->ShaderStorageBlocks
[i
].Name
) == 0) {
781 blob_write_uint32(metadata
, i
);
786 case GL_BUFFER_VARIABLE
:
787 case GL_VERTEX_SUBROUTINE_UNIFORM
:
788 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
789 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
790 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
791 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
792 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
794 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
795 if (strcmp(((gl_uniform_storage
*)res
->Data
)->name
,
796 prog
->data
->UniformStorage
[i
].name
) == 0) {
797 blob_write_uint32(metadata
, i
);
802 case GL_ATOMIC_COUNTER_BUFFER
:
803 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
804 if (((gl_active_atomic_buffer
*)res
->Data
)->Binding
==
805 prog
->data
->AtomicBuffers
[i
].Binding
) {
806 blob_write_uint32(metadata
, i
);
811 case GL_TRANSFORM_FEEDBACK_BUFFER
:
812 for (unsigned i
= 0; i
< MAX_FEEDBACK_BUFFERS
; i
++) {
813 if (((gl_transform_feedback_buffer
*)res
->Data
)->Binding
==
814 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Buffers
[i
].Binding
) {
815 blob_write_uint32(metadata
, i
);
820 case GL_TRANSFORM_FEEDBACK_VARYING
:
821 for (int i
= 0; i
< prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
; i
++) {
822 if (strcmp(((gl_transform_feedback_varying_info
*)res
->Data
)->Name
,
823 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Varyings
[i
].Name
) == 0) {
824 blob_write_uint32(metadata
, i
);
829 case GL_VERTEX_SUBROUTINE
:
830 case GL_TESS_CONTROL_SUBROUTINE
:
831 case GL_TESS_EVALUATION_SUBROUTINE
:
832 case GL_GEOMETRY_SUBROUTINE
:
833 case GL_FRAGMENT_SUBROUTINE
:
834 case GL_COMPUTE_SUBROUTINE
:
836 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
837 write_shader_subroutine_index(metadata
, sh
, res
);
840 assert(!"Support for writing resource not yet implemented.");
845 read_program_resource_data(struct blob_reader
*metadata
,
846 struct gl_shader_program
*prog
,
847 struct gl_program_resource
*res
)
849 struct gl_linked_shader
*sh
;
852 case GL_PROGRAM_INPUT
:
853 case GL_PROGRAM_OUTPUT
: {
854 gl_shader_variable
*var
= ralloc(prog
, struct gl_shader_variable
);
856 var
->type
= decode_type_from_blob(metadata
);
857 var
->interface_type
= decode_type_from_blob(metadata
);
858 var
->outermost_struct_type
= decode_type_from_blob(metadata
);
860 var
->name
= ralloc_strdup(prog
, blob_read_string(metadata
));
862 size_t s_var_size
, s_var_ptrs
;
863 get_shader_var_and_pointer_sizes(&s_var_size
, &s_var_ptrs
, var
);
865 blob_copy_bytes(metadata
, ((uint8_t *) var
) + s_var_ptrs
,
866 s_var_size
- s_var_ptrs
);
871 case GL_UNIFORM_BLOCK
:
872 res
->Data
= &prog
->data
->UniformBlocks
[blob_read_uint32(metadata
)];
874 case GL_SHADER_STORAGE_BLOCK
:
875 res
->Data
= &prog
->data
->ShaderStorageBlocks
[blob_read_uint32(metadata
)];
877 case GL_BUFFER_VARIABLE
:
878 case GL_VERTEX_SUBROUTINE_UNIFORM
:
879 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
880 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
881 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
882 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
883 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
885 res
->Data
= &prog
->data
->UniformStorage
[blob_read_uint32(metadata
)];
887 case GL_ATOMIC_COUNTER_BUFFER
:
888 res
->Data
= &prog
->data
->AtomicBuffers
[blob_read_uint32(metadata
)];
890 case GL_TRANSFORM_FEEDBACK_BUFFER
:
891 res
->Data
= &prog
->last_vert_prog
->
892 sh
.LinkedTransformFeedback
->Buffers
[blob_read_uint32(metadata
)];
894 case GL_TRANSFORM_FEEDBACK_VARYING
:
895 res
->Data
= &prog
->last_vert_prog
->
896 sh
.LinkedTransformFeedback
->Varyings
[blob_read_uint32(metadata
)];
898 case GL_VERTEX_SUBROUTINE
:
899 case GL_TESS_CONTROL_SUBROUTINE
:
900 case GL_TESS_EVALUATION_SUBROUTINE
:
901 case GL_GEOMETRY_SUBROUTINE
:
902 case GL_FRAGMENT_SUBROUTINE
:
903 case GL_COMPUTE_SUBROUTINE
:
905 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
907 &sh
->Program
->sh
.SubroutineFunctions
[blob_read_uint32(metadata
)];
910 assert(!"Support for reading resource not yet implemented.");
915 write_program_resource_list(struct blob
*metadata
,
916 struct gl_shader_program
*prog
)
918 blob_write_uint32(metadata
, prog
->data
->NumProgramResourceList
);
920 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
921 blob_write_uint32(metadata
, prog
->data
->ProgramResourceList
[i
].Type
);
922 write_program_resource_data(metadata
, prog
,
923 &prog
->data
->ProgramResourceList
[i
]);
924 blob_write_bytes(metadata
,
925 &prog
->data
->ProgramResourceList
[i
].StageReferences
,
926 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
931 read_program_resource_list(struct blob_reader
*metadata
,
932 struct gl_shader_program
*prog
)
934 prog
->data
->NumProgramResourceList
= blob_read_uint32(metadata
);
936 prog
->data
->ProgramResourceList
=
937 ralloc_array(prog
->data
, gl_program_resource
,
938 prog
->data
->NumProgramResourceList
);
940 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
941 prog
->data
->ProgramResourceList
[i
].Type
= blob_read_uint32(metadata
);
942 read_program_resource_data(metadata
, prog
,
943 &prog
->data
->ProgramResourceList
[i
]);
944 blob_copy_bytes(metadata
,
945 (uint8_t *) &prog
->data
->ProgramResourceList
[i
].StageReferences
,
946 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
951 write_shader_parameters(struct blob
*metadata
,
952 struct gl_program_parameter_list
*params
)
954 blob_write_uint32(metadata
, params
->NumParameters
);
957 while (i
< params
->NumParameters
) {
958 struct gl_program_parameter
*param
= ¶ms
->Parameters
[i
];
960 blob_write_uint32(metadata
, param
->Type
);
961 blob_write_string(metadata
, param
->Name
);
962 blob_write_uint32(metadata
, param
->Size
);
963 blob_write_uint32(metadata
, param
->DataType
);
964 blob_write_bytes(metadata
, param
->StateIndexes
,
965 sizeof(param
->StateIndexes
));
970 blob_write_bytes(metadata
, params
->ParameterValues
,
971 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
973 blob_write_uint32(metadata
, params
->StateFlags
);
977 read_shader_parameters(struct blob_reader
*metadata
,
978 struct gl_program_parameter_list
*params
)
980 gl_state_index state_indexes
[STATE_LENGTH
];
982 uint32_t num_parameters
= blob_read_uint32(metadata
);
984 _mesa_reserve_parameter_storage(params
, num_parameters
);
985 while (i
< num_parameters
) {
986 gl_register_file type
= (gl_register_file
) blob_read_uint32(metadata
);
987 const char *name
= blob_read_string(metadata
);
988 unsigned size
= blob_read_uint32(metadata
);
989 unsigned data_type
= blob_read_uint32(metadata
);
990 blob_copy_bytes(metadata
, (uint8_t *) state_indexes
,
991 sizeof(state_indexes
));
993 _mesa_add_parameter(params
, type
, name
, size
, data_type
,
994 NULL
, state_indexes
);
999 blob_copy_bytes(metadata
, (uint8_t *) params
->ParameterValues
,
1000 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
1002 params
->StateFlags
= blob_read_uint32(metadata
);
1006 write_shader_metadata(struct blob
*metadata
, gl_linked_shader
*shader
)
1008 assert(shader
->Program
);
1009 struct gl_program
*glprog
= shader
->Program
;
1012 blob_write_bytes(metadata
, glprog
->TexturesUsed
,
1013 sizeof(glprog
->TexturesUsed
));
1014 blob_write_uint64(metadata
, glprog
->SamplersUsed
);
1016 blob_write_bytes(metadata
, glprog
->SamplerUnits
,
1017 sizeof(glprog
->SamplerUnits
));
1018 blob_write_bytes(metadata
, glprog
->sh
.SamplerTargets
,
1019 sizeof(glprog
->sh
.SamplerTargets
));
1020 blob_write_uint32(metadata
, glprog
->ShadowSamplers
);
1022 blob_write_bytes(metadata
, glprog
->sh
.ImageAccess
,
1023 sizeof(glprog
->sh
.ImageAccess
));
1024 blob_write_bytes(metadata
, glprog
->sh
.ImageUnits
,
1025 sizeof(glprog
->sh
.ImageUnits
));
1027 size_t ptr_size
= sizeof(GLvoid
*);
1029 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessSamplers
);
1030 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessSampler
);
1031 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1032 blob_write_bytes(metadata
, &glprog
->sh
.BindlessSamplers
[i
],
1033 sizeof(struct gl_bindless_sampler
) - ptr_size
);
1036 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessImages
);
1037 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessImage
);
1038 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1039 blob_write_bytes(metadata
, &glprog
->sh
.BindlessImages
[i
],
1040 sizeof(struct gl_bindless_image
) - ptr_size
);
1043 blob_write_bytes(metadata
, &glprog
->sh
.fs
.BlendSupport
,
1044 sizeof(glprog
->sh
.fs
.BlendSupport
));
1046 write_shader_parameters(metadata
, glprog
->Parameters
);
1048 assert((glprog
->driver_cache_blob
== NULL
) ==
1049 (glprog
->driver_cache_blob_size
== 0));
1050 blob_write_uint32(metadata
, (uint32_t)glprog
->driver_cache_blob_size
);
1051 if (glprog
->driver_cache_blob_size
> 0) {
1052 blob_write_bytes(metadata
, glprog
->driver_cache_blob
,
1053 glprog
->driver_cache_blob_size
);
1058 read_shader_metadata(struct blob_reader
*metadata
,
1059 struct gl_program
*glprog
,
1060 gl_linked_shader
*linked
)
1064 blob_copy_bytes(metadata
, (uint8_t *) glprog
->TexturesUsed
,
1065 sizeof(glprog
->TexturesUsed
));
1066 glprog
->SamplersUsed
= blob_read_uint64(metadata
);
1068 blob_copy_bytes(metadata
, (uint8_t *) glprog
->SamplerUnits
,
1069 sizeof(glprog
->SamplerUnits
));
1070 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.SamplerTargets
,
1071 sizeof(glprog
->sh
.SamplerTargets
));
1072 glprog
->ShadowSamplers
= blob_read_uint32(metadata
);
1074 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageAccess
,
1075 sizeof(glprog
->sh
.ImageAccess
));
1076 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageUnits
,
1077 sizeof(glprog
->sh
.ImageUnits
));
1079 size_t ptr_size
= sizeof(GLvoid
*);
1081 glprog
->sh
.NumBindlessSamplers
= blob_read_uint32(metadata
);
1082 glprog
->sh
.HasBoundBindlessSampler
= blob_read_uint32(metadata
);
1083 if (glprog
->sh
.NumBindlessSamplers
> 0) {
1084 glprog
->sh
.BindlessSamplers
=
1085 rzalloc_array(glprog
, gl_bindless_sampler
,
1086 glprog
->sh
.NumBindlessSamplers
);
1088 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1089 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessSamplers
[i
],
1090 sizeof(struct gl_bindless_sampler
) - ptr_size
);
1094 glprog
->sh
.NumBindlessImages
= blob_read_uint32(metadata
);
1095 glprog
->sh
.HasBoundBindlessImage
= blob_read_uint32(metadata
);
1096 if (glprog
->sh
.NumBindlessImages
> 0) {
1097 glprog
->sh
.BindlessImages
=
1098 rzalloc_array(glprog
, gl_bindless_image
,
1099 glprog
->sh
.NumBindlessImages
);
1101 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1102 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessImages
[i
],
1103 sizeof(struct gl_bindless_image
) - ptr_size
);
1107 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.fs
.BlendSupport
,
1108 sizeof(glprog
->sh
.fs
.BlendSupport
));
1110 glprog
->Parameters
= _mesa_new_parameter_list();
1111 read_shader_parameters(metadata
, glprog
->Parameters
);
1113 glprog
->driver_cache_blob_size
= (size_t)blob_read_uint32(metadata
);
1114 if (glprog
->driver_cache_blob_size
> 0) {
1115 glprog
->driver_cache_blob
=
1116 (uint8_t*)ralloc_size(glprog
, glprog
->driver_cache_blob_size
);
1117 blob_copy_bytes(metadata
, glprog
->driver_cache_blob
,
1118 glprog
->driver_cache_blob_size
);
1123 get_shader_info_and_pointer_sizes(size_t *s_info_size
, size_t *s_info_ptrs
,
1126 *s_info_size
= sizeof(shader_info
);
1127 *s_info_ptrs
= sizeof(info
->name
) + sizeof(info
->label
);
1131 create_linked_shader_and_program(struct gl_context
*ctx
,
1132 gl_shader_stage stage
,
1133 struct gl_shader_program
*prog
,
1134 struct blob_reader
*metadata
)
1136 struct gl_program
*glprog
;
1138 struct gl_linked_shader
*linked
= rzalloc(NULL
, struct gl_linked_shader
);
1139 linked
->Stage
= stage
;
1141 glprog
= ctx
->Driver
.NewProgram(ctx
, _mesa_shader_stage_to_program(stage
),
1143 glprog
->info
.stage
= stage
;
1144 linked
->Program
= glprog
;
1146 read_shader_metadata(metadata
, glprog
, linked
);
1148 glprog
->info
.name
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1149 glprog
->info
.label
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1151 size_t s_info_size
, s_info_ptrs
;
1152 get_shader_info_and_pointer_sizes(&s_info_size
, &s_info_ptrs
,
1155 /* Restore shader info */
1156 blob_copy_bytes(metadata
, ((uint8_t *) &glprog
->info
) + s_info_ptrs
,
1157 s_info_size
- s_info_ptrs
);
1159 _mesa_reference_shader_program_data(ctx
, &glprog
->sh
.data
, prog
->data
);
1160 _mesa_reference_program(ctx
, &linked
->Program
, glprog
);
1161 prog
->_LinkedShaders
[stage
] = linked
;
1165 serialize_glsl_program(struct blob
*blob
, struct gl_context
*ctx
,
1166 struct gl_shader_program
*prog
)
1168 write_uniforms(blob
, prog
);
1170 write_hash_tables(blob
, prog
);
1172 blob_write_uint32(blob
, prog
->data
->Version
);
1173 blob_write_uint32(blob
, prog
->data
->linked_stages
);
1175 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1176 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
1178 write_shader_metadata(blob
, sh
);
1180 if (sh
->Program
->info
.name
)
1181 blob_write_string(blob
, sh
->Program
->info
.name
);
1183 blob_write_string(blob
, "");
1185 if (sh
->Program
->info
.label
)
1186 blob_write_string(blob
, sh
->Program
->info
.label
);
1188 blob_write_string(blob
, "");
1190 size_t s_info_size
, s_info_ptrs
;
1191 get_shader_info_and_pointer_sizes(&s_info_size
, &s_info_ptrs
,
1192 &sh
->Program
->info
);
1194 /* Store shader info */
1195 blob_write_bytes(blob
,
1196 ((char *) &sh
->Program
->info
) + s_info_ptrs
,
1197 s_info_size
- s_info_ptrs
);
1201 write_xfb(blob
, prog
);
1203 write_uniform_remap_tables(blob
, prog
);
1205 write_atomic_buffers(blob
, prog
);
1207 write_buffer_blocks(blob
, prog
);
1209 write_subroutines(blob
, prog
);
1211 write_program_resource_list(blob
, prog
);
1215 deserialize_glsl_program(struct blob_reader
*blob
, struct gl_context
*ctx
,
1216 struct gl_shader_program
*prog
)
1218 /* Fixed function programs generated by Mesa can't be serialized. */
1219 if (prog
->Name
== 0)
1222 assert(prog
->data
->UniformStorage
== NULL
);
1224 read_uniforms(blob
, prog
);
1226 read_hash_tables(blob
, prog
);
1228 prog
->data
->Version
= blob_read_uint32(blob
);
1229 prog
->data
->linked_stages
= blob_read_uint32(blob
);
1231 unsigned mask
= prog
->data
->linked_stages
;
1233 const int j
= u_bit_scan(&mask
);
1234 create_linked_shader_and_program(ctx
, (gl_shader_stage
) j
, prog
,
1238 read_xfb(blob
, prog
);
1240 read_uniform_remap_tables(blob
, prog
);
1242 read_atomic_buffers(blob
, prog
);
1244 read_buffer_blocks(blob
, prog
);
1246 read_subroutines(blob
, prog
);
1248 read_program_resource_list(blob
, prog
);
1250 return !blob
->overrun
;