tor-browser

RewriteArrayOfArrayOfOpaqueUniforms.cpp (12547B)

---

//
// Copyright 2019 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.
//
// RewriteAtomicCounters: Emulate atomic counter buffers with storage buffers.
//

#include "compiler/translator/tree_ops/RewriteArrayOfArrayOfOpaqueUniforms.h"

#include "compiler/translator/Compiler.h"
#include "compiler/translator/ImmutableStringBuilder.h"
#include "compiler/translator/SymbolTable.h"
#include "compiler/translator/tree_util/IntermNode_util.h"
#include "compiler/translator/tree_util/IntermTraverse.h"
#include "compiler/translator/tree_util/ReplaceVariable.h"

namespace sh
{
namespace
{
struct UniformData
{
   // Corresponding to an array of array of opaque uniform variable, this is the flattened variable
   // that is replacing it.
   const TVariable *flattened;
   // Assume a general case of array declaration with N dimensions:
   //
   //     uniform type u[Dn]..[D2][D1];
   //
   // Let's define
   //
   //     Pn = D(n-1)*...*D2*D1
   //
   // In that case, we have:
   //
   //     u[In]         = ac + In*Pn
   //     u[In][I(n-1)] = ac + In*Pn + I(n-1)*P(n-1)
   //     u[In]...[Ii]  = ac + In*Pn + ... + Ii*Pi
   //
   // This array contains Pi.  Note that the like TType::mArraySizes, the last element is the
   // outermost dimension.  Element 0 is necessarily 1.
   TVector<unsigned int> mSubArraySizes;
};

using UniformMap = angle::HashMap<const TVariable *, UniformData>;

TIntermTyped *RewriteArrayOfArraySubscriptExpression(TCompiler *compiler,
                                                    TIntermBinary *node,
                                                    const UniformMap &uniformMap);

// Given an expression, this traverser calculates a new expression where array of array of opaque
// uniforms are replaced with their flattened ones.  In particular, this is run on the right node of
// EOpIndexIndirect binary nodes, so that the expression in the index gets a chance to go through
// this transformation.
class RewriteExpressionTraverser final : public TIntermTraverser
{
 public:
   explicit RewriteExpressionTraverser(TCompiler *compiler, const UniformMap &uniformMap)
       : TIntermTraverser(true, false, false), mCompiler(compiler), mUniformMap(uniformMap)
   {}

   bool visitBinary(Visit visit, TIntermBinary *node) override
   {
       TIntermTyped *rewritten =
           RewriteArrayOfArraySubscriptExpression(mCompiler, node, mUniformMap);
       if (rewritten == nullptr)
       {
           return true;
       }

       queueReplacement(rewritten, OriginalNode::IS_DROPPED);

       // Don't iterate as the expression is rewritten.
       return false;
   }

   void visitSymbol(TIntermSymbol *node) override
   {
       // We cannot reach here for an opaque uniform that is being replaced.  visitBinary should
       // have taken care of it.
       ASSERT(!IsOpaqueType(node->getType().getBasicType()) ||
              mUniformMap.find(&node->variable()) == mUniformMap.end());
   }

 private:
   TCompiler *mCompiler;

