kc3-lang/angle/src/libANGLE/Uniform.cpp

• Show log

  Commit

• Hash : b8d5a423
  Author :
  Date : 2023-08-21T14:43:42
  

  Add static_assert(std::is_trivially_copyable<LinkedUniform>(),"")
  
  Since we are using memcpy for LinkedUniform, it is desirable to utilize
  compile time assertion to ensure that in future if anyone modifies POD
  struct (and the class of data members of POD struct) and made it that no
  longer memcopy-able, we would immediately caught at compile time.
  std::is_trivially_copyable<>is exactly for this reason. In order to make
  this work, the POD struct and any data it uses can not have user defined
  copy constructor. The problem is that right now ANGLE is using
  clang_use_chrome_plugins=true, and chrome-style generates warnings if
  the complex struct (has more than 10 data members) does not define a
  copy constructor, and that warning causes build failure with -Werror. So
  clang_use_chrome_plugins=true and std::is_trivially_copyable have this
  conflicting requirements that I can not apply both. This has been raised
  to compiler team, but before we get a solution from them, if we have to
  make a choice, I think the better choice is to disable
  clang_use_chrome_plugins and apply std::is_trivially_copyable, since the
  later is more critical to ensure safety, while chrome-style is mostly
  trying to minimize the code size, but won't affect
  correctness/robustness. This CL sets clang_use_chrome_plugins to false,
  and removes the copy constructor and copy assignment operator from
  BitSetT and LinkedUniform and added static assertion
  is_trivially_copyable for LinkedUniform. Same thing applied to
  ProgramInput as well.
  
  In future once we have a better solution from compile team, we can
  re-enable clang_use_chrome_plugins and disable only for structs that
  requires is_trivially_copyable assertion.
  
  Bug: b/275102061
  Change-Id: If33415ea61deda568d855a7dd6a4fd6042058be5
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4799342
  Reviewed-by: Roman Lavrov <romanl@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Charlie Lao <cclao@google.com>
  

Download

• src/libANGLE/Uniform.cpp

