Revert "Cache TTypes."

src/compiler.gypi

@@ -26,8 +26,6 @@
             'compiler/translator/BuiltInFunctionEmulator.h',
             'compiler/translator/BuiltInFunctionEmulatorGLSL.cpp',
             'compiler/translator/BuiltInFunctionEmulatorGLSL.h',
-            'compiler/translator/Cache.cpp',
-            'compiler/translator/Cache.h',
             'compiler/translator/CallDAG.cpp',
             'compiler/translator/CallDAG.h',
             'compiler/translator/CodeGen.cpp',

src/compiler/translator/BaseTypes.h

@@ -18,10 +18,7 @@ enum TPrecision
     EbpUndefined,
     EbpLow,
     EbpMedium,
-    EbpHigh,
-
-    // end of list
-    EbpLast
+    EbpHigh
 };
 
 inline const char* getPrecisionString(TPrecision p)
@@ -80,9 +77,6 @@ enum TBasicType
     EbtStruct,
     EbtInterfaceBlock,
     EbtAddress,            // should be deprecated??
-
-    // end of list
-    EbtLast
 };
 
 const char* getBasicString(TBasicType t);

src/compiler/translator/Cache.cpp

-//
-// Copyright (c) 2015 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.
-//
-
-// Cache.cpp: Implements a cache for various commonly created objects.
-
-#include "common/angleutils.h"
-#include "compiler/translator/Cache.h"
-
-namespace
-{
-
-class TScopedAllocator : angle::NonCopyable
-{
-  public:
-    TScopedAllocator(TPoolAllocator *allocator)
-        : mPreviousAllocator(GetGlobalPoolAllocator())
-    {
-        SetGlobalPoolAllocator(allocator);
-    }
-    ~TScopedAllocator()
-    {
-        SetGlobalPoolAllocator(mPreviousAllocator);
-    }
-
-  private:
-    TPoolAllocator *mPreviousAllocator;
-};
-
-}  // namespace
-
-TCache::TypeKey::TypeKey(TBasicType basicType,
-                         TPrecision precision,
-                         TQualifier qualifier,
-                         unsigned char primarySize,
-                         unsigned char secondarySize)
-{
-    static_assert(sizeof(components) <= sizeof(value),
-                  "TypeKey::value is too small");
-
-    // Can't use numeric_limits::max() here because of MSVC 2013
-    const size_t MaxEnumValue = ~EnumComponentType(0);
-
-    static_assert(MaxEnumValue >= EbtLast &&
-                  MaxEnumValue >= EbpLast &&
-                  MaxEnumValue >= EvqLast,
-                  "TypeKey::EnumComponentType is too small");
-
-    value = 0;
-    components.basicType = basicType;
-    components.precision = precision;
-    components.qualifier = qualifier;
-    components.primarySize = primarySize;
-    components.secondarySize = secondarySize;
-}
-
-TCache *TCache::sCache = nullptr;
-
-void TCache::initialize()
-{
-    if (sCache == nullptr)
-    {
-        sCache = new TCache();
-    }
-}
-
-void TCache::destroy()
-{
-    SafeDelete(sCache);
-}
-
-const TType *TCache::getType(TBasicType basicType,
-                             TPrecision precision,
-                             TQualifier qualifier,
-                             unsigned char primarySize,
-                             unsigned char secondarySize)
-{
-    TypeKey key(basicType, precision, qualifier,
-                primarySize, secondarySize);
-    auto it = sCache->mTypes.find(key);
-    if (it != sCache->mTypes.end())
-    {
-        return it->second;
-    }
-
-    TScopedAllocator scopedAllocator(&sCache->mAllocator);
-
-    TType *type = new TType(basicType, precision, qualifier,
-                            primarySize, secondarySize);
-    type->realize();
-    sCache->mTypes.insert(std::make_pair(key, type));
-
-    return type;
-}

src/compiler/translator/Cache.h

