vkd3d-shader: Explicitly align the size in bytecode_get_next_offset() and rename it accordingly.

Approved-by: Henri Verbeet (@hverbeet)
Approved-by: Alexandre Julliard (@julliard)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/151

libs/vkd3d-shader/dxbc.c

@@ -57,7 +57,7 @@ int vkd3d_shader_serialize_dxbc(size_t section_count, const struct vkd3d_shader_
 
     put_u32(&buffer, TAG_DXBC);
 
-    checksum_position = bytecode_get_next_offset(&buffer);
+    checksum_position = bytecode_get_size(&buffer);
     for (i = 0; i < 4; ++i)
         put_u32(&buffer, 0);
 
@@ -65,13 +65,13 @@ int vkd3d_shader_serialize_dxbc(size_t section_count, const struct vkd3d_shader_
     size_position = put_u32(&buffer, 0);
     put_u32(&buffer, section_count);
 
-    offsets_position = bytecode_get_next_offset(&buffer);
+    offsets_position = bytecode_get_size(&buffer);
     for (i = 0; i < section_count; ++i)
         put_u32(&buffer, 0);
 
     for (i = 0; i < section_count; ++i)
     {
-        set_u32(&buffer, offsets_position + i * sizeof(uint32_t), bytecode_get_next_offset(&buffer));
+        set_u32(&buffer, offsets_position + i * sizeof(uint32_t), bytecode_align(&buffer));
         put_u32(&buffer, sections[i].tag);
         put_u32(&buffer, sections[i].data.size);
         bytecode_put_bytes(&buffer, sections[i].data.code, sections[i].data.size);
@@ -2754,7 +2754,7 @@ struct root_signature_writer_context
 
 static size_t get_chunk_offset(struct root_signature_writer_context *context)
 {
-    return bytecode_get_next_offset(&context->buffer) - context->chunk_position;
+    return bytecode_get_size(&context->buffer) - context->chunk_position;
 }
 
 static void shader_write_root_signature_header(struct root_signature_writer_context *context)
@@ -2770,10 +2770,10 @@ static void shader_write_root_signature_header(struct root_signature_writer_cont
     put_u32(buffer, 1);
     context->total_size_position = put_u32(buffer, 0xffffffff);
     put_u32(buffer, 1); /* chunk count */
-    put_u32(buffer, bytecode_get_next_offset(buffer) + sizeof(uint32_t)); /* chunk offset */
+    put_u32(buffer, bytecode_get_size(buffer) + sizeof(uint32_t)); /* chunk offset */
     put_u32(buffer, TAG_RTS0);
     put_u32(buffer, 0xffffffff);
-    context->chunk_position = bytecode_get_next_offset(buffer);
+    context->chunk_position = bytecode_get_size(buffer);
 }
 
 static void shader_write_descriptor_ranges(struct vkd3d_bytecode_buffer *buffer,
@@ -2862,7 +2862,7 @@ static int shader_write_root_parameters(struct root_signature_writer_context *co
     size_t parameters_position;
     unsigned int i;
 
-    parameters_position = bytecode_get_next_offset(buffer);
+    parameters_position = bytecode_align(buffer);
     for (i = 0; i < parameter_count; ++i)
     {
         put_u32(buffer, versioned_root_signature_get_parameter_type(desc, i));

libs/vkd3d-shader/hlsl_sm1.c

@@ -261,7 +261,7 @@ static void write_sm1_type(struct vkd3d_bytecode_buffer *buffer, struct hlsl_typ
             write_sm1_type(buffer, field->type, ctab_start);
         }
 
-        fields_offset = bytecode_get_next_offset(buffer) - ctab_start;
+        fields_offset = bytecode_align(buffer) - ctab_start;
 
         for (i = 0; i < field_count; ++i)
         {
@@ -351,7 +351,7 @@ static void write_sm1_uniforms(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffe
     put_u32(buffer, 0); /* FIXME: flags */
     put_u32(buffer, 0); /* FIXME: target string */
 
-    vars_start = bytecode_get_next_offset(buffer);
+    vars_start = bytecode_align(buffer);
 
     LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry)
     {
@@ -402,7 +402,7 @@ static void write_sm1_uniforms(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffe
     offset = put_string(buffer, vkd3d_shader_get_version(NULL, NULL));
     set_u32(buffer, creator_offset, offset - ctab_start);
 
-    ctab_end = bytecode_get_next_offset(buffer);
+    ctab_end = bytecode_align(buffer);
     set_u32(buffer, size_offset, vkd3d_make_u32(D3DSIO_COMMENT, (ctab_end - ctab_offset) / sizeof(uint32_t)));
 }
 

libs/vkd3d-shader/hlsl_sm4.c

@@ -387,7 +387,7 @@ static void write_sm4_type(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *b
             write_sm4_type(ctx, buffer, field->type);
         }
 
-        fields_offset = bytecode_get_next_offset(buffer);
+        fields_offset = bytecode_align(buffer);
 
         for (i = 0; i < field_count; ++i)
         {
@@ -583,7 +583,7 @@ static void write_sm4_rdef(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc)
 
     /* Bound resources. */
 
-    resources_offset = bytecode_get_next_offset(&buffer);
+    resources_offset = bytecode_align(&buffer);
     set_u32(&buffer, resource_position, resources_offset);
 
     for (i = 0; i < extern_resources_count; ++i)
@@ -656,7 +656,7 @@ static void write_sm4_rdef(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc)
 
     /* Buffers. */
 
-    cbuffers_offset = bytecode_get_next_offset(&buffer);
+    cbuffers_offset = bytecode_align(&buffer);
     set_u32(&buffer, cbuffer_position, cbuffers_offset);
     LIST_FOR_EACH_ENTRY(cbuffer, &ctx->buffers, struct hlsl_buffer, entry)
     {
@@ -692,7 +692,7 @@ static void write_sm4_rdef(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc)
     i = 0;
     LIST_FOR_EACH_ENTRY(cbuffer, &ctx->buffers, struct hlsl_buffer, entry)
     {
-        size_t vars_start = bytecode_get_next_offset(&buffer);
+        size_t vars_start = bytecode_align(&buffer);
 
         if (!cbuffer->reg.allocated)
             continue;

libs/vkd3d-shader/vkd3d_shader_main.c

@@ -340,9 +340,24 @@ void vkd3d_shader_error(struct vkd3d_shader_message_context *context, const stru
     va_end(args);
 }
 
+size_t bytecode_align(struct vkd3d_bytecode_buffer *buffer)
+{
+    size_t aligned_size = align(buffer->size, 4);
+
+    if (!vkd3d_array_reserve((void **)&buffer->data, &buffer->capacity, aligned_size, 1))
+    {
+        buffer->status = VKD3D_ERROR_OUT_OF_MEMORY;
+        return aligned_size;
+    }
+
+    memset(buffer->data + buffer->size, 0xab, aligned_size - buffer->size);
+    buffer->size = aligned_size;
+    return aligned_size;
+}
+
 size_t bytecode_put_bytes(struct vkd3d_bytecode_buffer *buffer, const void *bytes, size_t size)
 {
-    size_t offset = bytecode_get_next_offset(buffer);
+    size_t offset = bytecode_align(buffer);
 
     if (buffer->status)
         return offset;
@@ -352,7 +367,6 @@ size_t bytecode_put_bytes(struct vkd3d_bytecode_buffer *buffer, const void *byte
         buffer->status = VKD3D_ERROR_OUT_OF_MEMORY;
         return offset;
     }
-    memset(buffer->data + buffer->size, 0xab, offset - buffer->size);
     memcpy(buffer->data + offset, bytes, size);
     buffer->size = offset + size;
     return offset;

libs/vkd3d-shader/vkd3d_shader_private.h

@@ -1071,6 +1071,8 @@ struct vkd3d_bytecode_buffer
     int status;
 };
 
+/* Align to the next 4-byte offset, and return that offset. */
+size_t bytecode_align(struct vkd3d_bytecode_buffer *buffer);
 size_t bytecode_put_bytes(struct vkd3d_bytecode_buffer *buffer, const void *bytes, size_t size);
 void set_u32(struct vkd3d_bytecode_buffer *buffer, size_t offset, uint32_t value);
 
@@ -1094,11 +1096,6 @@ static inline size_t bytecode_get_size(struct vkd3d_bytecode_buffer *buffer)
     return buffer->size;
 }
 
-static inline size_t bytecode_get_next_offset(struct vkd3d_bytecode_buffer *buffer)
-{
-    return align(buffer->size, 4);
-}
-
 uint32_t vkd3d_parse_integer(const char *s);
 
 struct vkd3d_shader_message_context