nir/linker: Add the start of a pure-NIR linker for XFB

v2: ignore names on purpose, for consistency with other places where
    we are doing the same (Alejandro)

v3: changes proposed by Timothy Arceri, implemented by Alejandro Piñeiro:
   * Remove redundant 'struct active_xfb_varying'
   * Update several comments, including spec quotes if needed
   * Rename struct 'active_xfb_varying_array' to 'active_xfb_varyings'
   * Rename variable 'array' to 'active_varyings'
   * Replace one if condition for an assert (<MAX_FEEDBACK_BUFFERS)
   * Remove BufferMode initialization (was already done)

v4: simplify output pointer handling (Timothy)

Signed-off-by: Neil Roberts <[email protected]>
Signed-off-by: Alejandro Piñeiro <[email protected]>

Reviewed-by: Timothy Arceri <[email protected]>

1 files changed, 316 insertions, 0 deletions

diff --git a/src/compiler/glsl/gl_nir_link_xfb.c b/src/compiler/glsl/gl_nir_link_xfb.c
new file mode 100644
index 00000000000..bcef1e1863d
--- /dev/null
+++ b/src/compiler/glsl/gl_nir_link_xfb.c
@@ -0,0 +1,316 @@
+/*
+ * Copyright © 2018 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "nir.h"
+#include "gl_nir_linker.h"
+#include "ir_uniform.h" /* for gl_uniform_storage */
+#include "linker_util.h"
+#include "main/context.h"
+
+/*
+ * This file does the linking of GLSL transform feedback using NIR.
+ *
+ * Note: This linking pass is currently tailored for ARB_gl_spirv needs and
+ * particularities.
+ */
+
+struct active_xfb_buffer {
+   GLuint stride;
+   GLuint num_varyings;
+};
+
+struct active_xfb_varyings {
+   unsigned num_varyings;
+   unsigned num_outputs;
+   unsigned buffer_size;
+   struct nir_variable **varyings;
+   struct active_xfb_buffer buffers[MAX_FEEDBACK_BUFFERS];
+};
+
+static unsigned
+get_num_outputs(nir_variable *var)
+{
+   return glsl_count_attribute_slots(var->type,
+                                     false /* is_vertex_input */);
+}
+
+static void
+add_xfb_varying(struct active_xfb_varyings *active_varyings,
+                nir_variable *var)
+{
+   if (active_varyings->num_varyings >= active_varyings->buffer_size) {
+      if (active_varyings->buffer_size == 0)
+         active_varyings->buffer_size = 1;
+      else
+         active_varyings->buffer_size *= 2;
+
+      active_varyings->varyings = realloc(active_varyings->varyings,
+                                          sizeof(nir_variable*) *
+                                          active_varyings->buffer_size);
+   }
+
+   active_varyings->varyings[active_varyings->num_varyings++] = var;
+
+   active_varyings->num_outputs += get_num_outputs(var);
+}
+
+static int
+cmp_xfb_offset(const void *x_generic, const void *y_generic)
+{
+   const nir_variable *const *x = x_generic;
+   const nir_variable *const *y = y_generic;
+
+   if ((*x)->data.xfb_buffer != (*y)->data.xfb_buffer)
+      return (*x)->data.xfb_buffer - (*y)->data.xfb_buffer;
+   return (*x)->data.offset - (*y)->data.offset;
+}
+
+static void
+get_active_xfb_varyings(struct gl_shader_program *prog,
+                        struct active_xfb_varyings *active_varyings)
+{
+   for (unsigned i = 0; i < MESA_SHADER_STAGES; ++i) {
+      struct gl_linked_shader *sh = prog->_LinkedShaders[i];
+      if (sh == NULL)
+         continue;
+
+      nir_shader *nir = sh->Program->nir;
+
+      nir_foreach_variable(var, &nir->outputs) {
+         if (var->data.explicit_xfb_buffer &&
+             var->data.explicit_xfb_stride) {
+            assert(var->data.xfb_buffer < MAX_FEEDBACK_BUFFERS);
+            active_varyings->buffers[var->data.xfb_buffer].stride =
+               var->data.xfb_stride;
+         }
+
+         if (!var->data.explicit_xfb_buffer ||
+             !var->data.explicit_offset)
+            continue;
+
+         active_varyings->buffers[var->data.xfb_buffer].num_varyings++;
+
+         add_xfb_varying(active_varyings, var);
+      }
+   }
+
+   /* The xfb_offset qualifier does not have to be used in increasing order
+    * however some drivers expect to receive the list of transform feedback
+    * declarations in order so sort it now for convenience.
+    */
+   qsort(active_varyings->varyings,
+         active_varyings->num_varyings,
+         sizeof(*active_varyings->varyings),
+         cmp_xfb_offset);
+}
+
+static unsigned
+add_varying_outputs(nir_variable *var,
+                    const struct glsl_type *type,
+                    unsigned location_offset,
+                    unsigned dest_offset,
+                    struct gl_transform_feedback_output *output)
+{
+   unsigned num_outputs = 0;
+
+   if (glsl_type_is_array(type) || glsl_type_is_matrix(type)) {
+      unsigned length = glsl_get_length(type);
+      const struct glsl_type *child_type = glsl_get_array_element(type);
+      unsigned component_slots = glsl_get_component_slots(child_type);
+
+      for (unsigned i = 0; i < length; i++) {
+         unsigned child_outputs = add_varying_outputs(var,
+                                                      child_type,
+                                                      location_offset,
+                                                      dest_offset,
+                                                      output + num_outputs);
+         num_outputs += child_outputs;
+         location_offset += child_outputs;
+         dest_offset += component_slots;
+      }
+   } else if (glsl_type_is_struct(type)) {
+      unsigned length = glsl_get_length(type);
+      for (unsigned i = 0; i < length; i++) {
+         const struct glsl_type *child_type = glsl_get_struct_field(type, i);
+         unsigned child_outputs = add_varying_outputs(var,
+                                                      child_type,
+                                                      location_offset,
+                                                      dest_offset,
+                                                      output + num_outputs);
+         num_outputs += child_outputs;
+         location_offset += child_outputs;
+         dest_offset += glsl_get_component_slots(child_type);
+      }
+   } else {
+      unsigned location = var->data.location + location_offset;
+      unsigned location_frac = var->data.location_frac;
+      unsigned num_components = glsl_get_component_slots(type);
+
+      while (num_components > 0) {
+         unsigned output_size = MIN2(num_components, 4 - location_frac);
+
+         output->OutputRegister = location;
+         output->OutputBuffer = var->data.xfb_buffer;
+         output->NumComponents = output_size;
+         output->StreamId = var->data.stream;
+         output->DstOffset = var->data.offset / 4 + dest_offset;
+         output->ComponentOffset = location_frac;
+
+         dest_offset += output_size;
+         num_components -= output_size;
+         num_outputs++;
+         output++;
+         location++;
+         location_frac = 0;
+      }
+   }
+
+   return num_outputs;
+}
+
+void
+gl_nir_link_assign_xfb_resources(struct gl_context *ctx,
+                                 struct gl_shader_program *prog)
+{
+   /*
+    * From ARB_gl_spirv spec:
+    *
+    *    "- If the *Xfb* Execution Mode is set, any output variable that is at
+    *       least partially captured:
+    *       * must be decorated with an *XfbBuffer*, declaring the capturing buffer
+    *       * must have at least one captured output variable in the capturing
+    *         buffer decorated with an *XfbStride* (and all such *XfbStride* values
+    *         for the capturing buffer must be equal)
+    *     - If the *Xfb* Execution Mode is set, any captured output:
+    *       * must be a non-structure decorated with *Offset* or a member of a
+    *         structure whose type member is decorated with *Offset*"
+    *
+    * Note the "must be", meaning that explicit buffer, offset and stride are
+    * mandatory. So as this is intended to work with SPIR-V shaders we don't
+    * need to calculate the offset or the stride.
+    */
+
+   struct gl_program *xfb_prog = prog->last_vert_prog;
+
+   if (xfb_prog == NULL)
+      return;
+
+   /* free existing varyings, if any */
+   for (unsigned i = 0; i < prog->TransformFeedback.NumVarying; i++)
+      free(prog->TransformFeedback.VaryingNames[i]);
+   free(prog->TransformFeedback.VaryingNames);
+
+   struct active_xfb_varyings active_varyings = { 0 };
+
+   get_active_xfb_varyings(prog, &active_varyings);
+
+   for (unsigned buf = 0; buf < MAX_FEEDBACK_BUFFERS; buf++)
+      prog->TransformFeedback.BufferStride[buf] = active_varyings.buffers[buf].stride;
+
+   prog->TransformFeedback.NumVarying = active_varyings.num_varyings;
+   prog->TransformFeedback.VaryingNames =
+      malloc(sizeof(GLchar *) * active_varyings.num_varyings);
+
+   struct gl_transform_feedback_info *linked_xfb =
+      rzalloc(xfb_prog, struct gl_transform_feedback_info);
+   xfb_prog->sh.LinkedTransformFeedback = linked_xfb;
+
+   linked_xfb->Outputs =
+      rzalloc_array(xfb_prog,
+                    struct gl_transform_feedback_output,
+                    active_varyings.num_outputs);
+   linked_xfb->NumOutputs = active_varyings.num_outputs;
+
+   linked_xfb->Varyings =
+      rzalloc_array(xfb_prog,
+                    struct gl_transform_feedback_varying_info,
+                    active_varyings.num_varyings);
+   linked_xfb->NumVarying = active_varyings.num_varyings;
+
+   struct gl_transform_feedback_output *output = linked_xfb->Outputs;
+   for (unsigned i = 0; i < active_varyings.num_varyings; i++) {
+      struct nir_variable *var = active_varyings.varyings[i];
+
+      /* From ARB_gl_spirv spec:
+       *
+       *    "19. How should the program interface query operations behave for
+       *         program objects created from SPIR-V shaders?
+       *
+       *     DISCUSSION: we previously said we didn't need reflection to work
+       *     for SPIR-V shaders (at least for the first version), however we
+       *     are left with specifying how it should "not work". The primary
+       *     issue is that SPIR-V binaries are not required to have names
+       *     associated with variables. They can be associated in debug
+       *     information, but there is no requirement for that to be present,
+       *     and it should not be relied upon."
+       *
+       *     Options:"
+       *
+       *     <skip>
+       *
+       *     "RESOLVED.  Pick (c), but also allow debug names to be returned
+       *      if an implementation wants to."
+       *
+       * So names are considered optional debug info, so the linker needs to
+       * work without them, and returning them is optional. For simplicity at
+       * this point we are ignoring names
+       */
+      prog->TransformFeedback.VaryingNames[i] = NULL;
+
+      unsigned varying_outputs = add_varying_outputs(var,
+                                                     var->type,
+                                                     0, /* location_offset */
+                                                     0, /* dest_offset */
+                                                     output);
+      assert(varying_outputs == get_num_outputs(var));
+      output = output + varying_outputs;
+
+      struct gl_transform_feedback_varying_info *varying =
+         linked_xfb->Varyings + i;
+
+      /* ARB_gl_spirv: see above. */
+      varying->Name = NULL;
+      varying->Type = glsl_get_gl_type(var->type);
+      varying->BufferIndex = var->data.xfb_buffer;
+      varying->Size = glsl_get_length(var->type);
+      varying->Offset = var->data.offset;
+   }
+
+   /* Make sure MaxTransformFeedbackBuffers is <= 32 so the bitmask for
+    * tracking the number of buffers doesn't overflow.
+    */
+   unsigned buffers = 0;
+   assert(ctx->Const.MaxTransformFeedbackBuffers <= sizeof(buffers) * 8);
+
+   for (unsigned buf = 0; buf < MAX_FEEDBACK_BUFFERS; buf++) {
+      if (active_varyings.buffers[buf].stride > 0) {
+         linked_xfb->Buffers[buf].Stride = active_varyings.buffers[buf].stride / 4;
+         linked_xfb->Buffers[buf].NumVaryings = active_varyings.buffers[buf].num_varyings;
+         buffers |= 1 << buf;
+      }
+   }
+
+   linked_xfb->ActiveBuffers = buffers;
+
+   free(active_varyings.varyings);
+}