-//
-// Copyright (c) 2015 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.
-//
-
-// Cache.h: Implements a cache for various commonly created objects.
-
-#ifndef COMPILER_TRANSLATOR_CACHE_H_
-#define COMPILER_TRANSLATOR_CACHE_H_
-
-#include <string.h>
-#include <map>
-
-#include "compiler/translator/Types.h"
-#include "compiler/translator/PoolAlloc.h"
-
-class TCache
-{
-  public:
-
-    static void initialize();
-    static void destroy();
-
-    static const TType *getType(TBasicType basicType,
-                                TPrecision precision)
-    {
-        return getType(basicType, precision, EvqTemporary,
-                       1, 1);
-    }
-    static const TType *getType(TBasicType basicType,
-                                unsigned char primarySize = 1,
-                                unsigned char secondarySize = 1)
-    {
-        return getType(basicType, EbpUndefined, EvqGlobal,
-                       primarySize, secondarySize);
-    }
-    static const TType *getType(TBasicType basicType,
-                                TQualifier qualifier,
-                                unsigned char primarySize = 1,
-                                unsigned char secondarySize = 1)
-    {
-        return getType(basicType, EbpUndefined, qualifier,
-                       primarySize, secondarySize);
-    }
-    static const TType *getType(TBasicType basicType,
-                                TPrecision precision,
-                                TQualifier qualifier,
-                                unsigned char primarySize,
-                                unsigned char secondarySize);
-
-  private:
-    TCache()
-    {
-    }
-
-    union TypeKey
-    {
-        TypeKey(TBasicType basicType,
-                TPrecision precision,
-                TQualifier qualifier,
-                unsigned char primarySize,
-                unsigned char secondarySize);
-
-        typedef uint8_t EnumComponentType;
-        struct
-        {
-            EnumComponentType basicType;
-            EnumComponentType precision;
-            EnumComponentType qualifier;
-            unsigned char primarySize;
-            unsigned char secondarySize;
-        } components;
-        uint64_t value;
-
-        bool operator < (const TypeKey &other) const
-        {
-            return value < other.value;
-        }
-    };
-    typedef std::map<TypeKey, const TType*> TypeMap;
-
-    TypeMap mTypes;
-    TPoolAllocator mAllocator;
-
-    static TCache *sCache;
-};
-
-#endif  // COMPILER_TRANSLATOR_CACHE_H_

src/compiler/translator/Compiler.cpp

@@ -4,7 +4,6 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/translator/Cache.h"
 #include "compiler/translator/Compiler.h"
 #include "compiler/translator/CallDAG.h"
 #include "compiler/translator/ForLoopUnroll.h"

src/compiler/translator/Initialize.cpp

@@ -11,26 +11,25 @@
 //
 
 #include "compiler/translator/Initialize.h"
-#include "compiler/translator/Cache.h"
 
 #include "compiler/translator/IntermNode.h"
 #include "angle_gl.h"
 
 void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInResources &resources, TSymbolTable &symbolTable)
 {
-    const TType *float1 = TCache::getType(EbtFloat);
-    const TType *float2 = TCache::getType(EbtFloat, 2);
-    const TType *float3 = TCache::getType(EbtFloat, 3);
-    const TType *float4 = TCache::getType(EbtFloat, 4);
-    const TType *int1 = TCache::getType(EbtInt);
-    const TType *int2 = TCache::getType(EbtInt, 2);
-    const TType *int3 = TCache::getType(EbtInt, 3);
-    const TType *uint1 = TCache::getType(EbtUInt);
-    const TType *bool1 = TCache::getType(EbtBool);
-    const TType *genType = TCache::getType(EbtGenType);
-    const TType *genIType = TCache::getType(EbtGenIType);
-    const TType *genUType = TCache::getType(EbtGenUType);
-    const TType *genBType = TCache::getType(EbtGenBType);
+    TType *float1 = new TType(EbtFloat);
+    TType *float2 = new TType(EbtFloat, 2);
+    TType *float3 = new TType(EbtFloat, 3);
+    TType *float4 = new TType(EbtFloat, 4);
+    TType *int1 = new TType(EbtInt);
+    TType *int2 = new TType(EbtInt, 2);
+    TType *int3 = new TType(EbtInt, 3);
+    TType *uint1 = new TType(EbtUInt);
+    TType *bool1 = new TType(EbtBool);
+    TType *genType = new TType(EbtGenType);
+    TType *genIType = new TType(EbtGenIType);
+    TType *genUType = new TType(EbtGenUType);
+    TType *genBType = new TType(EbtGenBType);
 
     //
     // Angle and Trigonometric Functions.
@@ -103,10 +102,14 @@ void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInR
     symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSmoothStep, genType, "smoothstep", genType, genType, genType);
     symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpSmoothStep, genType, "smoothstep", float1, float1, genType);
 
