vc4: Convert the driver to emitting the shader record using pack macros.

src/broadcom/cle/v3d_packet_v21.xml

@@ -217,4 +217,12 @@
     <field name="Coordinate Shader Uniforms Address" size="32" start="32b" type="uint"/>
   </struct>
 
+  <struct name="Attribute Record">
+    <field name="Address" size="32" start="0b" type="address"/>
+    <field name="Number of Bytes minus 1" size="8" start="4b" type="uint"/>
+    <field name="Stride" size="8" start="5b" type="uint"/>
+    <field name="Vertex Shader VPM offset" size="8" start="6b" type="uint"/>
+    <field name="Coordinate Shader VPM offset" size="8" start="7b" type="uint"/>
+  </struct>
+
 </vcxml>

src/gallium/drivers/vc4/vc4_cl.c

@@ -26,11 +26,12 @@
 #include "vc4_context.h"
 
 void
-vc4_init_cl(void *mem_ctx, struct vc4_cl *cl)
+vc4_init_cl(struct vc4_job *job, struct vc4_cl *cl)
 {
-        cl->base = rzalloc_size(mem_ctx, 1); /* TODO: don't use rzalloc */
+        cl->base = rzalloc_size(job, 1); /* TODO: don't use rzalloc */
         cl->next = cl->base;
         cl->size = 0;
+        cl->job = job;
 }
 
 void

src/gallium/drivers/vc4/vc4_cl.h

@@ -29,10 +29,9 @@
 #include "util/u_math.h"
 #include "util/macros.h"
 
-#include "kernel/vc4_packet.h"
-
 struct vc4_bo;
 struct vc4_job;
+struct vc4_cl;
 
 /**
  * Undefined structure, used for typechecking that you're passing the pointers
@@ -46,14 +45,9 @@ struct vc4_cl_reloc {
         uint32_t offset;
 };
 
-/* We don't call anything that packs a reloc yet, so don't implement it. */
+static inline void cl_pack_emit_reloc(struct vc4_cl *cl, const struct vc4_cl_reloc *);
-static inline void cl_pack_emit_reloc(void *cl, const struct vc4_cl_reloc *reloc)
-{
-        abort();
-}
 
-/* We don't use the data arg yet */
+#define __gen_user_data struct vc4_cl
-#define __gen_user_data void
 #define __gen_address_type struct vc4_cl_reloc
 #define __gen_address_offset(reloc) ((reloc)->offset)
 #define __gen_emit_reloc cl_pack_emit_reloc
@@ -63,6 +57,7 @@ static inline void cl_pack_emit_reloc(void *cl, const struct vc4_cl_reloc *reloc
 
 struct vc4_cl {
         void *base;
+        struct vc4_job *job;
         struct vc4_cl_out *next;
         struct vc4_cl_out *reloc_next;
         uint32_t size;
@@ -71,7 +66,7 @@ struct vc4_cl {
 #endif
 };
 
-void vc4_init_cl(void *mem_ctx, struct vc4_cl *cl);
+void vc4_init_cl(struct vc4_job *job, struct vc4_cl *cl);
 void vc4_reset_cl(struct vc4_cl *cl);
 void vc4_dump_cl(void *cl, uint32_t size, bool is_render);
 uint32_t vc4_gem_hindex(struct vc4_job *job, struct vc4_bo *bo);
@@ -224,6 +219,19 @@ cl_aligned_reloc(struct vc4_job *job, struct vc4_cl *cl,
         cl_aligned_u32(cl_out, offset);
 }
 
+/**
+ * Reference to a BO with its associated offset, used in the pack process.
+ */
+static inline struct vc4_cl_reloc
+cl_address(struct vc4_bo *bo, uint32_t offset)
+{
+        struct vc4_cl_reloc reloc = {
+                .bo = bo,
+                .offset = offset,
+        };
+        return reloc;
+}
+
 void cl_ensure_space(struct vc4_cl *cl, uint32_t size);
 
 #define cl_packet_header(packet) V3D21_ ## packet ## _header
@@ -271,4 +279,23 @@ cl_get_emit_space(struct vc4_cl_out **cl, size_t size)
                 _loop_terminate = NULL;                          \
         }))                                                      \
 
