1 // 2 // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved. 3 // Use of this source code is governed by a BSD-style license that can be 4 // found in the LICENSE file. 5 // 6 7 #ifndef _SHHANDLE_INCLUDED_ 8 #define _SHHANDLE_INCLUDED_ 9 10 // 11 // Machine independent part of the compiler private objects 12 // sent as ShHandle to the driver. 13 // 14 // This should not be included by driver code. 15 // 16 17 #include "compiler/translator/BuiltInFunctionEmulator.h" 18 #include "compiler/translator/ExtensionBehavior.h" 19 #include "compiler/translator/HashNames.h" 20 #include "compiler/translator/InfoSink.h" 21 #include "compiler/translator/SymbolTable.h" 22 #include "compiler/translator/VariableInfo.h" 23 #include "third_party/compiler/ArrayBoundsClamper.h" 24 25 class TCompiler; 26 class TDependencyGraph; 27 class TranslatorHLSL; 28 29 // 30 // Helper function to identify specs that are based on the WebGL spec, 31 // like the CSS Shaders spec. 32 // 33 bool IsWebGLBasedSpec(ShShaderSpec spec); 34 35 // 36 // The base class used to back handles returned to the driver. 37 // 38 class TShHandleBase { 39 public: 40 TShHandleBase(); 41 virtual ~TShHandleBase(); 42 virtual TCompiler* getAsCompiler() { return 0; } 43 virtual TranslatorHLSL* getAsTranslatorHLSL() { return 0; } 44 45 protected: 46 // Memory allocator. Allocates and tracks memory required by the compiler. 47 // Deallocates all memory when compiler is destructed. 48 TPoolAllocator allocator; 49 }; 50 51 // 52 // The base class for the machine dependent compiler to derive from 53 // for managing object code from the compile. 54 // 55 class TCompiler : public TShHandleBase 56 { 57 public: 58 TCompiler(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output); 59 virtual ~TCompiler(); 60 virtual TCompiler* getAsCompiler() { return this; } 61 62 bool Init(const ShBuiltInResources& resources); 63 bool compile(const char* const shaderStrings[], 64 size_t numStrings, 65 int compileOptions); 66 67 // Get results of the last compilation. 68 int getShaderVersion() const { return shaderVersion; } 69 TInfoSink& getInfoSink() { return infoSink; } 70 71 const std::vector<sh::Attribute> &getAttributes() const { return attributes; } 72 const std::vector<sh::Attribute> &getOutputVariables() const { return outputVariables; } 73 const std::vector<sh::Uniform> &getUniforms() const { return uniforms; } 74 const std::vector<sh::ShaderVariable> &getExpandedUniforms() const { return expandedUniforms; } 75 const std::vector<sh::Varying> &getVaryings() const { return varyings; } 76 const std::vector<sh::ShaderVariable> &getExpandedVaryings() const { return expandedVaryings; } 77 const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const { return interfaceBlocks; } 78 79 ShHashFunction64 getHashFunction() const { return hashFunction; } 80 NameMap& getNameMap() { return nameMap; } 81 TSymbolTable& getSymbolTable() { return symbolTable; } 82 ShShaderSpec getShaderSpec() const { return shaderSpec; } 83 ShShaderOutput getOutputType() const { return outputType; } 84 std::string getBuiltInResourcesString() const { return builtInResourcesString; } 85 86 // Get the resources set by InitBuiltInSymbolTable 87 const ShBuiltInResources& getResources() const; 88 89 protected: 90 sh::GLenum getShaderType() const { return shaderType; } 91 // Initialize symbol-table with built-in symbols. 92 bool InitBuiltInSymbolTable(const ShBuiltInResources& resources); 93 // Compute the string representation of the built-in resources 94 void setResourceString(); 95 // Clears the results from the previous compilation. 96 void clearResults(); 97 // Return true if function recursion is detected or call depth exceeded. 98 bool detectCallDepth(TIntermNode* root, TInfoSink& infoSink, bool limitCallStackDepth); 99 // Returns true if a program has no conflicting or missing fragment outputs 100 bool validateOutputs(TIntermNode* root); 101 // Rewrites a shader's intermediate tree according to the CSS Shaders spec. 102 void rewriteCSSShader(TIntermNode* root); 103 // Returns true if the given shader does not exceed the minimum 104 // functionality mandated in GLSL 1.0 spec Appendix A. 105 bool validateLimitations(TIntermNode* root); 106 // Collect info for all attribs, uniforms, varyings. 107 void collectVariables(TIntermNode* root); 108 // Translate to object code. 109 virtual void translate(TIntermNode* root) = 0; 110 // Returns true if, after applying the packing rules in the GLSL 1.017 spec 111 // Appendix A, section 7, the shader does not use too many uniforms. 112 bool enforcePackingRestrictions(); 113 // Insert statements to initialize varyings without static use in the beginning 114 // of main(). It is to work around a Mac driver where such varyings in a vertex 115 // shader may be optimized out incorrectly at compile time, causing a link failure. 116 // This function should only be applied to vertex shaders. 117 void initializeVaryingsWithoutStaticUse(TIntermNode* root); 118 // Insert gl_Position = vec4(0,0,0,0) to the beginning of main(). 119 // It is to work around a Linux driver bug where missing this causes compile failure 120 // while spec says it is allowed. 121 // This function should only be applied to vertex shaders. 122 void initializeGLPosition(TIntermNode* root); 123 // Returns true if the shader passes the restrictions that aim to prevent timing attacks. 124 bool enforceTimingRestrictions(TIntermNode* root, bool outputGraph); 125 // Returns true if the shader does not use samplers. 126 bool enforceVertexShaderTimingRestrictions(TIntermNode* root); 127 // Returns true if the shader does not use sampler dependent values to affect control 128 // flow or in operations whose time can depend on the input values. 129 bool enforceFragmentShaderTimingRestrictions(const TDependencyGraph& graph); 130 // Return true if the maximum expression complexity is below the limit. 131 bool limitExpressionComplexity(TIntermNode* root); 132 // Get built-in extensions with default behavior. 133 const TExtensionBehavior& getExtensionBehavior() const; 134 135 const ArrayBoundsClamper& getArrayBoundsClamper() const; 136 ShArrayIndexClampingStrategy getArrayIndexClampingStrategy() const; 137 const BuiltInFunctionEmulator& getBuiltInFunctionEmulator() const; 138 139 std::vector<sh::Attribute> attributes; 140 std::vector<sh::Attribute> outputVariables; 141 std::vector<sh::Uniform> uniforms; 142 std::vector<sh::ShaderVariable> expandedUniforms; 143 std::vector<sh::Varying> varyings; 144 std::vector<sh::ShaderVariable> expandedVaryings; 145 std::vector<sh::InterfaceBlock> interfaceBlocks; 146 147 private: 148 sh::GLenum shaderType; 149 ShShaderSpec shaderSpec; 150 ShShaderOutput outputType; 151 152 int maxUniformVectors; 153 int maxExpressionComplexity; 154 int maxCallStackDepth; 155 156 ShBuiltInResources compileResources; 157 std::string builtInResourcesString; 158 159 // Built-in symbol table for the given language, spec, and resources. 160 // It is preserved from compile-to-compile. 161 TSymbolTable symbolTable; 162 // Built-in extensions with default behavior. 163 TExtensionBehavior extensionBehavior; 164 bool fragmentPrecisionHigh; 165 166 ArrayBoundsClamper arrayBoundsClamper; 167 ShArrayIndexClampingStrategy clampingStrategy; 168 BuiltInFunctionEmulator builtInFunctionEmulator; 169 170 // Results of compilation. 171 int shaderVersion; 172 TInfoSink infoSink; // Output sink. 173 174 // name hashing. 175 ShHashFunction64 hashFunction; 176 NameMap nameMap; 177 }; 178 179 // 180 // This is the interface between the machine independent code 181 // and the machine dependent code. 182 // 183 // The machine dependent code should derive from the classes 184 // above. Then Construct*() and Delete*() will create and 185 // destroy the machine dependent objects, which contain the 186 // above machine independent information. 187 // 188 TCompiler* ConstructCompiler( 189 sh::GLenum type, ShShaderSpec spec, ShShaderOutput output); 190 void DeleteCompiler(TCompiler*); 191 192 #endif // _SHHANDLE_INCLUDED_ 193