-    const TType *outFloat1 = TCache::getType(EbtFloat, EvqOut);
-    const TType *outFloat2 = TCache::getType(EbtFloat, EvqOut, 2);
-    const TType *outFloat3 = TCache::getType(EbtFloat, EvqOut, 3);
-    const TType *outFloat4 = TCache::getType(EbtFloat, EvqOut, 4);
+    TType *outFloat1 = new TType(EbtFloat);
+    TType *outFloat2 = new TType(EbtFloat, 2);
+    TType *outFloat3 = new TType(EbtFloat, 3);
+    TType *outFloat4 = new TType(EbtFloat, 4);
+    outFloat1->setQualifier(EvqOut);
+    outFloat2->setQualifier(EvqOut);
+    outFloat3->setQualifier(EvqOut);
+    outFloat4->setQualifier(EvqOut);
 
     symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpModf, float1, "modf", float1, outFloat1);
     symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpModf, float2, "modf", float2, outFloat2);
@@ -139,15 +142,15 @@ void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInR
     symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpReflect, genType, "reflect", genType, genType);
     symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpRefract, genType, "refract", genType, genType, float1);
 
-    const TType *mat2 = TCache::getType(EbtFloat, 2, 2);
-    const TType *mat3 = TCache::getType(EbtFloat, 3, 3);
-    const TType *mat4 = TCache::getType(EbtFloat, 4, 4);
-    const TType *mat2x3 = TCache::getType(EbtFloat, 2, 3);
-    const TType *mat3x2 = TCache::getType(EbtFloat, 3, 2);
-    const TType *mat2x4 = TCache::getType(EbtFloat, 2, 4);
-    const TType *mat4x2 = TCache::getType(EbtFloat, 4, 2);
-    const TType *mat3x4 = TCache::getType(EbtFloat, 3, 4);
-    const TType *mat4x3 = TCache::getType(EbtFloat, 4, 3);
+    TType *mat2 = new TType(EbtFloat, 2, 2);
+    TType *mat3 = new TType(EbtFloat, 3, 3);
+    TType *mat4 = new TType(EbtFloat, 4, 4);
+    TType *mat2x3 = new TType(EbtFloat, 2, 3);
+    TType *mat3x2 = new TType(EbtFloat, 3, 2);
+    TType *mat2x4 = new TType(EbtFloat, 2, 4);
+    TType *mat4x2 = new TType(EbtFloat, 4, 2);
+    TType *mat3x4 = new TType(EbtFloat, 3, 4);
+    TType *mat4x3 = new TType(EbtFloat, 4, 3);
 
     //
     // Matrix Functions.
@@ -190,10 +193,10 @@ void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInR
     symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpInverse, mat3, "inverse", mat3);
     symbolTable.insertBuiltIn(ESSL3_BUILTINS, EOpInverse, mat4, "inverse", mat4);
 
-    const TType *vec = TCache::getType(EbtVec);
-    const TType *ivec = TCache::getType(EbtIVec);
-    const TType *uvec = TCache::getType(EbtUVec);
-    const TType *bvec = TCache::getType(EbtBVec);
+    TType *vec = new TType(EbtVec);
+    TType *ivec = new TType(EbtIVec);
+    TType *uvec = new TType(EbtUVec);
+    TType *bvec = new TType(EbtBVec);
 
     //
     // Vector relational functions.
@@ -222,8 +225,8 @@ void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInR
     symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpAll, bool1, "all", bvec);
     symbolTable.insertBuiltIn(COMMON_BUILTINS, EOpVectorLogicalNot, bvec, "not", bvec);
 
-    const TType *sampler2D = TCache::getType(EbtSampler2D);
-    const TType *samplerCube = TCache::getType(EbtSamplerCube);
+    TType *sampler2D = new TType(EbtSampler2D);
+    TType *samplerCube = new TType(EbtSamplerCube);
 
     //
     // Texture Functions for GLSL ES 1.0
@@ -235,7 +238,7 @@ void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInR
 
     if (resources.OES_EGL_image_external)
     {
-        const TType *samplerExternalOES = TCache::getType(EbtSamplerExternalOES);
+        TType *samplerExternalOES = new TType(EbtSamplerExternalOES);
 
         symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2D", samplerExternalOES, float2);
         symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DProj", samplerExternalOES, float3);
@@ -244,7 +247,7 @@ void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInR
 
     if (resources.ARB_texture_rectangle)
     {
-        const TType *sampler2DRect = TCache::getType(EbtSampler2DRect);
+        TType *sampler2DRect = new TType(EbtSampler2DRect);
 
         symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DRect", sampler2DRect, float2);
         symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "texture2DRectProj", sampler2DRect, float3);
@@ -293,12 +296,12 @@ void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInR
         symbolTable.insertBuiltIn(ESSL1_BUILTINS, float4, "textureCubeLod", samplerCube, float3, float1);
     }
 