   const UniformMap &mUniformMap;
};

// Rewrite the index of an EOpIndexIndirect expression.  The root can never need replacing, because
// it cannot be an opaque uniform itself.
void RewriteIndexExpression(TCompiler *compiler,
                           TIntermTyped *expression,
                           const UniformMap &uniformMap)
{
   RewriteExpressionTraverser traverser(compiler, uniformMap);
   expression->traverse(&traverser);
   bool valid = traverser.updateTree(compiler, expression);
   ASSERT(valid);
}

// Given an expression such as the following:
//
//                                              EOpIndex(In)Direct (opaque uniform)
//                                                    /           \
//                                            EOpIndex(In)Direct   I1
//                                                  /           \
//                                                ...            I2
//                                            /
//                                    EOpIndex(In)Direct
//                                          /           \
//                                      uniform          In
//
// produces:
//
//          EOpIndex(In)Direct
//            /        \
//        uniform    In*Pn + ... + I2*P2 + I1*P1
//
TIntermTyped *RewriteArrayOfArraySubscriptExpression(TCompiler *compiler,
                                                    TIntermBinary *node,
                                                    const UniformMap &uniformMap)
{
   // Only interested in opaque uniforms.
   if (!IsOpaqueType(node->getType().getBasicType()))
   {
       return nullptr;
   }

   TIntermSymbol *opaqueUniform = nullptr;

   // Iterate once and find the opaque uniform that's being indexed.
   TIntermBinary *iter = node;
   while (opaqueUniform == nullptr)
   {
       ASSERT(iter->getOp() == EOpIndexDirect || iter->getOp() == EOpIndexIndirect);

       opaqueUniform = iter->getLeft()->getAsSymbolNode();
       iter          = iter->getLeft()->getAsBinaryNode();
   }

   // If not being replaced, there's nothing to do.
   auto flattenedIter = uniformMap.find(&opaqueUniform->variable());
   if (flattenedIter == uniformMap.end())
   {
       return nullptr;
   }

   const UniformData &data = flattenedIter->second;

   // Iterate again and build the index expression.  The index expression constitutes the sum of
   // the variable indices plus a constant offset calculated from the constant indices.  For
   // example, smplr[1][x][2][y] will have an index of x*P3 + y*P1 + c, where c = (1*P4 + 2*P2).
   unsigned int constantOffset = 0;
   TIntermTyped *variableIndex = nullptr;

   // Since the opaque uniforms are fully subscripted, we know exactly how many EOpIndex* nodes
   // there should be.
   for (size_t dimIndex = 0; dimIndex < data.mSubArraySizes.size(); ++dimIndex)
   {
       ASSERT(node);

       unsigned int subArraySize = data.mSubArraySizes[dimIndex];

       switch (node->getOp())
       {
           case EOpIndexDirect:
               // Accumulate the constant index.
               constantOffset +=
                   node->getRight()->getAsConstantUnion()->getIConst(0) * subArraySize;
               break;
           case EOpIndexIndirect:
           {
               // Run RewriteExpressionTraverser on the right node.  It may itself be an expression
               // with an array of array of opaque uniform inside that needs to be rewritten.
               TIntermTyped *indexExpression = node->getRight();
               RewriteIndexExpression(compiler, indexExpression, uniformMap);

               // Scale and accumulate.
               if (subArraySize != 1)
               {
                   indexExpression =
                       new TIntermBinary(EOpMul, indexExpression, CreateIndexNode(subArraySize));
               }

               if (variableIndex == nullptr)
               {
                   variableIndex = indexExpression;
               }
               else
               {
                   variableIndex = new TIntermBinary(EOpAdd, variableIndex, indexExpression);
               }
               break;
           }
           default:
               UNREACHABLE();
               break;
       }

       node = node->getLeft()->getAsBinaryNode();
   }

   // Add the two accumulated indices together.
   TIntermTyped *index = nullptr;
   if (constantOffset == 0 && variableIndex != nullptr)
   {
       // No constant offset, but there's variable offset.  Take that as offset.
       index = variableIndex;
   }
   else
   {
       // Either the constant offset is non zero, or there's no variable offset (so constant 0
       // should be used).
       index = CreateIndexNode(constantOffset);

       if (variableIndex)
       {
           index = new TIntermBinary(EOpAdd, index, variableIndex);
       }
   }

   // Create an index into the flattened uniform.
   TOperator op = variableIndex ? EOpIndexIndirect : EOpIndexDirect;
   return new TIntermBinary(op, new TIntermSymbol(data.flattened), index);
}

// Traverser that takes:
//
//     uniform sampler/image/atomic_uint u[N][M]..
//
// and transforms it to:
//
//     uniform sampler/image/atomic_uint u[N * M * ..]
//
// MonomorphizeUnsupportedFunctions makes it impossible for this array to be partially
// subscripted, or passed as argument to a function unsubscripted.  This means that every encounter
// of this uniform can be expected to be fully subscripted.
//
class RewriteArrayOfArrayOfOpaqueUniformsTraverser : public TIntermTraverser
{
 public:
   RewriteArrayOfArrayOfOpaqueUniformsTraverser(TCompiler *compiler, TSymbolTable *symbolTable)
       : TIntermTraverser(true, false, false, symbolTable), mCompiler(compiler)
   {}

