kc3-lang/angle/src/compiler/translator/TranslatorMetalDirect/SeparateCompoundStructDeclarations.cpp

• Show log

  Commit

• Hash : aec5e65c
  Author :
  Date : 2021-07-28T00:36:12
  

  Get direct-to-Metal backend to run angle_end2end_tests.
  
  Cherry-pick nameless struct fix from Apple in
  https://bugs.webkit.org/show_bug.cgi?id=227482 .
  
  Fix SeparateCompoundStructDeclarations pass to stop generating
  multiple declarations; thanks syoussefi@ for advice.
  
  Incorporate additional passes from TranslatorVulkan
  (MonomorphizeUnsupportedFunctionsInVulkanGLSL,
  RewriteArrayOfArrayOfOpaqueUniforms,
  SeparateStructFromUniformDeclarations) needed by RewriteStructSamplers
  pass in TranslatorMetalDirect. Fixes many assertion failures in GLSL
  tests. Moved these passes out of tree_ops/vulkan. Thanks again to
  syoussefi@ for advice and help.
  
  Disable a validation check related to the RewritePipelines pass. Skip
  two tests that were failing for other reasons.
  
  With these changes, angle_end2end_tests runs to completion when the
  direct-to-Metal backend is turned on. There are still ~1300 failures
  of the ~4000 tests which will be investigated next.
  
  Bug: angleproject:5505
  Change-Id: Ibca77822543e8e8e8d2a8c862e92cdf74bfa3545
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3058524
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Kenneth Russell <kbr@chromium.org>
  

Download

• src/compiler/translator/TranslatorMetalDirect/SeparateCompoundStructDeclarations.cpp

• //
  // 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.
  //
  
  #include <algorithm>
  
  #include "compiler/translator/TranslatorMetalDirect/AstHelpers.h"
  #include "compiler/translator/TranslatorMetalDirect/SeparateCompoundStructDeclarations.h"
  #include "compiler/translator/tree_ops/SeparateDeclarations.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  
  using namespace sh;
  
  ////////////////////////////////////////////////////////////////////////////////
  
  namespace
  {
  
  class Separator : public TIntermTraverser
  {
    public:
      std::unordered_map<int, TIntermSymbol *> replacementMap;
      Separator(TSymbolTable &symbolTable, IdGen &idGen)
          : TIntermTraverser(false, false, true, &symbolTable), mIdGen(idGen)
      {}
      IdGen &mIdGen;
      bool visitDeclaration(Visit, TIntermDeclaration *declNode) override
      {
          ASSERT(declNode->getChildCount() == 1);
          Declaration declaration = ViewDeclaration(*declNode);
  
          const TVariable &var        = declaration.symbol.variable();
          const TType &type           = var.getType();
          const SymbolType symbolType = var.symbolType();
          if (type.isStructSpecifier() && symbolType != SymbolType::Empty)
          {
              const TStructure *structure = type.getStruct();
              TVariable *structVar        = nullptr;
              TType *instanceType         = nullptr;
              // Name unnamed inline structs
              if (structure->symbolType() == SymbolType::Empty)
              {
                  const TStructure *structDefn =
                      new TStructure(mSymbolTable, mIdGen.createNewName().rawName(),
                                     &structure->fields(), SymbolType::AngleInternal);
                  structVar    = new TVariable(mSymbolTable, ImmutableString(""),
                                            new TType(structDefn, true), SymbolType::Empty);
                  instanceType = new TType(structDefn, false);
              }
              else
              {
                  structVar    = new TVariable(mSymbolTable, ImmutableString(""),
                                            new TType(structure, true), SymbolType::Empty);
                  instanceType = new TType(structure, false);
              }
              if (type.isArray())
              {
                  instanceType->makeArrays(type.getArraySizes());
              }
              instanceType->setQualifier(type.getQualifier());
              auto *instanceVar =
                  new TVariable(mSymbolTable, var.name(), instanceType, symbolType, var.extensions());
  
              TIntermSequence replacements;
              replacements.push_back(new TIntermDeclaration({structVar}));
  
              TIntermSymbol *instanceSymbol    = new TIntermSymbol(instanceVar);
              TIntermDeclaration *instanceDecl = new TIntermDeclaration;
              if (declaration.initExpr)
              {
                  instanceDecl->appendDeclarator(new TIntermBinary(
                      TOperator::EOpInitialize, instanceSymbol, declaration.initExpr));
              }
              else
              {
                  instanceDecl->appendDeclarator(instanceSymbol);
              }
              replacements.push_back(instanceDecl);
  
              replacementMap[declaration.symbol.uniqueId().get()] = instanceSymbol;
              ASSERT(getParentNode() != nullptr);
              ASSERT(getParentNode()->getAsBlock() != nullptr);
              mMultiReplacements.push_back(NodeReplaceWithMultipleEntry(
                  getParentNode()->getAsBlock(), declNode, std::move(replacements)));
          }
  
          return false;
      }
  
      void visitSymbol(TIntermSymbol *decl) override
      {
          auto symbol = replacementMap.find(decl->uniqueId().get());
          if (symbol != replacementMap.end())
          {
              queueReplacement(symbol->second->deepCopy(), OriginalNode::IS_DROPPED);
          }
      }
  };
  
  }  // anonymous namespace
  
  ////////////////////////////////////////////////////////////////////////////////
  
  bool sh::SeparateCompoundStructDeclarations(TCompiler &compiler, IdGen &idGen, TIntermBlock &root)
  {
      Separator separator(compiler.getSymbolTable(), idGen);
      root.traverse(&separator);
      if (!separator.updateTree(&compiler, &root))
      {
          return false;
      }
  
      if (!SeparateDeclarations(&compiler, &root))
      {
          return false;
      }
  
      return true;
  }
  

Download