-    const TType *gvec4 = TCache::getType(EbtGVec4);
+    TType *gvec4 = new TType(EbtGVec4);
 
-    const TType *gsampler2D = TCache::getType(EbtGSampler2D);
-    const TType *gsamplerCube = TCache::getType(EbtGSamplerCube);
-    const TType *gsampler3D = TCache::getType(EbtGSampler3D);
-    const TType *gsampler2DArray = TCache::getType(EbtGSampler2DArray);
+    TType *gsampler2D = new TType(EbtGSampler2D);
+    TType *gsamplerCube = new TType(EbtGSamplerCube);
+    TType *gsampler3D = new TType(EbtGSampler3D);
+    TType *gsampler2DArray = new TType(EbtGSampler2DArray);
 
     //
     // Texture Functions for GLSL ES 3.0
@@ -326,9 +329,9 @@ void InsertBuiltInFunctions(sh::GLenum type, ShShaderSpec spec, const ShBuiltInR
         symbolTable.insertBuiltIn(ESSL3_BUILTINS, gvec4, "textureProj", gsampler3D, float4, float1);
     }
 
-    const TType *sampler2DShadow = TCache::getType(EbtSampler2DShadow);
-    const TType *samplerCubeShadow = TCache::getType(EbtSamplerCubeShadow);
-    const TType *sampler2DArrayShadow = TCache::getType(EbtSampler2DArrayShadow);
+    TType *sampler2DShadow = new TType(EbtSampler2DShadow);
+    TType *samplerCubeShadow = new TType(EbtSamplerCubeShadow);
+    TType *sampler2DArrayShadow = new TType(EbtSampler2DArrayShadow);
 
     symbolTable.insertBuiltIn(ESSL3_BUILTINS, float1, "texture", sampler2DShadow, float3);
     symbolTable.insertBuiltIn(ESSL3_BUILTINS, float1, "texture", samplerCubeShadow, float4);

src/compiler/translator/InitializeDll.cpp

@@ -4,7 +4,6 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/translator/Cache.h"
 #include "compiler/translator/InitializeDll.h"
 #include "compiler/translator/InitializeGlobals.h"
 #include "compiler/translator/InitializeParseContext.h"
@@ -25,8 +24,6 @@ bool InitProcess()
         return false;
     }
 
-    TCache::initialize();
-
     return true;
 }
 
@@ -34,5 +31,4 @@ void DetachProcess()
 {
     FreeParseContextIndex();
     FreePoolIndex();
-    TCache::destroy();
 }

src/compiler/translator/ParseContext.cpp

@@ -10,7 +10,6 @@
 #include <stdio.h>
 
 #include "compiler/preprocessor/SourceLocation.h"
-#include "compiler/translator/Cache.h"
 #include "compiler/translator/glslang.h"
 #include "compiler/translator/ValidateSwitch.h"
 #include "compiler/translator/ValidateGlobalInitializer.h"

src/compiler/translator/PoolAlloc.h

@@ -247,13 +247,18 @@ public:
     pointer address(reference x) const { return &x; }
     const_pointer address(const_reference x) const { return &x; }
 
-    pool_allocator() { }
-
-    template<class Other>
-    pool_allocator(const pool_allocator<Other>& p) { }
+    pool_allocator() : allocator(GetGlobalPoolAllocator()) { }
+    pool_allocator(TPoolAllocator& a) : allocator(&a) { }
+    pool_allocator(const pool_allocator<T>& p) : allocator(p.allocator) { }
 
     template <class Other>
-    pool_allocator<T>& operator=(const pool_allocator<Other>& p) { return *this; }
+    pool_allocator<T>& operator=(const pool_allocator<Other>& p) {
+      allocator = p.allocator;
+      return *this;
+    }
+
+    template<class Other>
+    pool_allocator(const pool_allocator<Other>& p) : allocator(&p.getAllocator()) { }
 
 #if defined(__SUNPRO_CC) && !defined(_RWSTD_ALLOCATOR)
     // libCStd on some platforms have a different allocate/deallocate interface.