   bool visitDeclaration(Visit visit, TIntermDeclaration *node) override
   {
       if (!mInGlobalScope)
       {
           return true;
       }

       const TIntermSequence &sequence = *(node->getSequence());

       TIntermTyped *variable = sequence.front()->getAsTyped();
       const TType &type      = variable->getType();
       bool isOpaqueUniform =
           type.getQualifier() == EvqUniform && IsOpaqueType(type.getBasicType());

       // Only interested in array of array of opaque uniforms.
       if (!isOpaqueUniform || !type.isArrayOfArrays())
       {
           return false;
       }

       // Opaque uniforms cannot have initializers, so the declaration must necessarily be a
       // symbol.
       TIntermSymbol *symbol = variable->getAsSymbolNode();
       ASSERT(symbol != nullptr);

       const TVariable *uniformVariable = &symbol->variable();

       // Create an entry in the map.
       ASSERT(mUniformMap.find(uniformVariable) == mUniformMap.end());
       UniformData &data = mUniformMap[uniformVariable];

       // Calculate the accumulated dimension products.  See UniformData::mSubArraySizes.
       const TSpan<const unsigned int> &arraySizes = type.getArraySizes();
       mUniformMap[uniformVariable].mSubArraySizes.resize(arraySizes.size());
       unsigned int runningProduct = 1;
       for (size_t dimension = 0; dimension < arraySizes.size(); ++dimension)
       {
           data.mSubArraySizes[dimension] = runningProduct;
           runningProduct *= arraySizes[dimension];
       }

       // Create a replacement variable with the array flattened.
       TType *newType = new TType(type);
       newType->toArrayBaseType();
       newType->makeArray(runningProduct);

       data.flattened = new TVariable(mSymbolTable, uniformVariable->name(), newType,
                                      uniformVariable->symbolType());

       TIntermDeclaration *decl = new TIntermDeclaration;
       decl->appendDeclarator(new TIntermSymbol(data.flattened));

       queueReplacement(decl, OriginalNode::IS_DROPPED);
       return false;
   }

   bool visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) override
   {
       // As an optimization, don't bother inspecting functions if there aren't any opaque uniforms
       // to replace.
       return !mUniformMap.empty();
   }

   // Same implementation as in RewriteExpressionTraverser.  That traverser cannot replace root.
   bool visitBinary(Visit visit, TIntermBinary *node) override
   {
       TIntermTyped *rewritten =
           RewriteArrayOfArraySubscriptExpression(mCompiler, node, mUniformMap);
       if (rewritten == nullptr)
       {
           return true;
       }

       queueReplacement(rewritten, OriginalNode::IS_DROPPED);

       // Don't iterate as the expression is rewritten.
       return false;
   }

   void visitSymbol(TIntermSymbol *node) override
   {
       ASSERT(!IsOpaqueType(node->getType().getBasicType()) ||
              mUniformMap.find(&node->variable()) == mUniformMap.end());
   }

 private:
   TCompiler *mCompiler;
   UniformMap mUniformMap;
};
}  // anonymous namespace

bool RewriteArrayOfArrayOfOpaqueUniforms(TCompiler *compiler,
                                        TIntermBlock *root,
                                        TSymbolTable *symbolTable)
{
   RewriteArrayOfArrayOfOpaqueUniformsTraverser traverser(compiler, symbolTable);
   root->traverse(&traverser);
   return traverser.updateTree(compiler, root);
}
}  // namespace sh