path: root/src/compiler/glsl/gl_nir_link_xfb.c

/*
 * 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);
}