@@ -279,13 +284,17 @@ public:
     void construct(pointer p, const T& val) { new ((void *)p) T(val); }
     void destroy(pointer p) { p->T::~T(); }
 
-    bool operator==(const pool_allocator& rhs) const { return true; }
-    bool operator!=(const pool_allocator& rhs) const { return false; }
+    bool operator==(const pool_allocator& rhs) const { return &getAllocator() == &rhs.getAllocator(); }
+    bool operator!=(const pool_allocator& rhs) const { return &getAllocator() != &rhs.getAllocator(); }
 
     size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
     size_type max_size(int size) const { return static_cast<size_type>(-1) / size; }
 
-    TPoolAllocator& getAllocator() const { return *GetGlobalPoolAllocator(); }
+    void setAllocator(TPoolAllocator* a) { allocator = a; }
+    TPoolAllocator& getAllocator() const { return *allocator; }
+
+protected:
+    TPoolAllocator* allocator;
 };
 
 #endif // COMPILER_TRANSLATOR_POOLALLOC_H_

src/compiler/translator/SymbolTable.cpp

@@ -14,7 +14,6 @@
 #endif
 
 #include "compiler/translator/SymbolTable.h"
-#include "compiler/translator/Cache.h"
 
 #include <stdio.h>
 #include <algorithm>
@@ -153,10 +152,10 @@ const TType *SpecificType(const TType *type, int size)
 
     switch(type->getBasicType())
     {
-      case EbtGenType:  return TCache::getType(EbtFloat, static_cast<unsigned char>(size));
-      case EbtGenIType: return TCache::getType(EbtInt, static_cast<unsigned char>(size));
-      case EbtGenUType: return TCache::getType(EbtUInt, static_cast<unsigned char>(size));
-      case EbtGenBType: return TCache::getType(EbtBool, static_cast<unsigned char>(size));
+      case EbtGenType:  return new TType(EbtFloat, static_cast<unsigned char>(size));
+      case EbtGenIType: return new TType(EbtInt, static_cast<unsigned char>(size));
+      case EbtGenUType: return new TType(EbtUInt, static_cast<unsigned char>(size));
+      case EbtGenBType: return new TType(EbtBool, static_cast<unsigned char>(size));
       default: return type;
     }
 }
@@ -174,10 +173,10 @@ const TType *VectorType(const TType *type, int size)
 
     switch(type->getBasicType())
     {
-      case EbtVec:  return TCache::getType(EbtFloat, static_cast<unsigned char>(size));
-      case EbtIVec: return TCache::getType(EbtInt, static_cast<unsigned char>(size));
-      case EbtUVec: return TCache::getType(EbtUInt, static_cast<unsigned char>(size));
-      case EbtBVec: return TCache::getType(EbtBool, static_cast<unsigned char>(size));
+      case EbtVec:  return new TType(EbtFloat, static_cast<unsigned char>(size));
+      case EbtIVec: return new TType(EbtInt, static_cast<unsigned char>(size));
+      case EbtUVec: return new TType(EbtUInt, static_cast<unsigned char>(size));
+      case EbtBVec: return new TType(EbtBool, static_cast<unsigned char>(size));
       default: return type;
     }
 }
@@ -188,30 +187,30 @@ void TSymbolTable::insertBuiltIn(ESymbolLevel level, TOperator op, const char *e
     if (ptype1->getBasicType() == EbtGSampler2D)
     {
         bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtFloat, 4) : rvalue, name, TCache::getType(EbtSampler2D), ptype2, ptype3, ptype4, ptype5);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtInt, 4) : rvalue, name, TCache::getType(EbtISampler2D), ptype2, ptype3, ptype4, ptype5);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtUInt, 4) : rvalue, name, TCache::getType(EbtUSampler2D), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2D), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2D), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2D), ptype2, ptype3, ptype4, ptype5);
     }
     else if (ptype1->getBasicType() == EbtGSampler3D)
     {
         bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtFloat, 4) : rvalue, name, TCache::getType(EbtSampler3D), ptype2, ptype3, ptype4, ptype5);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtInt, 4) : rvalue, name, TCache::getType(EbtISampler3D), ptype2, ptype3, ptype4, ptype5);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtUInt, 4) : rvalue, name, TCache::getType(EbtUSampler3D), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler3D), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler3D), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler3D), ptype2, ptype3, ptype4, ptype5);
     }
     else if (ptype1->getBasicType() == EbtGSamplerCube)
     {
         bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtFloat, 4) : rvalue, name, TCache::getType(EbtSamplerCube), ptype2, ptype3, ptype4, ptype5);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtInt, 4) : rvalue, name, TCache::getType(EbtISamplerCube), ptype2, ptype3, ptype4, ptype5);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtUInt, 4) : rvalue, name, TCache::getType(EbtUSamplerCube), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSamplerCube), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISamplerCube), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSamplerCube), ptype2, ptype3, ptype4, ptype5);
     }
     else if (ptype1->getBasicType() == EbtGSampler2DArray)
     {
         bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtFloat, 4) : rvalue, name, TCache::getType(EbtSampler2DArray), ptype2, ptype3, ptype4, ptype5);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtInt, 4) : rvalue, name, TCache::getType(EbtISampler2DArray), ptype2, ptype3, ptype4, ptype5);
