Subversion Repositories Kolibri OS

/*

 * Copyright (c) 2013 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.

 */

/**

 * \file lower_named_interface_blocks.cpp

 *

 * This lowering pass converts all interface blocks with instance names

 * into interface blocks without an instance name.

 *

 * For example, the following shader:

 *

 *   out block {

 *     float block_var;

 *   } inst_name;

 *

 *   main()

 *   {

 *     inst_name.block_var = 0.0;

 *   }

 *

 * Is rewritten to:

 *

 *   out block {

 *     float block_var;

 *   };

 *

 *   main()

 *   {

 *     block_var = 0.0;

 *   }

 *

 * This takes place after the shader code has already been verified with

 * the interface name in place.

 *

 * The linking phase will use the interface block name rather than the

 * interface's instance name when linking interfaces.

 *

 * This modification to the ir allows our currently existing dead code

 * elimination to work with interface blocks without changes.

 */

#include "glsl_symbol_table.h"

#include "ir.h"

#include "ir_optimization.h"

#include "ir_rvalue_visitor.h"

#include "program/hash_table.h"

class flatten_named_interface_blocks_declarations : public ir_rvalue_visitor

{

public:

   void * const mem_ctx;

   hash_table *interface_namespace;

   flatten_named_interface_blocks_declarations(void *mem_ctx)

      : mem_ctx(mem_ctx),

        interface_namespace(NULL)

   {

   }

   void run(exec_list *instructions);

   virtual ir_visitor_status visit_leave(ir_assignment *);

   virtual void handle_rvalue(ir_rvalue **rvalue);

};

void

flatten_named_interface_blocks_declarations::run(exec_list *instructions)

{

   interface_namespace = hash_table_ctor(0, hash_table_string_hash,

                                         hash_table_string_compare);

   /* First pass: adjust instance block variables with an instance name

    * to not have an instance name.

    *

    * The interface block variables are stored in the interface_namespace

    * hash table so they can be used in the second pass.

    */

   foreach_list_safe(node, instructions) {

      ir_variable *var = ((ir_instruction *) node)->as_variable();

      if (!var || !var->is_interface_instance())

         continue;

      /* It should be possible to handle uniforms during this pass,

       * but, this will require changes to the other uniform block

       * support code.

       */

      if (var->mode == ir_var_uniform)

         continue;

      const glsl_type * iface_t = var->type;

      const glsl_type * array_t = NULL;

      exec_node *insert_pos = var;

      if (iface_t->is_array()) {

         array_t = iface_t;

         iface_t = array_t->fields.array;

      }

      assert (iface_t->is_interface());

      for (unsigned i = 0; i < iface_t->length; i++) {

         const char * field_name = iface_t->fields.structure[i].name;

         char *iface_field_name =

            ralloc_asprintf(mem_ctx, "%s.%s",

                            iface_t->name, field_name);

         ir_variable *found_var =

            (ir_variable *) hash_table_find(interface_namespace,

                                            iface_field_name);

         if (!found_var) {

            ir_variable *new_var;

            if (array_t == NULL) {

               char *var_name =

                  ralloc_strdup(mem_ctx, iface_t->fields.structure[i].name);

               new_var =

                  new(mem_ctx) ir_variable(iface_t->fields.structure[i].type,

                                           var_name,

                                           (ir_variable_mode) var->mode);

            } else {

               const glsl_type *new_array_type =

                  glsl_type::get_array_instance(

                     iface_t->fields.structure[i].type,

                     array_t->length);

               char *var_name =

                  ralloc_asprintf(mem_ctx, "%s[%d]",

                                  iface_t->fields.structure[i].name,

                                  array_t->length);

               new_var =

                  new(mem_ctx) ir_variable(new_array_type,

                                           var_name,

                                           (ir_variable_mode) var->mode);

            }

            new_var->interface_type = iface_t;

            hash_table_insert(interface_namespace, new_var,

                              iface_field_name);

            insert_pos->insert_after(new_var);

            insert_pos = new_var;

         }

      }

      var->remove();

   }

   /* Second pass: visit all ir_dereference_record instances, and if they

    * reference an interface block, then flatten the refererence out.

    */

   visit_list_elements(this, instructions);

   hash_table_dtor(interface_namespace);

   interface_namespace = NULL;

}

ir_visitor_status

flatten_named_interface_blocks_declarations::visit_leave(ir_assignment *ir)

{

   ir_dereference_record *lhs_rec = ir->lhs->as_dereference_record();

   if (lhs_rec) {

      ir_rvalue *lhs_rec_tmp = lhs_rec;

      handle_rvalue(&lhs_rec_tmp);

      if (lhs_rec_tmp != lhs_rec) {

         ir->set_lhs(lhs_rec_tmp);

      }

   }

   return rvalue_visit(ir);

}

void

flatten_named_interface_blocks_declarations::handle_rvalue(ir_rvalue **rvalue)

{

   if (*rvalue == NULL)

      return;

   ir_dereference_record *ir = (*rvalue)->as_dereference_record();

   if (ir == NULL)

      return;

   ir_variable *var = ir->variable_referenced();

   if (var == NULL)

      return;

   if (!var->is_interface_instance())

      return;

   /* It should be possible to handle uniforms during this pass,

    * but, this will require changes to the other uniform block

    * support code.

    */

   if (var->mode == ir_var_uniform)

      return;

   if (var->interface_type != NULL) {

      char *iface_field_name =

         ralloc_asprintf(mem_ctx, "%s.%s", var->interface_type->name,

                         ir->field);

      /* Find the variable in the set of flattened interface blocks */

      ir_variable *found_var =

         (ir_variable *) hash_table_find(interface_namespace,

                                         iface_field_name);

      assert(found_var);

      ir_dereference_variable *deref_var =

         new(mem_ctx) ir_dereference_variable(found_var);

      ir_dereference_array *deref_array =

         ir->record->as_dereference_array();

      if (deref_array != NULL) {

         *rvalue =

            new(mem_ctx) ir_dereference_array(deref_var,

                                              deref_array->array_index);

      } else {

         *rvalue = deref_var;

      }

   }

}

void

lower_named_interface_blocks(void *mem_ctx, gl_shader *shader)

{

   flatten_named_interface_blocks_declarations v_decl(mem_ctx);

   v_decl.run(shader->ir);

}