Use non-human-readable mangled names for types

src/compiler/translator/BaseTypes.h

@@ -57,10 +57,12 @@ enum TBasicType
     EbtInt,
     EbtUInt,
     EbtBool,
+
+    EbtAtomicCounter,
     EbtYuvCscStandardEXT,  // Only valid if EXT_YUV_target exists.
 
     EbtGuardSamplerBegin,  // non type: see implementation of IsSampler()
-    EbtSampler2D,
+    EbtSampler2D = EbtGuardSamplerBegin,
     EbtSampler3D,
     EbtSamplerCube,
     EbtSampler2DArray,
@@ -81,11 +83,11 @@ enum TBasicType
     EbtSampler2DShadow,
     EbtSamplerCubeShadow,
     EbtSampler2DArrayShadow,
-    EbtGuardSamplerEnd,  // non type: see implementation of IsSampler()
+    EbtGuardSamplerEnd = EbtSampler2DArrayShadow,  // non type: see implementation of IsSampler()
 
     // images
     EbtGuardImageBegin,
-    EbtImage2D,
+    EbtImage2D = EbtGuardImageBegin,
     EbtIImage2D,
     EbtUImage2D,
     EbtImage3D,
@@ -97,119 +99,41 @@ enum TBasicType
     EbtImageCube,
     EbtIImageCube,
     EbtUImageCube,
-    EbtGuardImageEnd,
+    EbtGuardImageEnd = EbtUImageCube,
+
+    EbtLastSimpleType = EbtGuardImageEnd,
 
     EbtStruct,
     EbtInterfaceBlock,
-    EbtAddress,  // should be deprecated??
-
-    EbtAtomicCounter,
 
     // end of list
-    EbtLast
+    EbtLast = EbtInterfaceBlock
 };
 
-constexpr const char *GetBasicMangledName(TBasicType t)
+constexpr char GetBasicMangledName(TBasicType t)
 {
-    switch (t)
+    if (t > EbtLastSimpleType)
     {
-        case EbtFloat:
-            return "f";
-        case EbtInt:
-            return "i";
-        case EbtUInt:
-            return "u";
-        case EbtBool:
-            return "b";
-        case EbtYuvCscStandardEXT:
-            return "y";
-        case EbtSampler2D:
-            return "s2";
-        case EbtSampler3D:
-            return "s3";
-        case EbtSamplerCube:
-            return "sC";
-        case EbtSampler2DArray:
-            return "sA";
-        case EbtSamplerExternalOES:
-            return "sX";
-        case EbtSamplerExternal2DY2YEXT:
-            return "sY";
-        case EbtSampler2DRect:
-            return "sR";
-        case EbtSampler2DMS:
-            return "sM";
-        case EbtISampler2D:
-            return "is2";
-        case EbtISampler3D:
-            return "is3";
-        case EbtISamplerCube:
-            return "isC";
-        case EbtISampler2DArray:
-            return "isA";
-        case EbtISampler2DMS:
-            return "isM";
-        case EbtUSampler2D:
-            return "us2";
-        case EbtUSampler3D:
-            return "us3";
-        case EbtUSamplerCube:
-            return "usC";
-        case EbtUSampler2DArray:
-            return "usA";
-        case EbtUSampler2DMS:
-            return "usM";
-        case EbtSampler2DShadow:
-            return "s2s";
-        case EbtSamplerCubeShadow:
-            return "sCs";
-        case EbtSampler2DArrayShadow:
-            return "sAs";
-        case EbtImage2D:
-            return "I2";
-        case EbtIImage2D:
-            return "iI2";
-        case EbtUImage2D:
-            return "uI2";
-        case EbtImage3D:
-            return "I3";
-        case EbtIImage3D:
-            return "iI3";
-        case EbtUImage3D:
-            return "uI3";
-        case EbtImage2DArray:
-            return "IA";
-        case EbtIImage2DArray:
-            return "iIA";
-        case EbtUImage2DArray:
-            return "uIA";
-        case EbtImageCube:
-            return "Ic";
-        case EbtIImageCube:
-            return "iIc";
-        case EbtUImageCube:
-            return "uIc";
-        case EbtAtomicCounter:
-            return "a";
-        case EbtStruct:
-        case EbtInterfaceBlock:
-            return nullptr;
-        default:
-            // EbtVoid, EbtAddress and non types
-            return "";
+        return '{';
+    }
+    static_assert(EbtLastSimpleType < 52, "We only use alphabetic characters for mangled names");
+    if (t < 26)
+    {
+        return static_cast<char>('A' + t);
     }
+    return static_cast<char>('a' - 26 + t);
 }
 
 const char *getBasicString(TBasicType t);
 
 inline bool IsSampler(TBasicType type)
 {
-    return type > EbtGuardSamplerBegin && type < EbtGuardSamplerEnd;
+    return type >= EbtGuardSamplerBegin && type <= EbtGuardSamplerEnd;
 }
 
 inline bool IsImage(TBasicType type)
 {
-    return type > EbtGuardImageBegin && type < EbtGuardImageEnd;
+    return type >= EbtGuardImageBegin && type <= EbtGuardImageEnd;
 }
 
 inline bool IsAtomicCounter(TBasicType type)