-        insertBuiltIn(level, gvec4 ? TCache::getType(EbtUInt, 4) : rvalue, name, TCache::getType(EbtUSampler2DArray), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2DArray), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2DArray), ptype2, ptype3, ptype4, ptype5);
+        insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2DArray), ptype2, ptype3, ptype4, ptype5);
     }
     else if (IsGenType(rvalue) || IsGenType(ptype1) || IsGenType(ptype2) || IsGenType(ptype3))
     {

src/compiler/translator/Types.cpp

@@ -142,8 +142,7 @@ TString TType::buildMangledName() const
         mangledName += interfaceBlock->mangledName();
         break;
       default:
-        // EbtVoid, EbtAddress and non types
-        break;
+        UNREACHABLE();
     }
 
     if (isMatrix())

src/compiler/translator/Types.h

@@ -491,15 +491,10 @@ class TType
         return structure ? structure->containsSamplers() : false;
     }
 
-    // Initializes all lazily-initialized members.
-    void realize()
-    {
-        getMangledName();
-    }
-
   protected:
     TString buildMangledName() const;
     size_t getStructSize() const;
+    void computeDeepestStructNesting();
 
     TBasicType type;
     TPrecision precision;

src/compiler/translator/glslang.y

@@ -37,7 +37,6 @@ WHICH GENERATES THE GLSL ES PARSER (glslang_tab.cpp AND glslang_tab.h).
 #endif
 
 #include "angle_gl.h"
-#include "compiler/translator/Cache.h"
 #include "compiler/translator/SymbolTable.h"
 #include "compiler/translator/ParseContext.h"
 #include "GLSLANG/ShaderLang.h"
@@ -370,14 +369,14 @@ function_identifier
     | IDENTIFIER {
         if (context->reservedErrorCheck(@1, *$1.string))
             context->recover();
-        const TType *type = TCache::getType(EbtVoid, EbpUndefined);
+        const TType *type = new TType(EbtVoid, EbpUndefined);
         TFunction *function = new TFunction($1.string, type);
         $$ = function;
     }
     | FIELD_SELECTION {
         if (context->reservedErrorCheck(@1, *$1.string))
             context->recover();
-        const TType *type = TCache::getType(EbtVoid, EbpUndefined);
+        const TType *type = new TType(EbtVoid, EbpUndefined);
         TFunction *function = new TFunction($1.string, type);
         $$ = function;
     }

src/compiler/translator/glslang_tab.cpp

@@ -87,7 +87,6 @@
 #endif
 
 #include "angle_gl.h"
-#include "compiler/translator/Cache.h"
 #include "compiler/translator/SymbolTable.h"
 #include "compiler/translator/ParseContext.h"
 #include "GLSLANG/ShaderLang.h"
@@ -2604,7 +2603,7 @@ yyreduce:
     {
         if (context->reservedErrorCheck((yylsp[0]), *(yyvsp[0].lex).string))
             context->recover();
-        const TType *type = TCache::getType(EbtVoid, EbpUndefined);
+        const TType *type = new TType(EbtVoid, EbpUndefined);
         TFunction *function = new TFunction((yyvsp[0].lex).string, type);
         (yyval.interm.function) = function;
     }
@@ -2616,7 +2615,7 @@ yyreduce:
     {
         if (context->reservedErrorCheck((yylsp[0]), *(yyvsp[0].lex).string))
             context->recover();
-        const TType *type = TCache::getType(EbtVoid, EbpUndefined);
+        const TType *type = new TType(EbtVoid, EbpUndefined);
         TFunction *function = new TFunction((yyvsp[0].lex).string, type);
         (yyval.interm.function) = function;
     }