tor-browser

ReplaceArrayOfMatrixVarying.cpp (6272B)

---

//
// Copyright 2020 The ANGLE Project Authors. All rights reserved. Use of this
// source code is governed by a BSD-style license that can be found in the
// LICENSE file.
//
// ReplaceArrayOfMatrixVarying: Find any references to array of matrices varying
// and replace it with array of vectors.
//

#include "compiler/translator/tree_util/ReplaceArrayOfMatrixVarying.h"

#include <vector>

#include "common/bitset_utils.h"
#include "common/debug.h"
#include "common/utilities.h"
#include "compiler/translator/Compiler.h"
#include "compiler/translator/SymbolTable.h"
#include "compiler/translator/tree_util/BuiltIn.h"
#include "compiler/translator/tree_util/FindMain.h"
#include "compiler/translator/tree_util/IntermNode_util.h"
#include "compiler/translator/tree_util/IntermTraverse.h"
#include "compiler/translator/tree_util/ReplaceVariable.h"
#include "compiler/translator/tree_util/RunAtTheEndOfShader.h"
#include "compiler/translator/util.h"

namespace sh
{

// We create two variables to replace the given varying:
// - The new varying which is an array of vectors to be used at input/ouput only.
// - The new global variable which is a same type as given variable, to temporarily be used
// as replacements for assignments, arithmetic ops and so on. During input/ouput phrase, this temp
// variable will be copied from/to the array of vectors variable above.
// NOTE(hqle): Consider eliminating the need for using temp variable.

namespace
{
class CollectVaryingTraverser : public TIntermTraverser
{
 public:
   CollectVaryingTraverser(std::vector<const TVariable *> *varyingsOut)
       : TIntermTraverser(true, false, false), mVaryingsOut(varyingsOut)
   {}

   bool visitDeclaration(Visit visit, TIntermDeclaration *node) override
   {
       const TIntermSequence &sequence = *(node->getSequence());

       if (sequence.size() != 1)
       {
           return false;
       }

       TIntermTyped *variableType = sequence.front()->getAsTyped();
       if (!variableType || !IsVarying(variableType->getQualifier()) ||
           !variableType->isMatrix() || !variableType->isArray())
       {
           return false;
       }

       TIntermSymbol *variableSymbol = variableType->getAsSymbolNode();
       if (!variableSymbol)
       {
           return false;
       }

       mVaryingsOut->push_back(&variableSymbol->variable());

       return false;
   }

 private:
   std::vector<const TVariable *> *mVaryingsOut;
};
}  // namespace

[[nodiscard]] bool ReplaceArrayOfMatrixVarying(TCompiler *compiler,
                                              TIntermBlock *root,
                                              TSymbolTable *symbolTable,
                                              const TVariable *varying)
{
   const TType &type = varying->getType();

   // Create global variable to temporarily acts as the given variable in places such as
   // arithmetic, assignments an so on.
   TType *tmpReplacementType = new TType(type);
   tmpReplacementType->setQualifier(EvqGlobal);

   TVariable *tempReplaceVar = new TVariable(
       symbolTable, ImmutableString(std::string("ANGLE_AOM_Temp_") + varying->name().data()),
       tmpReplacementType, SymbolType::AngleInternal);

   if (!ReplaceVariable(compiler, root, varying, tempReplaceVar))
   {
       return false;
   }

   // Create array of vectors type
   TType *varyingReplaceType = new TType(type);
   varyingReplaceType->toMatrixColumnType();
   varyingReplaceType->toArrayElementType();
   varyingReplaceType->makeArray(type.getCols() * type.getOutermostArraySize());

   TVariable *varyingReplaceVar =
       new TVariable(symbolTable, varying->name(), varyingReplaceType, SymbolType::UserDefined);

   TIntermSymbol *varyingReplaceDeclarator = new TIntermSymbol(varyingReplaceVar);
   TIntermDeclaration *varyingReplaceDecl  = new TIntermDeclaration;
   varyingReplaceDecl->appendDeclarator(varyingReplaceDeclarator);
   root->insertStatement(0, varyingReplaceDecl);

   // Copy from/to the temp variable
   TIntermBlock *reassignBlock         = new TIntermBlock;
   TIntermSymbol *tempReplaceSymbol    = new TIntermSymbol(tempReplaceVar);
   TIntermSymbol *varyingReplaceSymbol = new TIntermSymbol(varyingReplaceVar);
   bool isInput                        = IsVaryingIn(type.getQualifier());

   for (unsigned int i = 0; i < type.getOutermostArraySize(); ++i)
   {
       TIntermBinary *tempMatrixIndexed =
           new TIntermBinary(EOpIndexDirect, tempReplaceSymbol->deepCopy(), CreateIndexNode(i));
       for (uint8_t col = 0; col < type.getCols(); ++col)
       {

           TIntermBinary *tempMatrixColIndexed = new TIntermBinary(
               EOpIndexDirect, tempMatrixIndexed->deepCopy(), CreateIndexNode(col));
           TIntermBinary *vectorIndexed =
               new TIntermBinary(EOpIndexDirect, varyingReplaceSymbol->deepCopy(),
                                 CreateIndexNode(i * type.getCols() + col));
           TIntermBinary *assignment;
           if (isInput)
           {
               assignment = new TIntermBinary(EOpAssign, tempMatrixColIndexed, vectorIndexed);
           }
           else
           {
               assignment = new TIntermBinary(EOpAssign, vectorIndexed, tempMatrixColIndexed);
           }
           reassignBlock->appendStatement(assignment);
       }
   }

   if (isInput)
   {
       TIntermFunctionDefinition *main = FindMain(root);
       main->getBody()->insertStatement(0, reassignBlock);
       return compiler->validateAST(root);
   }
   else
   {
       return RunAtTheEndOfShader(compiler, root, reassignBlock, symbolTable);
   }
}

[[nodiscard]] bool ReplaceArrayOfMatrixVaryings(TCompiler *compiler,
                                               TIntermBlock *root,
                                               TSymbolTable *symbolTable)
{
   std::vector<const TVariable *> arrayOfMatrixVars;
   CollectVaryingTraverser varCollector(&arrayOfMatrixVars);
   root->traverse(&varCollector);

   for (const TVariable *var : arrayOfMatrixVars)
   {
       if (!ReplaceArrayOfMatrixVarying(compiler, root, symbolTable, var))
       {
           return false;
       }
   }

   return true;
}

}  // namespace sh