+/**
+ * Helper function called by the XML-generated pack functions for filling in
+ * an address field in shader records.
+ *
+ * Relocations for shader recs and texturing involve the packet (or uniforms
+ * stream) being preceded by the handles to the BOs, and the offset within the
+ * BO being in the stream (the output of this function).
+ */
+static inline void
+cl_pack_emit_reloc(struct vc4_cl *cl, const struct vc4_cl_reloc *reloc)
+{
+        *(uint32_t *)cl->reloc_next = vc4_gem_hindex(cl->job, reloc->bo);
+        cl_advance(&cl->reloc_next, 4);
+
+#ifdef DEBUG
+        cl->reloc_count--;
+#endif
+}
+
 #endif /* VC4_CL_H */

src/gallium/drivers/vc4/vc4_draw.c

@@ -142,37 +142,42 @@ vc4_emit_gl_shader_state(struct vc4_context *vc4,
          * we emit a dummy read.
          */
         uint32_t num_elements_emit = MAX2(vtx->num_elements, 1);
+
         /* Emit the shader record. */
-        struct vc4_cl_out *shader_rec =
+        cl_start_shader_reloc(&job->shader_rec, 3 + num_elements_emit);
-                cl_start_shader_reloc(&job->shader_rec, 3 + num_elements_emit);
-        /* VC4_DIRTY_PRIM_MODE | VC4_DIRTY_RASTERIZER */
-        cl_u16(&shader_rec,
-               VC4_SHADER_FLAG_ENABLE_CLIPPING |
-               (vc4->prog.fs->fs_threaded ?
-                0 : VC4_SHADER_FLAG_FS_SINGLE_THREAD) |
-               ((info->mode == PIPE_PRIM_POINTS &&
-                 vc4->rasterizer->base.point_size_per_vertex) ?
-                VC4_SHADER_FLAG_VS_POINT_SIZE : 0));
 
-        /* VC4_DIRTY_COMPILED_FS */
+        cl_emit(&job->shader_rec, SHADER_RECORD, rec) {
-        cl_u8(&shader_rec, 0); /* fs num uniforms (unused) */
+                rec.enable_clipping = true;
-        cl_u8(&shader_rec, vc4->prog.fs->num_inputs);
-        cl_reloc(job, &job->shader_rec, &shader_rec, vc4->prog.fs->bo, 0);
-        cl_u32(&shader_rec, 0); /* UBO offset written by kernel */
 
-        /* VC4_DIRTY_COMPILED_VS */
+                /* VC4_DIRTY_COMPILED_FS */
-        cl_u16(&shader_rec, 0); /* vs num uniforms */
+                rec.fragment_shader_is_single_threaded =
-        cl_u8(&shader_rec, vc4->prog.vs->vattrs_live);
+                        !vc4->prog.fs->fs_threaded;
-        cl_u8(&shader_rec, vc4->prog.vs->vattr_offsets[8]);
-        cl_reloc(job, &job->shader_rec, &shader_rec, vc4->prog.vs->bo, 0);
-        cl_u32(&shader_rec, 0); /* UBO offset written by kernel */
 
-        /* VC4_DIRTY_COMPILED_CS */
+                /* VC4_DIRTY_PRIM_MODE | VC4_DIRTY_RASTERIZER */
-        cl_u16(&shader_rec, 0); /* cs num uniforms */
+                rec.point_size_included_in_shaded_vertex_data =
-        cl_u8(&shader_rec, vc4->prog.cs->vattrs_live);
+                         (info->mode == PIPE_PRIM_POINTS &&
-        cl_u8(&shader_rec, vc4->prog.cs->vattr_offsets[8]);
+                          vc4->rasterizer->base.point_size_per_vertex);
-        cl_reloc(job, &job->shader_rec, &shader_rec, vc4->prog.cs->bo, 0);
+
-        cl_u32(&shader_rec, 0); /* UBO offset written by kernel */
+                /* VC4_DIRTY_COMPILED_FS */
+                rec.fragment_shader_number_of_varyings =
+                        vc4->prog.fs->num_inputs;
+                rec.fragment_shader_code_address =
+                        cl_address(vc4->prog.fs->bo, 0);
+
+                rec.coordinate_shader_attribute_array_select_bits =
+                         vc4->prog.cs->vattrs_live;
+                rec.coordinate_shader_total_attributes_size =
+                         vc4->prog.cs->vattr_offsets[8];
+                rec.coordinate_shader_code_address =
+                        cl_address(vc4->prog.cs->bo, 0);
+
+                rec.vertex_shader_attribute_array_select_bits =
+                         vc4->prog.vs->vattrs_live;
+                rec.vertex_shader_total_attributes_size =
+                         vc4->prog.vs->vattr_offsets[8];
+                rec.vertex_shader_code_address =
+                        cl_address(vc4->prog.vs->bo, 0);
+        };
 
         uint32_t max_index = 0xffff;
         for (int i = 0; i < vtx->num_elements; i++) {
@@ -189,11 +194,15 @@ vc4_emit_gl_shader_state(struct vc4_context *vc4,
                 uint32_t elem_size =
                         util_format_get_blocksize(elem->src_format);
 
-                cl_reloc(job, &job->shader_rec, &shader_rec, rsc->bo, offset);
+                cl_emit(&job->shader_rec, ATTRIBUTE_RECORD, attr) {
-                cl_u8(&shader_rec, elem_size - 1);
+                        attr.address = cl_address(rsc->bo, offset);
-                cl_u8(&shader_rec, vb->stride);
+                        attr.number_of_bytes_minus_1 = elem_size - 1;
-                cl_u8(&shader_rec, vc4->prog.vs->vattr_offsets[i]);
+                        attr.stride = vb->stride;
-                cl_u8(&shader_rec, vc4->prog.cs->vattr_offsets[i]);
+                        attr.coordinate_shader_vpm_offset =
+                                vc4->prog.cs->vattr_offsets[i];
+                        attr.vertex_shader_vpm_offset =
+                                vc4->prog.vs->vattr_offsets[i];
+                }
 
                 if (vb->stride > 0) {
                         max_index = MIN2(max_index,
@@ -204,14 +213,15 @@ vc4_emit_gl_shader_state(struct vc4_context *vc4,
         if (vtx->num_elements == 0) {
                 assert(num_elements_emit == 1);
                 struct vc4_bo *bo = vc4_bo_alloc(vc4->screen, 4096, "scratch VBO");
-                cl_reloc(job, &job->shader_rec, &shader_rec, bo, 0);
+
-                cl_u8(&shader_rec, 16 - 1); /* element size */
+                cl_emit(&job->shader_rec, ATTRIBUTE_RECORD, attr) {
-                cl_u8(&shader_rec, 0); /* stride */
+                        attr.address = cl_address(bo, 0);
-                cl_u8(&shader_rec, 0); /* VS VPM offset */
+                        attr.number_of_bytes_minus_1 = 16 - 1;
-                cl_u8(&shader_rec, 0); /* CS VPM offset */
+                        attr.stride = 0;
-                vc4_bo_unreference(&bo);
+                        attr.coordinate_shader_vpm_offset = 0;
+                        attr.vertex_shader_vpm_offset = 0;
+                }
         }
-        cl_end(&job->shader_rec, shader_rec);
 
         cl_emit(&job->bcl, GL_SHADER_STATE, shader_state) {
                 /* Note that number of attributes == 0 in the packet means 8