Use TSpan for TType's array sizes

Until C++20, std::vector doesn't have a constexpr constructor, which
means TType cannot use a `TVector` for `mArraySizes` if an arrayed type
needs to be created constexpr.  This is needed for the upcoming
textureGatherOffsets implementation.

A new TSpan class is introduced, based on std::span (from C++20) that
holds the pointer/size allocated from a TVector without owning it.
Since TVector's allocation are made from a pool, the allocated memory
will live beyond the vector's destruction.  `TType::mArraySizes` is
changed to this type.

This change will allow a new constexpr constructor to be added to TType
that takes a TSpan as array directly, a value which is constexpr
initialized from a static array (instead of TVector).

Bug: angleproject:3569
Change-Id: I78793b0f4c64519e0ebe30cf6e0de995ba70035d
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1968260
Reviewed-by: Jiajia Qin <[email protected]>
Reviewed-by: Shahbaz Youssefi <[email protected]>
Commit-Queue: Shahbaz Youssefi <[email protected]>

Author: ShabbyX

src/compiler/translator/CollectVariables.cpp

@@ -653,9 +653,10 @@ void CollectVariablesTraverser::setFieldOrVariableProperties(const TType &type,
             variableOut->fields.push_back(fieldVariable);
         }
     }
-    if (auto *arraySizes = type.getArraySizes())
+    const TSpan<const unsigned int> &arraySizes = type.getArraySizes();
+    if (!arraySizes.empty())
     {
-        variableOut->arraySizes.assign(arraySizes->begin(), arraySizes->end());
+        variableOut->arraySizes.assign(arraySizes.begin(), arraySizes.end());
     }
 }
 

src/compiler/translator/Common.h

@@ -108,6 +108,105 @@ class TMap : public std::map<K, D, CMP, pool_allocator<std::pair<const K, D>>>
     {}
 };
 