src/compiler/translator/StaticType.h

@@ -25,16 +25,16 @@ namespace Helpers
 // Generation and static allocation of type mangled name values.
 //
 
-// Size of the maximum possible constexpr-generated mangled name.
+// Size of the constexpr-generated mangled name.
 // If this value is too small, the compiler will produce errors.
-static constexpr size_t kStaticMangledNameMaxLength = 5;
+static constexpr size_t kStaticMangledNameLength = 2;
 
 // Type which holds the mangled names for constexpr-generated TTypes.
 // This simple struct is needed so that a char array can be returned by value.
 struct StaticMangledName
 {
     // If this array is too small, the compiler will produce errors.
-    char name[kStaticMangledNameMaxLength + 1] = {};
+    char name[kStaticMangledNameLength + 1] = {};
 };
 
 // Generates a mangled name for a TType given its parameters.
@@ -45,31 +45,9 @@ constexpr StaticMangledName BuildStaticMangledName(TBasicType basicType,
                                                    unsigned char secondarySize)
 {
     StaticMangledName name = {};
-    // When this function is executed constexpr (should be always),
-    // name.name[at] is guaranteed by the compiler to never go out of bounds.
-    size_t at = 0;
-
-    bool isMatrix = primarySize > 1 && secondarySize > 1;
-    if (primarySize > 1)
-    {
-        name.name[at++] = '0' + primarySize;
-    }
-    if (isMatrix)
-    {
-        name.name[at++] = '0' + secondarySize;
-    }
-
-    {
-        const char *basicMangledName = GetBasicMangledName(basicType);
-        for (size_t i = 0; basicMangledName[i] != '\0'; ++i)
-        {
-            name.name[at++] = basicMangledName[i];
-        }
-    }
-
-    name.name[at++] = ';';
-
-    name.name[at] = '\0';
+    name.name[0]           = TType::GetSizeMangledName(primarySize, secondarySize);
+    name.name[1]           = GetBasicMangledName(basicType);
+    name.name[2]           = '\0';
     return name;
 }
 

src/compiler/translator/SymbolTable.cpp

