1 // Copyright 2016 The SwiftShader Authors. All Rights Reserved. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #include "Compiler.h" 16 17 #include "AnalyzeCallDepth.h" 18 #include "Initialize.h" 19 #include "InitializeParseContext.h" 20 #include "InitializeGlobals.h" 21 #include "ParseHelper.h" 22 #include "ValidateLimitations.h" 23 24 namespace 25 { 26 class TScopedPoolAllocator { 27 public: 28 TScopedPoolAllocator(TPoolAllocator* allocator, bool pushPop) 29 : mAllocator(allocator), mPushPopAllocator(pushPop) 30 { 31 if (mPushPopAllocator) mAllocator->push(); 32 SetGlobalPoolAllocator(mAllocator); 33 } 34 ~TScopedPoolAllocator() 35 { 36 SetGlobalPoolAllocator(nullptr); 37 if (mPushPopAllocator) mAllocator->pop(); 38 } 39 40 private: 41 TPoolAllocator* mAllocator; 42 bool mPushPopAllocator; 43 }; 44 } // namespace 45 46 // 47 // Initialize built-in resources with minimum expected values. 48 // 49 ShBuiltInResources::ShBuiltInResources() 50 { 51 // Constants. 52 MaxVertexAttribs = 8; 53 MaxVertexUniformVectors = 128; 54 MaxVaryingVectors = 8; 55 MaxVertexTextureImageUnits = 0; 56 MaxCombinedTextureImageUnits = 8; 57 MaxTextureImageUnits = 8; 58 MaxFragmentUniformVectors = 16; 59 MaxDrawBuffers = 1; 60 MaxVertexOutputVectors = 16; 61 MaxFragmentInputVectors = 15; 62 MinProgramTexelOffset = -8; 63 MaxProgramTexelOffset = 7; 64 65 // Extensions. 66 OES_standard_derivatives = 0; 67 OES_fragment_precision_high = 0; 68 OES_EGL_image_external = 0; 69 OES_EGL_image_external_essl3 = 0; 70 71 MaxCallStackDepth = UINT_MAX; 72 } 73 74 TCompiler::TCompiler(GLenum type) 75 : shaderType(type), 76 maxCallStackDepth(UINT_MAX) 77 { 78 allocator.push(); 79 SetGlobalPoolAllocator(&allocator); 80 } 81 82 TCompiler::~TCompiler() 83 { 84 SetGlobalPoolAllocator(nullptr); 85 allocator.popAll(); 86 } 87 88 bool TCompiler::Init(const ShBuiltInResources& resources) 89 { 90 shaderVersion = 100; 91 maxCallStackDepth = resources.MaxCallStackDepth; 92 TScopedPoolAllocator scopedAlloc(&allocator, false); 93 94 // Generate built-in symbol table. 95 if (!InitBuiltInSymbolTable(resources)) 96 return false; 97 InitExtensionBehavior(resources, extensionBehavior); 98 99 return true; 100 } 101 102 bool TCompiler::compile(const char* const shaderStrings[], 103 const int numStrings, 104 int compileOptions) 105 { 106 TScopedPoolAllocator scopedAlloc(&allocator, true); 107 clearResults(); 108 109 if (numStrings == 0) 110 return true; 111 112 // First string is path of source file if flag is set. The actual source follows. 113 const char* sourcePath = nullptr; 114 int firstSource = 0; 115 if (compileOptions & SH_SOURCE_PATH) 116 { 117 sourcePath = shaderStrings[0]; 118 ++firstSource; 119 } 120 121 TIntermediate intermediate(infoSink); 122 TParseContext parseContext(symbolTable, extensionBehavior, intermediate, 123 shaderType, compileOptions, true, 124 sourcePath, infoSink); 125 SetGlobalParseContext(&parseContext); 126 127 // We preserve symbols at the built-in level from compile-to-compile. 128 // Start pushing the user-defined symbols at global level. 129 symbolTable.push(); 130 if (!symbolTable.atGlobalLevel()) 131 infoSink.info.message(EPrefixInternalError, "Wrong symbol table level"); 132 133 // Parse shader. 134 bool success = 135 (PaParseStrings(numStrings - firstSource, &shaderStrings[firstSource], nullptr, &parseContext) == 0) && 136 (parseContext.getTreeRoot() != nullptr); 137 138 shaderVersion = parseContext.getShaderVersion(); 139 140 if (success) { 141 TIntermNode* root = parseContext.getTreeRoot(); 142 success = intermediate.postProcess(root); 143 144 if (success) 145 success = validateCallDepth(root, infoSink); 146 147 if (success && (compileOptions & SH_VALIDATE_LOOP_INDEXING)) 148 success = validateLimitations(root); 149 150 if (success && (compileOptions & SH_INTERMEDIATE_TREE)) 151 intermediate.outputTree(root); 152 153 if (success && (compileOptions & SH_OBJECT_CODE)) 154 success = translate(root); 155 } 156 157 // Ensure symbol table is returned to the built-in level, 158 // throwing away all but the built-ins. 159 while (!symbolTable.atBuiltInLevel()) 160 symbolTable.pop(); 161 162 return success; 163 } 164 165 bool TCompiler::InitBuiltInSymbolTable(const ShBuiltInResources &resources) 166 { 167 assert(symbolTable.isEmpty()); 168 symbolTable.push(); // COMMON_BUILTINS 169 symbolTable.push(); // ESSL1_BUILTINS 170 symbolTable.push(); // ESSL3_BUILTINS 171 172 TPublicType integer; 173 integer.type = EbtInt; 174 integer.primarySize = 1; 175 integer.secondarySize = 1; 176 integer.array = false; 177 178 TPublicType floatingPoint; 179 floatingPoint.type = EbtFloat; 180 floatingPoint.primarySize = 1; 181 floatingPoint.secondarySize = 1; 182 floatingPoint.array = false; 183 184 switch(shaderType) 185 { 186 case GL_FRAGMENT_SHADER: 187 symbolTable.setDefaultPrecision(integer, EbpMedium); 188 break; 189 case GL_VERTEX_SHADER: 190 symbolTable.setDefaultPrecision(integer, EbpHigh); 191 symbolTable.setDefaultPrecision(floatingPoint, EbpHigh); 192 break; 193 default: assert(false && "Language not supported"); 194 } 195 196 InsertBuiltInFunctions(shaderType, resources, symbolTable); 197 198 IdentifyBuiltIns(shaderType, resources, symbolTable); 199 200 return true; 201 } 202 203 void TCompiler::clearResults() 204 { 205 infoSink.info.erase(); 206 infoSink.obj.erase(); 207 infoSink.debug.erase(); 208 } 209 210 bool TCompiler::validateCallDepth(TIntermNode *root, TInfoSink &infoSink) 211 { 212 AnalyzeCallDepth validator(root); 213 214 unsigned int depth = validator.analyzeCallDepth(); 215 216 if(depth == 0) 217 { 218 infoSink.info.prefix(EPrefixError); 219 infoSink.info << "Missing main()"; 220 return false; 221 } 222 else if(depth == UINT_MAX) 223 { 224 infoSink.info.prefix(EPrefixError); 225 infoSink.info << "Function recursion detected"; 226 return false; 227 } 228 else if(depth > maxCallStackDepth) 229 { 230 infoSink.info.prefix(EPrefixError); 231 infoSink.info << "Function call stack too deep (depth was "; 232 infoSink.info << depth; 233 infoSink.info << " while maximum call stack depth is "; 234 infoSink.info << maxCallStackDepth; 235 infoSink.info << ")"; 236 return false; 237 } 238 239 return true; 240 } 241 242 bool TCompiler::validateLimitations(TIntermNode* root) { 243 ValidateLimitations validate(shaderType, infoSink.info); 244 root->traverse(&validate); 245 return validate.numErrors() == 0; 246 } 247 248 const TExtensionBehavior& TCompiler::getExtensionBehavior() const 249 { 250 return extensionBehavior; 251 } 252 253 bool InitCompilerGlobals() 254 { 255 if(!InitializePoolIndex()) 256 { 257 assert(0 && "InitCompilerGlobals(): Failed to initalize global pool"); 258 return false; 259 } 260 261 if(!InitializeParseContextIndex()) 262 { 263 assert(0 && "InitCompilerGlobals(): Failed to initalize parse context"); 264 return false; 265 } 266 267 return true; 268 } 269 270 void FreeCompilerGlobals() 271 { 272 FreeParseContextIndex(); 273 FreePoolIndex(); 274 } 275