+// Basic implementation of C++20's span for use with pool-allocated containers (TVector) or static
+// arrays.  This is used by the array sizes member of TType to allow arrayed types to be
+// constexpr-constructed.
+// See the reference for std::span here: https://en.cppreference.com/w/cpp/container/span
+template <typename T>
+class TSpan
+{
+  public:
+    typedef size_t size_type;
+
+    constexpr TSpan() {}
+    constexpr TSpan(T *ptr, size_type size) : mData(ptr), mSize(size) {}
+
+    constexpr TSpan(const TSpan &that) : mData(that.mData), mSize(that.mSize) {}
+    constexpr TSpan &operator=(const TSpan &that)
+    {
+        mData = that.mData;
+        mSize = that.mSize;
+        return *this;
+    }
+
+    // Note: the pointer is taken out of the TVector because TVector's memory is pool allocated,
+    // so the memory will live on even if the TVector is destroyed.
+    template <typename S>
+    TSpan(const TVector<S> &vec) : mData(vec.data()), mSize(vec.size())
+    {}
+    template <typename S>
+    TSpan &operator=(const TVector<S> &vec)
+    {
+        mData = vec.data();
+        mSize = vec.size();
+        return *this;
+    }
+
+    constexpr bool operator==(const TSpan &that) const
+    {
+        if (mSize != that.mSize)
+        {
+            return false;
+        }
+
+        if (mData == that.mData)
+        {
+            return true;
+        }
+
+        for (size_type index = 0; index < mSize; ++index)
+        {
+            if (mData[index] != that.mData[index])
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+    constexpr bool operator!=(const TSpan &that) const { return !(*this == that); }
+
+    constexpr T *data() const { return mData; }
+    constexpr size_type size() const { return mSize; }
+    constexpr bool empty() const { return mSize == 0; }
+
+    constexpr T &operator[](size_type index) const { return mData[index]; }
+    constexpr T &front() const { return mData[0]; }
+    constexpr T &back() const { return mData[mSize - 1]; }
+
+    constexpr T *begin() const { return mData; }
+    constexpr T *end() const { return mData + mSize; }
+
+    constexpr std::reverse_iterator<T *> rbegin() const
+    {
+        return std::make_reverse_iterator(end());
+    }
+    constexpr std::reverse_iterator<T *> rend() const
+    {
+        return std::make_reverse_iterator(begin());
+    }
+
+    constexpr TSpan first(size_type count) const
+    {
+        ASSERT(count <= mSize);
+        return count == 0 ? TSpan() : TSpan(mData, count);
+    }
+    constexpr TSpan last(size_type count) const
+    {
+        ASSERT(count <= mSize);
+        return count == 0 ? TSpan() : TSpan(mData + mSize - count, count);
+    }
+    constexpr TSpan subspan(size_type offset, size_type count) const
+    {
+        ASSERT(offset + count <= mSize);
+        return count == 0 ? TSpan() : TSpan(mData + offset, count);
+    }
+
+  private:
+    T *mData     = nullptr;
+    size_t mSize = 0;
+};
+
 // Integer to TString conversion
 template <typename T>
 inline TString str(T i)

src/compiler/translator/InfoSink.cpp

@@ -73,8 +73,8 @@ TInfoSinkBase &TInfoSinkBase::operator<<(const TType &type)
 
     if (type.isArray())
     {
-        for (auto arraySizeIter = type.getArraySizes()->rbegin();
-             arraySizeIter != type.getArraySizes()->rend(); ++arraySizeIter)
+        for (auto arraySizeIter = type.getArraySizes().rbegin();
+             arraySizeIter != type.getArraySizes().rend(); ++arraySizeIter)
         {
             *this << "array[" << (*arraySizeIter) << "] of ";
         }

src/compiler/translator/OutputHLSL.cpp

@@ -43,7 +43,7 @@ TString ArrayHelperFunctionName(const char *prefix, const TType &type)
     fnName << prefix << "_";
     if (type.isArray())
     {
-        for (unsigned int arraySize : *type.getArraySizes())
+        for (unsigned int arraySize : type.getArraySizes())
         {
             fnName << arraySize << "_";
         }

src/compiler/translator/ParseContext.cpp

@@ -1961,8 +1961,7 @@ bool TParseContext::executeInitializer(const TSourceLoc &line,
         // will default to setting array sizes to 1. We have not checked yet whether the initializer
         // actually is an array or not. Having a non-array initializer for an unsized array will
         // result in an error later, so we don't generate an error message here.
-        auto *arraySizes = initializer->getType().getArraySizes();
-        type->sizeUnsizedArrays(arraySizes);
+        type->sizeUnsizedArrays(initializer->getType().getArraySizes());
     }
 
     const TQualifier qualifier = type->getQualifier();
@@ -3531,7 +3530,7 @@ void TParseContext::checkIsNotUnsizedArray(const TSourceLoc &line,
     if (arrayType->isUnsizedArray())
     {
         error(line, errorMessage, token);
-        arrayType->sizeUnsizedArrays(nullptr);
+        arrayType->sizeUnsizedArrays(TSpan<const unsigned int>());
     }
 }
 
@@ -3623,7 +3622,7 @@ TIntermTyped *TParseContext::addConstructor(TFunctionLookup *fnCall, const TSour
     {
         if (!checkUnsizedArrayConstructorArgumentDimensionality(arguments, type, line))
         {
-            type.sizeUnsizedArrays(nullptr);
+            type.sizeUnsizedArrays(TSpan<const unsigned int>());
             return CreateZeroNode(type);
         }
         TIntermTyped *firstElement = arguments.at(0)->getAsTyped();
@@ -3634,9 +3633,9 @@ TIntermTyped *TParseContext::addConstructor(TFunctionLookup *fnCall, const TSour
         }
         for (size_t i = 0; i < firstElement->getType().getNumArraySizes(); ++i)
         {
-            if ((*type.getArraySizes())[i] == 0u)
+            if (type.getArraySizes()[i] == 0u)
             {
-                type.setArraySize(i, (*firstElement->getType().getArraySizes())[i]);
+                type.setArraySize(i, firstElement->getType().getArraySizes()[i]);
             }
         }
         ASSERT(!type.isUnsizedArray());
@@ -5227,7 +5226,7 @@ bool TParseContext::binaryOpCommonCheck(TOperator op,
                 return false;
         }
         // At this point, size of implicitly sized arrays should be resolved.
-        if (*left->getType().getArraySizes() != *right->getType().getArraySizes())
+        if (left->getType().getArraySizes() != right->getType().getArraySizes())
         {
             error(loc, "array size mismatch", GetOperatorString(op));
             return false;

src/compiler/translator/ShaderStorageBlockOutputHLSL.cpp

@@ -111,10 +111,10 @@ const BlockMemberInfo GetBlockMemberInfoByType(const TType &type,
     }
 
     std::vector<unsigned int> arraySizes;
-    auto *typeArraySizes = type.getArraySizes();
-    if (typeArraySizes != nullptr)
+    const TSpan<const unsigned int> &typeArraySizes = type.getArraySizes();
+    if (!typeArraySizes.empty())
     {
-        arraySizes.assign(typeArraySizes->begin(), typeArraySizes->end());
+        arraySizes.assign(typeArraySizes.begin(), typeArraySizes.end());
     }
     return encoder->encodeType(GLVariableType(type), arraySizes, rowMajor);
 }
@@ -677,7 +677,7 @@ void ShaderStorageBlockOutputHLSL::writeEOpIndexDirectOrIndirectOutput(TInfoSink
         {
             if (type.isArrayOfArrays())
             {
-                const TVector<unsigned int> &arraySizes = *type.getArraySizes();
+                const TSpan<const unsigned int> &arraySizes = type.getArraySizes();
                 // Don't need to concern the tail comma which will be used to multiply the index.
                 for (unsigned int i = 0; i < (arraySizes.size() - 1); i++)
                 {