@@ -375,7 +375,7 @@ void TSymbolTable::initializeBuiltIns(sh::GLenum type,
 
 void TSymbolTable::initSamplerDefaultPrecision(TBasicType samplerType)
 {
-    ASSERT(samplerType > EbtGuardSamplerBegin && samplerType < EbtGuardSamplerEnd);
+    ASSERT(samplerType >= EbtGuardSamplerBegin && samplerType <= EbtGuardSamplerEnd);
     setDefaultPrecision(samplerType, EbpLow);
 }
 

src/compiler/translator/Types.cpp

@@ -479,20 +479,10 @@ bool TType::canReplaceWithConstantUnion() const
 //
 const char *TType::buildMangledName() const
 {
-    TString mangledName;
-
-    if (isMatrix())
-    {
-        mangledName += static_cast<char>('0' + getCols());
-        mangledName += static_cast<char>('0' + getRows());
-    }
-    else if (getNominalSize() > 1)
-    {
-        mangledName += static_cast<char>('0' + getNominalSize());
-    }
+    TString mangledName(1, GetSizeMangledName(primarySize, secondarySize));
 
-    const char *basicMangledName = GetBasicMangledName(type);
-    if (basicMangledName != nullptr)
+    char basicMangledName = GetBasicMangledName(type);
+    if (basicMangledName != '{')
     {
         mangledName += basicMangledName;
     }
@@ -502,17 +492,19 @@ const char *TType::buildMangledName() const
         switch (type)
         {
             case EbtStruct:
-                mangledName += "struct-";
+                mangledName += "{s";
                 if (mStructure->symbolType() != SymbolType::Empty)
                 {
                     mangledName += mStructure->name().data();
                 }
                 mangledName += mStructure->mangledFieldList();
+                mangledName += '}';
                 break;
             case EbtInterfaceBlock:
-                mangledName += "iblock-";
+                mangledName += "{i";
                 mangledName += mInterfaceBlock->name().data();
                 mangledName += mInterfaceBlock->mangledFieldList();
+                mangledName += '}';
                 break;
             default:
                 UNREACHABLE();
@@ -532,8 +524,6 @@ const char *TType::buildMangledName() const
         }
     }
 
-    mangledName += ';';
-
     // Copy string contents into a pool-allocated buffer, so we never need to call delete.
     return AllocatePoolCharArray(mangledName.c_str(), mangledName.size());
 }
@@ -874,7 +864,6 @@ TString TFieldListCollection::buildMangledFieldList() const
     TString mangledName;
     for (const auto *field : *mFields)
     {
-        mangledName += '-';
         mangledName += field->type()->getMangledName();
     }
     return mangledName;

src/compiler/translator/Types.h

@@ -229,6 +229,15 @@ class TType
 
     const TStructure *getStruct() const { return mStructure; }
 
+    static constexpr char GetSizeMangledName(unsigned char primarySize, unsigned char secondarySize)
+    {
+        unsigned int sizeKey = (secondarySize - 1u) * 4u + primarySize - 1u;
+        if (sizeKey < 10u)
+        {
+            return static_cast<char>('0' + sizeKey);
+        }
+        return static_cast<char>('A' + sizeKey - 10);
+    }
     const char *getMangledName() const;
 
     bool sameNonArrayType(const TType &right) const;

src/compiler/translator/gen_builtin_symbols.py

@@ -188,47 +188,54 @@ parsed_variables = None
 variables_json_filename = 'builtin_variables.json'
 functions_txt_filename = 'builtin_function_declarations.txt'
 
