tor-browser

DeferGlobalInitializers.cpp (7607B)

---

//
// Copyright 2016 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.
//
// DeferGlobalInitializers is an AST traverser that moves global initializers into a separate
// function that is called in the beginning of main(). This enables initialization of globals with
// uniforms or non-constant globals, as allowed by the WebGL spec. Some initializers referencing
// non-constants may need to be unfolded into if statements in HLSL - this kind of steps should be
// done after DeferGlobalInitializers is run. Note that it's important that the function definition
// is at the end of the shader, as some globals may be declared after main().
//
// It can also initialize all uninitialized globals.
//

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

#include <vector>

#include "compiler/translator/Compiler.h"
#include "compiler/translator/IntermNode.h"
#include "compiler/translator/StaticType.h"
#include "compiler/translator/SymbolTable.h"
#include "compiler/translator/tree_ops/InitializeVariables.h"
#include "compiler/translator/tree_util/FindMain.h"
#include "compiler/translator/tree_util/IntermNode_util.h"
#include "compiler/translator/tree_util/ReplaceVariable.h"

namespace sh
{

namespace
{

constexpr const ImmutableString kInitGlobalsString("initGlobals");

void GetDeferredInitializers(TIntermDeclaration *declaration,
                            bool initializeUninitializedGlobals,
                            bool canUseLoopsToInitialize,
                            bool highPrecisionSupported,
                            bool forceDeferGlobalInitializers,
                            TIntermSequence *deferredInitializersOut,
                            std::vector<const TVariable *> *variablesToReplaceOut,
                            TSymbolTable *symbolTable)
{
   // SeparateDeclarations should have already been run.
   ASSERT(declaration->getSequence()->size() == 1);

   TIntermNode *declarator = declaration->getSequence()->back();
   TIntermBinary *init     = declarator->getAsBinaryNode();
   if (init)
   {
       TIntermSymbol *symbolNode = init->getLeft()->getAsSymbolNode();
       ASSERT(symbolNode);
       TIntermTyped *expression = init->getRight();

       if (expression->getQualifier() != EvqConst || !expression->hasConstantValue() ||
           forceDeferGlobalInitializers)
       {
           // For variables which are not constant, defer their real initialization until
           // after we initialize uniforms.
           // Deferral is done also in any cases where the variable can not be converted to a
           // constant union, since otherwise there's a chance that HLSL output will generate extra
           // statements from the initializer expression.

           // Change const global to a regular global if its initialization is deferred.
           // This can happen if ANGLE has not been able to fold the constant expression used
           // as an initializer.
           ASSERT(symbolNode->getQualifier() == EvqConst ||
                  symbolNode->getQualifier() == EvqGlobal);
           if (symbolNode->getQualifier() == EvqConst)
           {
               variablesToReplaceOut->push_back(&symbolNode->variable());
           }

           TIntermBinary *deferredInit =
               new TIntermBinary(EOpAssign, symbolNode->deepCopy(), init->getRight());
           deferredInitializersOut->push_back(deferredInit);

           // Remove the initializer from the global scope and just declare the global instead.
           declaration->replaceChildNode(init, symbolNode);
       }
   }
   else if (initializeUninitializedGlobals)
   {
       TIntermSymbol *symbolNode = declarator->getAsSymbolNode();
       ASSERT(symbolNode);

       // Ignore ANGLE internal variables and nameless declarations.
       if (symbolNode->variable().symbolType() == SymbolType::AngleInternal ||
           symbolNode->variable().symbolType() == SymbolType::Empty)
           return;

       if (symbolNode->getQualifier() == EvqGlobal)
       {
           TIntermSequence initCode;
           CreateInitCode(symbolNode, canUseLoopsToInitialize, highPrecisionSupported, &initCode,
                          symbolTable);
           deferredInitializersOut->insert(deferredInitializersOut->end(), initCode.begin(),
                                           initCode.end());
       }
   }
}

void InsertInitCallToMain(TIntermBlock *root,
                         TIntermSequence *deferredInitializers,
                         TSymbolTable *symbolTable)
{
   TIntermBlock *initGlobalsBlock = new TIntermBlock();
   initGlobalsBlock->getSequence()->swap(*deferredInitializers);

   TFunction *initGlobalsFunction =
       new TFunction(symbolTable, kInitGlobalsString, SymbolType::AngleInternal,
                     StaticType::GetBasic<EbtVoid, EbpUndefined>(), false);

   TIntermFunctionPrototype *initGlobalsFunctionPrototype =
       CreateInternalFunctionPrototypeNode(*initGlobalsFunction);
   root->getSequence()->insert(root->getSequence()->begin(), initGlobalsFunctionPrototype);
   TIntermFunctionDefinition *initGlobalsFunctionDefinition =
       CreateInternalFunctionDefinitionNode(*initGlobalsFunction, initGlobalsBlock);
   root->appendStatement(initGlobalsFunctionDefinition);

   TIntermSequence emptySequence;
   TIntermAggregate *initGlobalsCall =
       TIntermAggregate::CreateFunctionCall(*initGlobalsFunction, &emptySequence);

   TIntermBlock *mainBody = FindMainBody(root);
   mainBody->getSequence()->insert(mainBody->getSequence()->begin(), initGlobalsCall);
}

}  // namespace

bool DeferGlobalInitializers(TCompiler *compiler,
                            TIntermBlock *root,
                            bool initializeUninitializedGlobals,
                            bool canUseLoopsToInitialize,
                            bool highPrecisionSupported,
                            bool forceDeferGlobalInitializers,
                            TSymbolTable *symbolTable)
{
   TIntermSequence deferredInitializers;
   std::vector<const TVariable *> variablesToReplace;

   // Loop over all global statements and process the declarations. This is simpler than using a
   // traverser.
   for (TIntermNode *statement : *root->getSequence())
   {
       TIntermDeclaration *declaration = statement->getAsDeclarationNode();
       if (declaration)
       {
           GetDeferredInitializers(declaration, initializeUninitializedGlobals,
                                   canUseLoopsToInitialize, highPrecisionSupported,
                                   forceDeferGlobalInitializers, &deferredInitializers,
                                   &variablesToReplace, symbolTable);
       }
   }

   // Add the function with initialization and the call to that.
   if (!deferredInitializers.empty())
   {
       InsertInitCallToMain(root, &deferredInitializers, symbolTable);
   }

   // Replace constant variables with non-constant global variables.
   for (const TVariable *var : variablesToReplace)
   {
       TType *replacementType = new TType(var->getType());
       replacementType->setQualifier(EvqGlobal);
       TVariable *replacement =
           new TVariable(symbolTable, var->name(), replacementType, var->symbolType());
       if (!ReplaceVariable(compiler, root, var, replacement))
       {
           return false;
       }
   }

   return true;
}

}  // namespace sh