st/mesa: factor ucp-lowering logic into helper

[mesa.git] / src / mesa / state_tracker / st_shader_cache.c

diff --git a/src/mesa/state_tracker/st_shader_cache.c b/src/mesa/state_tracker/st_shader_cache.c
index 474ab4e1a0e08c952a13c397c039a02d115d70d1..000d1c2688b7dc4030594efdc8ee1ad359025b1c 100644 (file)
--- a/src/mesa/state_tracker/st_shader_cache.c
+++ b/src/mesa/state_tracker/st_shader_cache.c
@@ -44,8 +44,13 @@ static void
 write_stream_out_to_cache(struct blob *blob,
                           struct pipe_shader_state *state)
 {
-   blob_write_bytes(blob, &state->stream_output,
-                    sizeof(state->stream_output));
+   blob_write_uint32(blob, state->stream_output.num_outputs);
+   if (state->stream_output.num_outputs) {
+      blob_write_bytes(blob, &state->stream_output.stride,
+                       sizeof(state->stream_output.stride));
+      blob_write_bytes(blob, &state->stream_output.output,
+                       sizeof(state->stream_output.output));
+   }
 }
 
 static void
@@ -70,20 +75,13 @@ write_tgsi_to_cache(struct blob *blob, const struct tgsi_token *tokens,
 static void
 write_nir_to_cache(struct blob *blob, struct gl_program *prog)
 {
-   if (prog->nir) {
-      /* Reserve intptr_t to store the size. intptr_t is also the alignment
-       * of NIR in the blob, so the NIR size computation will be trivial.
-       */
-      size_t offset = blob_reserve_intptr(blob);
-      nir_serialize(blob, prog->nir, false);
-
-      unsigned nir_size = blob->size - offset - sizeof(intptr_t);
-      *(uintptr_t *)(blob->data + offset) = nir_size;
-   } else {
-      struct st_program *stp = (struct st_program *)prog;
-      blob_write_intptr(blob, stp->nir_size);
-      blob_write_bytes(blob, stp->nir_binary, stp->nir_size);
-   }
+   struct st_program *stp = (struct st_program *)prog;
+
+   st_serialize_nir(stp);
+
+   blob_write_intptr(blob, stp->serialized_nir_size);
+   blob_write_bytes(blob, stp->serialized_nir, stp->serialized_nir_size);
+
    copy_blob_to_driver_cache_blob(blob, prog);
 }
 
@@ -152,8 +150,14 @@ static void
 read_stream_out_from_cache(struct blob_reader *blob_reader,
                            struct pipe_shader_state *state)
 {
-   blob_copy_bytes(blob_reader, (uint8_t *) &state->stream_output,
-                    sizeof(state->stream_output));
+   memset(&state->stream_output, 0, sizeof(state->stream_output));
+   state->stream_output.num_outputs = blob_read_uint32(blob_reader);
+   if (state->stream_output.num_outputs) {
+      blob_copy_bytes(blob_reader, &state->stream_output.stride,
+                      sizeof(state->stream_output.stride));
+      blob_copy_bytes(blob_reader, &state->stream_output.output,
+                      sizeof(state->stream_output.output));
+   }
 }
 
 static void
@@ -184,9 +188,9 @@ st_deserialise_ir_program(struct gl_context *ctx,
    struct blob_reader blob_reader;
    blob_reader_init(&blob_reader, buffer, size);
 
-   if (prog->info.stage == MESA_SHADER_VERTEX) {
-      st_release_vp_variants(st, stp);
+   st_release_variants(st, stp);
 
+   if (prog->info.stage == MESA_SHADER_VERTEX) {
       struct st_vertex_program *stvp = (struct st_vertex_program *)stp;
       stvp->num_inputs = blob_read_uint32(&blob_reader);
       blob_copy_bytes(&blob_reader, (uint8_t *) stvp->index_to_input,
@@ -195,10 +199,6 @@ st_deserialise_ir_program(struct gl_context *ctx,
                       sizeof(stvp->input_to_index));
       blob_copy_bytes(&blob_reader, (uint8_t *) stvp->result_to_output,
                       sizeof(stvp->result_to_output));
-   } else if (prog->info.stage == MESA_SHADER_FRAGMENT) {
-      st_release_fp_variants(st, stp);
-   } else {
-      st_release_common_variants(st, stp);
    }
 
    if (prog->info.stage == MESA_SHADER_VERTEX ||
@@ -208,14 +208,12 @@ st_deserialise_ir_program(struct gl_context *ctx,
 
    if (nir) {
       assert(prog->nir == NULL);
-      assert(stp->state.ir.nir == NULL);
-      assert(stp->nir_binary == NULL);
+      assert(stp->serialized_nir == NULL);
 
-      /* The remainder of the binary is NIR. */
       stp->state.type = PIPE_SHADER_IR_NIR;
-      stp->nir_size = blob_read_intptr(&blob_reader);
-      stp->nir_binary = malloc(stp->nir_size);
-      blob_copy_bytes(&blob_reader, stp->nir_binary, stp->nir_size);
+      stp->serialized_nir_size = blob_read_intptr(&blob_reader);
+      stp->serialized_nir = malloc(stp->serialized_nir_size);
+      blob_copy_bytes(&blob_reader, stp->serialized_nir, stp->serialized_nir_size);
       stp->shader_program = shProg;
    } else {
       read_tgsi_from_cache(&blob_reader, &stp->state.tokens);