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