-basic_mangled_names = {
-    'Float': 'f',
-    'Int': 'i',
-    'UInt': 'u',
-    'Bool': 'b',
-    'YuvCscStandardEXT': 'y',
-    'Sampler2D': 's2',
-    'Sampler3D': 's3',
-    'SamplerCube': 'sC',
-    'Sampler2DArray': 'sA',
-    'SamplerExternalOES': 'sX',
-    'SamplerExternal2DY2YEXT': 'sY',
-    'Sampler2DRect': 'sR',
-    'Sampler2DMS': 'sM',
-    'ISampler2D': 'is2',
-    'ISampler3D': 'is3',
-    'ISamplerCube': 'isC',
-    'ISampler2DArray': 'isA',
-    'ISampler2DMS': 'isM',
-    'USampler2D': 'us2',
-    'USampler3D': 'us3',
-    'USamplerCube': 'usC',
-    'USampler2DArray': 'usA',
-    'USampler2DMS': 'usM',
-    'Sampler2DShadow': 's2s',
-    'SamplerCubeShadow': 'sCs',
-    'Sampler2DArrayShadow': 'sAs',
-    'Image2D': 'I2',
-    'IImage2D': 'iI2',
-    'UImage2D': 'uI2',
-    'Image3D': 'I3',
-    'IImage3D': 'iI3',
-    'UImage3D': 'uI3',
-    'Image2DArray': 'IA',
-    'IImage2DArray': 'iIA',
-    'UImage2DArray': 'uIA',
-    'ImageCube': 'Ic',
-    'IImageCube': 'iIc',
-    'UImageCube': 'uIc',
-    'AtomicCounter': 'a'
-}
+basic_types_enumeration = [
+    'Void',
+    'Float',
+    'Int',
+    'UInt',
+    'Bool',
+    'AtomicCounter',
+    'YuvCscStandardEXT',
+    'Sampler2D',
+    'Sampler3D',
+    'SamplerCube',
+    'Sampler2DArray',
+    'SamplerExternalOES',
+    'SamplerExternal2DY2YEXT',
+    'Sampler2DRect',
+    'Sampler2DMS',
+    'ISampler2D',
+    'ISampler3D',
+    'ISamplerCube',
+    'ISampler2DArray',
+    'ISampler2DMS',
+    'USampler2D',
+    'USampler3D',
+    'USamplerCube',
+    'USampler2DArray',
+    'USampler2DMS',
+    'Sampler2DShadow',
+    'SamplerCubeShadow',
+    'Sampler2DArrayShadow',
+    'Image2D',
+    'IImage2D',
+    'UImage2D',
+    'Image3D',
+    'IImage3D',
+    'UImage3D',
+    'Image2DArray',
+    'IImage2DArray',
+    'UImage2DArray',
+    'ImageCube',
+    'IImageCube',
+    'UImageCube'
+]
+
+def get_basic_mangled_name(basic):
+    index = basic_types_enumeration.index(basic)
+    if index < 26:
+        return chr(ord('A') + index)
+    return chr(ord('a') + index - 26)
 
 levels = ['ESSL3_1_BUILTINS', 'ESSL3_BUILTINS', 'ESSL1_BUILTINS', 'COMMON_BUILTINS']
 
@@ -293,18 +300,16 @@ class TType:
         template_type = 'new TType(Ebt{basic}, Ebp{precision}, Evq{qualifier}, {primarySize}, {secondarySize})'
         return template_type.format(**self.data)
 
-    def get_mangled_name(self, separator = ';'):
+    def get_mangled_name(self):
         mangled_name = ''
 
-        if self.is_matrix():
-            mangled_name += str(self.data['primarySize'])
-            mangled_name += str(self.data['secondarySize'])
-        elif self.data['primarySize'] > 1:
-            mangled_name += str(self.data['primarySize'])
-
-        mangled_name += basic_mangled_names[self.data['basic']]
+        size_key = (self.data['secondarySize'] - 1) * 4 + self.data['primarySize'] - 1
+        if size_key < 10:
+            mangled_name += chr(ord('0') + size_key)
+        else:
+            mangled_name += chr(ord('A') + size_key - 10)
 
-        mangled_name += separator
+        mangled_name += get_basic_mangled_name(self.data['basic'])
         return mangled_name
 
     def is_vector(self):
@@ -589,20 +594,20 @@ def get_function_mangled_name(function_name, parameters):
 def get_unique_identifier_name(function_name, parameters):
     unique_name = function_name + '_'
     for param in parameters:
-        unique_name += param.get_mangled_name('_')
+        unique_name += param.get_mangled_name()
     return unique_name
 
 def get_variable_name_to_store_parameters(parameters):
     if len(parameters) == 0:
         return 'empty'
-    unique_name = 'p_'
+    unique_name = 'p'
     for param in parameters:
         if 'qualifier' in param.data:
             if param.data['qualifier'] == 'Out':
-                unique_name += 'o_'
+                unique_name += '_o_'
             if param.data['qualifier'] == 'InOut':
-                unique_name += 'io_'
-        unique_name += param.get_mangled_name('_')
+                unique_name += '_io_'
+        unique_name += param.get_mangled_name()
     return unique_name
 
 def gen_function_variants(function_name, function_props):

src/tests/compiler_tests/ShaderImage_test.cpp

@@ -7,11 +7,12 @@
 // Tests for images
 //
 