• //
  // Copyright 2010 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 "libANGLE/Uniform.h"
  #include "common/BinaryStream.h"
  #include "libANGLE/ProgramLinkedResources.h"
  
  #include <cstring>
  
  namespace gl
  {
  
  ActiveVariable::ActiveVariable()
  {
      std::fill(mIds.begin(), mIds.end(), 0);
  }
  
  ActiveVariable::~ActiveVariable() {}
  
  ActiveVariable::ActiveVariable(const ActiveVariable &rhs)            = default;
  ActiveVariable &ActiveVariable::operator=(const ActiveVariable &rhs) = default;
  
  void ActiveVariable::setActive(ShaderType shaderType, bool used, uint32_t id)
  {
      ASSERT(shaderType != ShaderType::InvalidEnum);
      mActiveUseBits.set(shaderType, used);
      mIds[shaderType] = id;
  }
  
  void ActiveVariable::unionReferencesWith(const LinkedUniform &other)
  {
      mActiveUseBits |= other.mActiveUseBits;
      for (const ShaderType shaderType : AllShaderTypes())
      {
          ASSERT(mIds[shaderType] == 0 || other.getId(shaderType) == 0 ||
                 mIds[shaderType] == other.getId(shaderType));
          if (mIds[shaderType] == 0)
          {
              mIds[shaderType] = other.getId(shaderType);
          }
      }
  }
  
  LinkedUniform::LinkedUniform() = default;
  
  LinkedUniform::LinkedUniform(GLenum typeIn,
                               GLenum precisionIn,
                               const std::vector<unsigned int> &arraySizesIn,
                               const int bindingIn,
                               const int offsetIn,
                               const int locationIn,
                               const int bufferIndexIn,
                               const sh::BlockMemberInfo &blockInfoIn)
  {
      // arrays are always flattened, which means at most 1D array
      ASSERT(arraySizesIn.size() <= 1);
  
      memset(this, 0, sizeof(*this));
      SetBitField(type, typeIn);
      SetBitField(precision, precisionIn);
      location = locationIn;
      SetBitField(binding, bindingIn);
      SetBitField(offset, offsetIn);
      SetBitField(bufferIndex, bufferIndexIn);
      outerArraySizeProduct = 1;
      SetBitField(arraySize, arraySizesIn.empty() ? 1u : arraySizesIn[0]);
      SetBitField(flagBits.isArray, !arraySizesIn.empty());
      if (!(blockInfoIn == sh::kDefaultBlockMemberInfo))
      {
          flagBits.isBlock               = 1;
          flagBits.blockIsRowMajorMatrix = blockInfoIn.isRowMajorMatrix;
          SetBitField(blockOffset, blockInfoIn.offset);
          SetBitField(blockArrayStride, blockInfoIn.arrayStride);
          SetBitField(blockMatrixStride, blockInfoIn.matrixStride);
      }
  }
  
  LinkedUniform::LinkedUniform(const UsedUniform &usedUniform)
  {
      ASSERT(!usedUniform.isArrayOfArrays());
      ASSERT(!usedUniform.isStruct());
      ASSERT(usedUniform.active);
      ASSERT(usedUniform.blockInfo == sh::kDefaultBlockMemberInfo);
  
      // Note: Ensure every data member is initialized.
      flagBitsAsUByte = 0;
      SetBitField(type, usedUniform.type);
      SetBitField(precision, usedUniform.precision);
      SetBitField(imageUnitFormat, usedUniform.imageUnitFormat);
      location          = usedUniform.location;
      blockOffset       = 0;
      blockArrayStride  = 0;
      blockMatrixStride = 0;
      SetBitField(binding, usedUniform.binding);
      SetBitField(offset, usedUniform.offset);
  
      SetBitField(bufferIndex, usedUniform.bufferIndex);
      SetBitField(parentArrayIndex, usedUniform.parentArrayIndex());
      SetBitField(outerArraySizeProduct, ArraySizeProduct(usedUniform.outerArraySizes));
      SetBitField(outerArrayOffset, usedUniform.outerArrayOffset);
      SetBitField(arraySize, usedUniform.isArray() ? usedUniform.getArraySizeProduct() : 1u);
      SetBitField(flagBits.isArray, usedUniform.isArray());
  
      id             = usedUniform.id;
      mActiveUseBits = usedUniform.activeVariable.activeShaders();
      mIds           = usedUniform.activeVariable.getIds();
  
      SetBitField(flagBits.isFragmentInOut, usedUniform.isFragmentInOut);
      SetBitField(flagBits.texelFetchStaticUse, usedUniform.texelFetchStaticUse);
      ASSERT(!usedUniform.isArray() || arraySize == usedUniform.getArraySizeProduct());
  }
  
  BufferVariable::BufferVariable()
      : bufferIndex(-1), blockInfo(sh::kDefaultBlockMemberInfo), topLevelArraySize(-1)
  {}
  
  BufferVariable::BufferVariable(GLenum typeIn,
                                 GLenum precisionIn,
                                 const std::string &nameIn,
                                 const std::vector<unsigned int> &arraySizesIn,
                                 const int bufferIndexIn,
                                 const sh::BlockMemberInfo &blockInfoIn)
      : bufferIndex(bufferIndexIn), blockInfo(blockInfoIn), topLevelArraySize(-1)
  {
      type       = typeIn;
      precision  = precisionIn;
      name       = nameIn;
      arraySizes = arraySizesIn;
  }
  
  BufferVariable::~BufferVariable() {}
  
  ShaderVariableBuffer::ShaderVariableBuffer() : binding(0), dataSize(0) {}
  
  ShaderVariableBuffer::ShaderVariableBuffer(const ShaderVariableBuffer &other) = default;
  
  ShaderVariableBuffer::~ShaderVariableBuffer() {}
  
  int ShaderVariableBuffer::numActiveVariables() const
  {
      return static_cast<int>(memberIndexes.size());
  }
  
  InterfaceBlock::InterfaceBlock() : isArray(false), isReadOnly(false), arrayElement(0) {}
  
  InterfaceBlock::InterfaceBlock(const std::string &nameIn,
                                 const std::string &mappedNameIn,
                                 bool isArrayIn,
                                 bool isReadOnlyIn,
                                 unsigned int arrayElementIn,
                                 unsigned int firstFieldArraySizeIn,
                                 int bindingIn)
      : name(nameIn),
        mappedName(mappedNameIn),
        isArray(isArrayIn),
        isReadOnly(isReadOnlyIn),
        arrayElement(arrayElementIn),
        firstFieldArraySize(firstFieldArraySizeIn)
  {
      binding = bindingIn;
  }
  
  InterfaceBlock::InterfaceBlock(const InterfaceBlock &other) = default;
  
  std::string InterfaceBlock::nameWithArrayIndex() const
  {
      std::stringstream fullNameStr;
      fullNameStr << name;
      if (isArray)
      {
          fullNameStr << "[" << arrayElement << "]";
      }
  
      return fullNameStr.str();
  }
  
  std::string InterfaceBlock::mappedNameWithArrayIndex() const
  {
      std::stringstream fullNameStr;
      fullNameStr << mappedName;
      if (isArray)
      {
          fullNameStr << "[" << arrayElement << "]";
      }
  
      return fullNameStr.str();
  }
  }  // namespace gl
  

Download