+#include "GLSLANG/ShaderLang.h"
 #include "angle_gl.h"
+#include "compiler/translator/StaticType.h"
 #include "gtest/gtest.h"
-#include "GLSLANG/ShaderLang.h"
-#include "tests/test_utils/compiler_test.h"
 #include "tests/test_utils/ShaderCompileTreeTest.h"
+#include "tests/test_utils/compiler_test.h"
 
 using namespace sh;
 
@@ -188,10 +189,16 @@ TEST_F(ShaderImageTest, ImageLoad)
     }
 
     // imageLoad call with image2D passed
-    CheckImageLoadCall(mASTRoot, "imageLoad(I2;2i;", EbtImage2D, 2);
+    std::string mangledName2D = "imageLoad(";
+    mangledName2D += StaticType::GetBasic<EbtImage2D>()->getMangledName();
+    mangledName2D += StaticType::GetBasic<EbtInt, 2>()->getMangledName();
+    CheckImageLoadCall(mASTRoot, mangledName2D.c_str(), EbtImage2D, 2);
 
     // imageLoad call with image3D passed
-    CheckImageLoadCall(mASTRoot, "imageLoad(iI3;3i;", EbtIImage3D, 3);
+    std::string mangledName3D = "imageLoad(";
+    mangledName3D += StaticType::GetBasic<EbtIImage3D>()->getMangledName();
+    mangledName3D += StaticType::GetBasic<EbtInt, 3>()->getMangledName();
+    CheckImageLoadCall(mASTRoot, mangledName3D.c_str(), EbtIImage3D, 3);
 }
 
 // Check that imageStore calls get correctly parsed.
@@ -212,10 +219,18 @@ TEST_F(ShaderImageTest, ImageStore)
     }
 
     // imageStore call with image2D
-    CheckImageStoreCall(mASTRoot, "imageStore(I2;2i;4f;", EbtImage2D, 2, EbtFloat, 4);
+    std::string mangledName2D = "imageStore(";
+    mangledName2D += StaticType::GetBasic<EbtImage2D>()->getMangledName();
+    mangledName2D += StaticType::GetBasic<EbtInt, 2>()->getMangledName();
+    mangledName2D += StaticType::GetBasic<EbtFloat, 4>()->getMangledName();
+    CheckImageStoreCall(mASTRoot, mangledName2D.c_str(), EbtImage2D, 2, EbtFloat, 4);
 
     // imageStore call with image2DArray
-    CheckImageStoreCall(mASTRoot, "imageStore(uIA;3i;4u;", EbtUImage2DArray, 3, EbtUInt, 4);
+    std::string mangledName2DArray = "imageStore(";
+    mangledName2DArray += StaticType::GetBasic<EbtUImage2DArray>()->getMangledName();
+    mangledName2DArray += StaticType::GetBasic<EbtInt, 3>()->getMangledName();
+    mangledName2DArray += StaticType::GetBasic<EbtUInt, 4>()->getMangledName();
+    CheckImageStoreCall(mASTRoot, mangledName2DArray.c_str(), EbtUImage2DArray, 3, EbtUInt, 4);
 }
 
 // Check that memory qualifiers are correctly parsed.

src/tests/compiler_tests/Type_test.cpp

@@ -43,15 +43,15 @@ TEST(Type, VectorAndMatrixMangledNameConsistent)
 // Verify that basic type mangled names are unique.
 TEST(Type, BaseTypeMangledNamesUnique)
 {
-    std::set<std::string> uniqueNames;
+    std::set<char> uniqueNames;
     for (int i = static_cast<int>(EbtVoid); i < static_cast<int>(EbtLast); ++i)
     {
         if (i == static_cast<int>(EbtStruct) || i == static_cast<int>(EbtInterfaceBlock))
         {
             continue;
         }
-        const std::string &mangledName = GetBasicMangledName(static_cast<TBasicType>(i));
-        if (mangledName != "")
+        char mangledName = GetBasicMangledName(static_cast<TBasicType>(i));
+        if (mangledName != '{')
         {
             ASSERT_TRUE(uniqueNames.insert(mangledName).second);
         }