clang-tidy: Fix unnecessary copy of for loop variables in ANGLE
[WebKit-https.git] / Source / ThirdParty / ANGLE / src / compiler / translator / Compiler.cpp
1 //
2 // Copyright (c) 2002-2014 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 #include "compiler/translator/Compiler.h"
8
9 #include <sstream>
10
11 #include "angle_gl.h"
12 #include "common/utilities.h"
13 #include "compiler/translator/AddAndTrueToLoopCondition.h"
14 #include "compiler/translator/Cache.h"
15 #include "compiler/translator/CallDAG.h"
16 #include "compiler/translator/ClampPointSize.h"
17 #include "compiler/translator/CollectVariables.h"
18 #include "compiler/translator/DeclareAndInitBuiltinsForInstancedMultiview.h"
19 #include "compiler/translator/DeferGlobalInitializers.h"
20 #include "compiler/translator/EmulateGLFragColorBroadcast.h"
21 #include "compiler/translator/EmulatePrecision.h"
22 #include "compiler/translator/Initialize.h"
23 #include "compiler/translator/InitializeVariables.h"
24 #include "compiler/translator/IntermNodePatternMatcher.h"
25 #include "compiler/translator/IsASTDepthBelowLimit.h"
26 #include "compiler/translator/OutputTree.h"
27 #include "compiler/translator/ParseContext.h"
28 #include "compiler/translator/PruneNoOps.h"
29 #include "compiler/translator/RegenerateStructNames.h"
30 #include "compiler/translator/RemoveArrayLengthMethod.h"
31 #include "compiler/translator/RemoveEmptySwitchStatements.h"
32 #include "compiler/translator/RemoveInvariantDeclaration.h"
33 #include "compiler/translator/RemoveNoOpCasesFromEndOfSwitchStatements.h"
34 #include "compiler/translator/RemovePow.h"
35 #include "compiler/translator/RemoveUnreferencedVariables.h"
36 #include "compiler/translator/RewriteDoWhile.h"
37 #include "compiler/translator/ScalarizeVecAndMatConstructorArgs.h"
38 #include "compiler/translator/SeparateDeclarations.h"
39 #include "compiler/translator/SimplifyLoopConditions.h"
40 #include "compiler/translator/SplitSequenceOperator.h"
41 #include "compiler/translator/UnfoldShortCircuitAST.h"
42 #include "compiler/translator/UseInterfaceBlockFields.h"
43 #include "compiler/translator/ValidateLimitations.h"
44 #include "compiler/translator/ValidateMaxParameters.h"
45 #include "compiler/translator/ValidateOutputs.h"
46 #include "compiler/translator/ValidateVaryingLocations.h"
47 #include "compiler/translator/VariablePacker.h"
48 #include "compiler/translator/VectorizeVectorScalarArithmetic.h"
49 #include "compiler/translator/util.h"
50 #include "third_party/compiler/ArrayBoundsClamper.h"
51
52 namespace sh
53 {
54
55 namespace
56 {
57
58 #if defined(ANGLE_ENABLE_FUZZER_CORPUS_OUTPUT)
59 void DumpFuzzerCase(char const *const *shaderStrings,
60                     size_t numStrings,
61                     uint32_t type,
62                     uint32_t spec,
63                     uint32_t output,
64                     uint64_t options)
65 {
66     static int fileIndex = 0;
67
68     std::ostringstream o;
69     o << "corpus/" << fileIndex++ << ".sample";
70     std::string s = o.str();
71
72     // Must match the input format of the fuzzer
73     FILE *f = fopen(s.c_str(), "w");
74     fwrite(&type, sizeof(type), 1, f);
75     fwrite(&spec, sizeof(spec), 1, f);
76     fwrite(&output, sizeof(output), 1, f);
77     fwrite(&options, sizeof(options), 1, f);
78
79     char zero[128 - 20] = {0};
80     fwrite(&zero, 128 - 20, 1, f);
81
82     for (size_t i = 0; i < numStrings; i++)
83     {
84         fwrite(shaderStrings[i], sizeof(char), strlen(shaderStrings[i]), f);
85     }
86     fwrite(&zero, 1, 1, f);
87
88     fclose(f);
89 }
90 #endif  // defined(ANGLE_ENABLE_FUZZER_CORPUS_OUTPUT)
91 }  // anonymous namespace
92
93 bool IsWebGLBasedSpec(ShShaderSpec spec)
94 {
95     return (spec == SH_WEBGL_SPEC || spec == SH_WEBGL2_SPEC || spec == SH_WEBGL3_SPEC);
96 }
97
98 bool IsGLSL130OrNewer(ShShaderOutput output)
99 {
100     return (output == SH_GLSL_130_OUTPUT || output == SH_GLSL_140_OUTPUT ||
101             output == SH_GLSL_150_CORE_OUTPUT || output == SH_GLSL_330_CORE_OUTPUT ||
102             output == SH_GLSL_400_CORE_OUTPUT || output == SH_GLSL_410_CORE_OUTPUT ||
103             output == SH_GLSL_420_CORE_OUTPUT || output == SH_GLSL_430_CORE_OUTPUT ||
104             output == SH_GLSL_440_CORE_OUTPUT || output == SH_GLSL_450_CORE_OUTPUT);
105 }
106
107 bool IsGLSL420OrNewer(ShShaderOutput output)
108 {
109     return (output == SH_GLSL_420_CORE_OUTPUT || output == SH_GLSL_430_CORE_OUTPUT ||
110             output == SH_GLSL_440_CORE_OUTPUT || output == SH_GLSL_450_CORE_OUTPUT);
111 }
112
113 bool IsGLSL410OrOlder(ShShaderOutput output)
114 {
115     return (output == SH_GLSL_130_OUTPUT || output == SH_GLSL_140_OUTPUT ||
116             output == SH_GLSL_150_CORE_OUTPUT || output == SH_GLSL_330_CORE_OUTPUT ||
117             output == SH_GLSL_400_CORE_OUTPUT || output == SH_GLSL_410_CORE_OUTPUT);
118 }
119
120 bool RemoveInvariant(sh::GLenum shaderType,
121                      int shaderVersion,
122                      ShShaderOutput outputType,
123                      ShCompileOptions compileOptions)
124 {
125     if ((compileOptions & SH_DONT_REMOVE_INVARIANT_FOR_FRAGMENT_INPUT) == 0 &&
126         shaderType == GL_FRAGMENT_SHADER && IsGLSL420OrNewer(outputType))
127         return true;
128
129     if ((compileOptions & SH_REMOVE_INVARIANT_AND_CENTROID_FOR_ESSL3) != 0 &&
130         shaderVersion >= 300 && shaderType == GL_VERTEX_SHADER)
131         return true;
132
133     return false;
134 }
135
136 size_t GetGlobalMaxTokenSize(ShShaderSpec spec)
137 {
138     // WebGL defines a max token length of 256, while ES2 leaves max token
139     // size undefined. ES3 defines a max size of 1024 characters.
140     switch (spec)
141     {
142         case SH_WEBGL_SPEC:
143             return 256;
144         default:
145             return 1024;
146     }
147 }
148
149 int GetMaxUniformVectorsForShaderType(GLenum shaderType, const ShBuiltInResources &resources)
150 {
151     switch (shaderType)
152     {
153         case GL_VERTEX_SHADER:
154             return resources.MaxVertexUniformVectors;
155         case GL_FRAGMENT_SHADER:
156             return resources.MaxFragmentUniformVectors;
157
158         // TODO (jiawei.shao@intel.com): check if we need finer-grained component counting
159         case GL_COMPUTE_SHADER:
160             return resources.MaxComputeUniformComponents / 4;
161         case GL_GEOMETRY_SHADER_OES:
162             return resources.MaxGeometryUniformComponents / 4;
163         default:
164             UNREACHABLE();
165             return -1;
166     }
167 }
168
169 namespace
170 {
171
172 class TScopedPoolAllocator
173 {
174   public:
175     TScopedPoolAllocator(TPoolAllocator *allocator) : mAllocator(allocator)
176     {
177         mAllocator->push();
178         SetGlobalPoolAllocator(mAllocator);
179     }
180     ~TScopedPoolAllocator()
181     {
182         SetGlobalPoolAllocator(nullptr);
183         mAllocator->pop();
184     }
185
186   private:
187     TPoolAllocator *mAllocator;
188 };
189
190 class TScopedSymbolTableLevel
191 {
192   public:
193     TScopedSymbolTableLevel(TSymbolTable *table) : mTable(table)
194     {
195         ASSERT(mTable->atBuiltInLevel());
196         mTable->push();
197     }
198     ~TScopedSymbolTableLevel()
199     {
200         while (!mTable->atBuiltInLevel())
201             mTable->pop();
202     }
203
204   private:
205     TSymbolTable *mTable;
206 };
207
208 int MapSpecToShaderVersion(ShShaderSpec spec)
209 {
210     switch (spec)
211     {
212         case SH_GLES2_SPEC:
213         case SH_WEBGL_SPEC:
214             return 100;
215         case SH_GLES3_SPEC:
216         case SH_WEBGL2_SPEC:
217             return 300;
218         case SH_GLES3_1_SPEC:
219         case SH_WEBGL3_SPEC:
220             return 310;
221         default:
222             UNREACHABLE();
223             return 0;
224     }
225 }
226
227 }  // namespace
228
229 TShHandleBase::TShHandleBase()
230 {
231     allocator.push();
232     SetGlobalPoolAllocator(&allocator);
233 }
234
235 TShHandleBase::~TShHandleBase()
236 {
237     SetGlobalPoolAllocator(nullptr);
238     allocator.popAll();
239 }
240
241 TCompiler::TCompiler(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output)
242     : variablesCollected(false),
243       mGLPositionInitialized(false),
244       shaderType(type),
245       shaderSpec(spec),
246       outputType(output),
247       maxUniformVectors(0),
248       maxExpressionComplexity(0),
249       maxCallStackDepth(0),
250       maxFunctionParameters(0),
251       fragmentPrecisionHigh(false),
252       clampingStrategy(SH_CLAMP_WITH_CLAMP_INTRINSIC),
253       builtInFunctionEmulator(),
254       mDiagnostics(infoSink.info),
255       mSourcePath(nullptr),
256       mComputeShaderLocalSizeDeclared(false),
257       mComputeShaderLocalSize(1),
258       mGeometryShaderMaxVertices(-1),
259       mGeometryShaderInvocations(0),
260       mGeometryShaderInputPrimitiveType(EptUndefined),
261       mGeometryShaderOutputPrimitiveType(EptUndefined)
262 {
263 }
264
265 TCompiler::~TCompiler()
266 {
267 }
268
269 bool TCompiler::shouldRunLoopAndIndexingValidation(ShCompileOptions compileOptions) const
270 {
271     // If compiling an ESSL 1.00 shader for WebGL, or if its been requested through the API,
272     // validate loop and indexing as well (to verify that the shader only uses minimal functionality
273     // of ESSL 1.00 as in Appendix A of the spec).
274     return (IsWebGLBasedSpec(shaderSpec) && shaderVersion == 100) ||
275            (compileOptions & SH_VALIDATE_LOOP_INDEXING);
276 }
277
278 bool TCompiler::Init(const ShBuiltInResources &resources)
279 {
280     shaderVersion = 100;
281
282     maxUniformVectors = GetMaxUniformVectorsForShaderType(shaderType, resources);
283
284     maxExpressionComplexity = resources.MaxExpressionComplexity;
285     maxCallStackDepth       = resources.MaxCallStackDepth;
286     maxFunctionParameters   = resources.MaxFunctionParameters;
287
288     SetGlobalPoolAllocator(&allocator);
289
290     // Generate built-in symbol table.
291     if (!InitBuiltInSymbolTable(resources))
292         return false;
293     InitExtensionBehavior(resources, extensionBehavior);
294     fragmentPrecisionHigh = resources.FragmentPrecisionHigh == 1;
295
296     arrayBoundsClamper.SetClampingStrategy(resources.ArrayIndexClampingStrategy);
297     clampingStrategy = resources.ArrayIndexClampingStrategy;
298
299     hashFunction = resources.HashFunction;
300
301     return true;
302 }
303
304 TIntermBlock *TCompiler::compileTreeForTesting(const char *const shaderStrings[],
305                                                size_t numStrings,
306                                                ShCompileOptions compileOptions)
307 {
308     return compileTreeImpl(shaderStrings, numStrings, compileOptions);
309 }
310
311 TIntermBlock *TCompiler::compileTreeImpl(const char *const shaderStrings[],
312                                          size_t numStrings,
313                                          const ShCompileOptions compileOptions)
314 {
315     clearResults();
316
317     ASSERT(numStrings > 0);
318     ASSERT(GetGlobalPoolAllocator());
319
320     // Reset the extension behavior for each compilation unit.
321     ResetExtensionBehavior(extensionBehavior);
322
323     // First string is path of source file if flag is set. The actual source follows.
324     size_t firstSource = 0;
325     if (compileOptions & SH_SOURCE_PATH)
326     {
327         mSourcePath = shaderStrings[0];
328         ++firstSource;
329     }
330
331     TParseContext parseContext(symbolTable, extensionBehavior, shaderType, shaderSpec,
332                                compileOptions, true, &mDiagnostics, getResources());
333
334     parseContext.setFragmentPrecisionHighOnESSL1(fragmentPrecisionHigh);
335
336     // We preserve symbols at the built-in level from compile-to-compile.
337     // Start pushing the user-defined symbols at global level.
338     TScopedSymbolTableLevel scopedSymbolLevel(&symbolTable);
339
340     // Parse shader.
341     if (PaParseStrings(numStrings - firstSource, &shaderStrings[firstSource], nullptr,
342                        &parseContext) != 0)
343     {
344         return nullptr;
345     }
346
347     if (parseContext.getTreeRoot() == nullptr)
348     {
349         return nullptr;
350     }
351
352     setASTMetadata(parseContext);
353
354     if (MapSpecToShaderVersion(shaderSpec) < shaderVersion)
355     {
356         mDiagnostics.globalError("unsupported shader version");
357         return nullptr;
358     }
359
360     TIntermBlock *root = parseContext.getTreeRoot();
361     if (!checkAndSimplifyAST(root, parseContext, compileOptions))
362     {
363         return nullptr;
364     }
365
366     return root;
367 }
368
369 void TCompiler::setASTMetadata(const TParseContext &parseContext)
370 {
371     shaderVersion = parseContext.getShaderVersion();
372
373     mPragma = parseContext.pragma();
374     symbolTable.setGlobalInvariant(mPragma.stdgl.invariantAll);
375
376     mComputeShaderLocalSizeDeclared = parseContext.isComputeShaderLocalSizeDeclared();
377     mComputeShaderLocalSize         = parseContext.getComputeShaderLocalSize();
378
379     mNumViews = parseContext.getNumViews();
380
381     // Highp might have been auto-enabled based on shader version
382     fragmentPrecisionHigh = parseContext.getFragmentPrecisionHigh();
383
384     if (shaderType == GL_GEOMETRY_SHADER_OES)
385     {
386         mGeometryShaderInputPrimitiveType  = parseContext.getGeometryShaderInputPrimitiveType();
387         mGeometryShaderOutputPrimitiveType = parseContext.getGeometryShaderOutputPrimitiveType();
388         mGeometryShaderMaxVertices         = parseContext.getGeometryShaderMaxVertices();
389         mGeometryShaderInvocations         = parseContext.getGeometryShaderInvocations();
390     }
391 }
392
393 bool TCompiler::checkAndSimplifyAST(TIntermBlock *root,
394                                     const TParseContext &parseContext,
395                                     ShCompileOptions compileOptions)
396 {
397     // Disallow expressions deemed too complex.
398     if ((compileOptions & SH_LIMIT_EXPRESSION_COMPLEXITY) && !limitExpressionComplexity(root))
399     {
400         return false;
401     }
402
403     // We prune no-ops to work around driver bugs and to keep AST processing and output simple.
404     // The following kinds of no-ops are pruned:
405     //   1. Empty declarations "int;".
406     //   2. Literal statements: "1.0;". The ESSL output doesn't define a default precision
407     //      for float, so float literal statements would end up with no precision which is
408     //      invalid ESSL.
409     // After this empty declarations are not allowed in the AST.
410     PruneNoOps(root);
411
412     // In case the last case inside a switch statement is a certain type of no-op, GLSL
413     // compilers in drivers may not accept it. In this case we clean up the dead code from the
414     // end of switch statements. This is also required because PruneNoOps may have left switch
415     // statements that only contained an empty declaration inside the final case in an invalid
416     // state. Relies on that PruneNoOps has already been run.
417     RemoveNoOpCasesFromEndOfSwitchStatements(root, &symbolTable);
418
419     // Remove empty switch statements - this makes output simpler.
420     RemoveEmptySwitchStatements(root);
421
422     // Create the function DAG and check there is no recursion
423     if (!initCallDag(root))
424     {
425         return false;
426     }
427
428     if ((compileOptions & SH_LIMIT_CALL_STACK_DEPTH) && !checkCallDepth())
429     {
430         return false;
431     }
432
433     // Checks which functions are used and if "main" exists
434     functionMetadata.clear();
435     functionMetadata.resize(mCallDag.size());
436     if (!tagUsedFunctions())
437     {
438         return false;
439     }
440
441     if (!(compileOptions & SH_DONT_PRUNE_UNUSED_FUNCTIONS))
442     {
443         pruneUnusedFunctions(root);
444     }
445
446     if (shaderVersion >= 310 && !ValidateVaryingLocations(root, &mDiagnostics, shaderType))
447     {
448         return false;
449     }
450
451     if (shaderVersion >= 300 && shaderType == GL_FRAGMENT_SHADER &&
452         !ValidateOutputs(root, getExtensionBehavior(), compileResources.MaxDrawBuffers,
453                          &mDiagnostics))
454     {
455         return false;
456     }
457
458     if (shouldRunLoopAndIndexingValidation(compileOptions) &&
459         !ValidateLimitations(root, shaderType, &symbolTable, shaderVersion, &mDiagnostics))
460     {
461         return false;
462     }
463
464     // Fail compilation if precision emulation not supported.
465     if (getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision &&
466         !EmulatePrecision::SupportedInLanguage(outputType))
467     {
468         mDiagnostics.globalError("Precision emulation not supported for this output type.");
469         return false;
470     }
471
472     // Clamping uniform array bounds needs to happen after validateLimitations pass.
473     if (compileOptions & SH_CLAMP_INDIRECT_ARRAY_BOUNDS)
474     {
475         arrayBoundsClamper.MarkIndirectArrayBoundsForClamping(root);
476     }
477
478     if ((compileOptions & SH_INITIALIZE_BUILTINS_FOR_INSTANCED_MULTIVIEW) &&
479         parseContext.isExtensionEnabled(TExtension::OVR_multiview) &&
480         getShaderType() != GL_COMPUTE_SHADER)
481     {
482         DeclareAndInitBuiltinsForInstancedMultiview(root, mNumViews, shaderType, compileOptions,
483                                                     outputType, &symbolTable);
484     }
485
486     // This pass might emit short circuits so keep it before the short circuit unfolding
487     if (compileOptions & SH_REWRITE_DO_WHILE_LOOPS)
488         RewriteDoWhile(root, &symbolTable);
489
490     if (compileOptions & SH_ADD_AND_TRUE_TO_LOOP_CONDITION)
491         sh::AddAndTrueToLoopCondition(root);
492
493     if (compileOptions & SH_UNFOLD_SHORT_CIRCUIT)
494     {
495         UnfoldShortCircuitAST unfoldShortCircuit;
496         root->traverse(&unfoldShortCircuit);
497         unfoldShortCircuit.updateTree();
498     }
499
500     if (compileOptions & SH_REMOVE_POW_WITH_CONSTANT_EXPONENT)
501     {
502         RemovePow(root);
503     }
504
505     if (compileOptions & SH_REGENERATE_STRUCT_NAMES)
506     {
507         RegenerateStructNames gen(&symbolTable, shaderVersion);
508         root->traverse(&gen);
509     }
510
511     if (shaderType == GL_FRAGMENT_SHADER && shaderVersion == 100 &&
512         compileResources.EXT_draw_buffers && compileResources.MaxDrawBuffers > 1 &&
513         IsExtensionEnabled(extensionBehavior, TExtension::EXT_draw_buffers))
514     {
515         EmulateGLFragColorBroadcast(root, compileResources.MaxDrawBuffers, &outputVariables,
516                                     &symbolTable, shaderVersion);
517     }
518
519     // Split multi declarations and remove calls to array length().
520     // Note that SimplifyLoopConditions needs to be run before any other AST transformations
521     // that may need to generate new statements from loop conditions or loop expressions.
522     SimplifyLoopConditions(
523         root,
524         IntermNodePatternMatcher::kMultiDeclaration | IntermNodePatternMatcher::kArrayLengthMethod,
525         &getSymbolTable(), getShaderVersion());
526
527     // Note that separate declarations need to be run before other AST transformations that
528     // generate new statements from expressions.
529     SeparateDeclarations(root);
530
531     SplitSequenceOperator(root, IntermNodePatternMatcher::kArrayLengthMethod, &getSymbolTable(),
532                           getShaderVersion());
533
534     RemoveArrayLengthMethod(root);
535
536     RemoveUnreferencedVariables(root, &symbolTable);
537
538     // Built-in function emulation needs to happen after validateLimitations pass.
539     // TODO(jmadill): Remove global pool allocator.
540     GetGlobalPoolAllocator()->lock();
541     initBuiltInFunctionEmulator(&builtInFunctionEmulator, compileOptions);
542     GetGlobalPoolAllocator()->unlock();
543     builtInFunctionEmulator.markBuiltInFunctionsForEmulation(root);
544
545     if (compileOptions & SH_SCALARIZE_VEC_AND_MAT_CONSTRUCTOR_ARGS)
546     {
547         ScalarizeVecAndMatConstructorArgs(root, shaderType, fragmentPrecisionHigh, &symbolTable);
548     }
549
550     if (shouldCollectVariables(compileOptions))
551     {
552         ASSERT(!variablesCollected);
553         CollectVariables(root, &attributes, &outputVariables, &uniforms, &inputVaryings,
554                          &outputVaryings, &uniformBlocks, &shaderStorageBlocks, &inBlocks,
555                          hashFunction, &symbolTable, shaderVersion, shaderType, extensionBehavior);
556         collectInterfaceBlocks();
557         variablesCollected = true;
558         if (compileOptions & SH_USE_UNUSED_STANDARD_SHARED_BLOCKS)
559         {
560             useAllMembersInUnusedStandardAndSharedBlocks(root);
561         }
562         if (compileOptions & SH_ENFORCE_PACKING_RESTRICTIONS)
563         {
564             // Returns true if, after applying the packing rules in the GLSL ES 1.00.17 spec
565             // Appendix A, section 7, the shader does not use too many uniforms.
566             if (!CheckVariablesInPackingLimits(maxUniformVectors, uniforms))
567             {
568                 mDiagnostics.globalError("too many uniforms");
569                 return false;
570             }
571         }
572         if (compileOptions & SH_INIT_OUTPUT_VARIABLES)
573         {
574             initializeOutputVariables(root);
575         }
576     }
577
578     // Removing invariant declarations must be done after collecting variables.
579     // Otherwise, built-in invariant declarations don't apply.
580     if (RemoveInvariant(shaderType, shaderVersion, outputType, compileOptions))
581     {
582         RemoveInvariantDeclaration(root);
583     }
584
585     // gl_Position is always written in compatibility output mode.
586     // It may have been already initialized among other output variables, in that case we don't
587     // need to initialize it twice.
588     if (shaderType == GL_VERTEX_SHADER && !mGLPositionInitialized &&
589         ((compileOptions & SH_INIT_GL_POSITION) || (outputType == SH_GLSL_COMPATIBILITY_OUTPUT)))
590     {
591         initializeGLPosition(root);
592         mGLPositionInitialized = true;
593     }
594
595     // DeferGlobalInitializers needs to be run before other AST transformations that generate new
596     // statements from expressions. But it's fine to run DeferGlobalInitializers after the above
597     // SplitSequenceOperator and RemoveArrayLengthMethod since they only have an effect on the AST
598     // on ESSL >= 3.00, and the initializers that need to be deferred can only exist in ESSL < 3.00.
599     bool initializeLocalsAndGlobals =
600         (compileOptions & SH_INITIALIZE_UNINITIALIZED_LOCALS) && !IsOutputHLSL(getOutputType());
601     bool canUseLoopsToInitialize = !(compileOptions & SH_DONT_USE_LOOPS_TO_INITIALIZE_VARIABLES);
602     DeferGlobalInitializers(root, initializeLocalsAndGlobals, canUseLoopsToInitialize, &symbolTable);
603
604     if (initializeLocalsAndGlobals)
605     {
606         // Initialize uninitialized local variables.
607         // In some cases initializing can generate extra statements in the parent block, such as
608         // when initializing nameless structs or initializing arrays in ESSL 1.00. In that case
609         // we need to first simplify loop conditions. We've already separated declarations
610         // earlier, which is also required. If we don't follow the Appendix A limitations, loop
611         // init statements can declare arrays or nameless structs and have multiple
612         // declarations.
613
614         if (!shouldRunLoopAndIndexingValidation(compileOptions))
615         {
616             SimplifyLoopConditions(root,
617                                    IntermNodePatternMatcher::kArrayDeclaration |
618                                        IntermNodePatternMatcher::kNamelessStructDeclaration,
619                                    &getSymbolTable(), getShaderVersion());
620         }
621
622         InitializeUninitializedLocals(root, getShaderVersion(), canUseLoopsToInitialize,
623                                       &getSymbolTable());
624     }
625
626     if (getShaderType() == GL_VERTEX_SHADER && (compileOptions & SH_CLAMP_POINT_SIZE))
627     {
628         ClampPointSize(root, compileResources.MaxPointSize, &getSymbolTable());
629     }
630
631     if (compileOptions & SH_REWRITE_VECTOR_SCALAR_ARITHMETIC)
632     {
633         VectorizeVectorScalarArithmetic(root, &getSymbolTable());
634     }
635
636     return true;
637 }
638
639 bool TCompiler::compile(const char *const shaderStrings[],
640                         size_t numStrings,
641                         ShCompileOptions compileOptionsIn)
642 {
643 #if defined(ANGLE_ENABLE_FUZZER_CORPUS_OUTPUT)
644     DumpFuzzerCase(shaderStrings, numStrings, shaderType, shaderSpec, outputType, compileOptionsIn);
645 #endif  // defined(ANGLE_ENABLE_FUZZER_CORPUS_OUTPUT)
646
647     if (numStrings == 0)
648         return true;
649
650     ShCompileOptions compileOptions = compileOptionsIn;
651
652     // Apply key workarounds.
653     if (shouldFlattenPragmaStdglInvariantAll())
654     {
655         // This should be harmless to do in all cases, but for the moment, do it only conditionally.
656         compileOptions |= SH_FLATTEN_PRAGMA_STDGL_INVARIANT_ALL;
657     }
658
659     TScopedPoolAllocator scopedAlloc(&allocator);
660     TIntermBlock *root = compileTreeImpl(shaderStrings, numStrings, compileOptions);
661
662     if (root)
663     {
664         if (compileOptions & SH_INTERMEDIATE_TREE)
665             OutputTree(root, infoSink.info);
666
667         if (compileOptions & SH_OBJECT_CODE)
668         {
669             PerformanceDiagnostics perfDiagnostics(&mDiagnostics);
670             translate(root, compileOptions, &perfDiagnostics);
671         }
672
673         // The IntermNode tree doesn't need to be deleted here, since the
674         // memory will be freed in a big chunk by the PoolAllocator.
675         return true;
676     }
677     return false;
678 }
679
680 bool TCompiler::InitBuiltInSymbolTable(const ShBuiltInResources &resources)
681 {
682     if (resources.MaxDrawBuffers < 1)
683     {
684         return false;
685     }
686     if (resources.EXT_blend_func_extended && resources.MaxDualSourceDrawBuffers < 1)
687     {
688         return false;
689     }
690
691     compileResources = resources;
692     setResourceString();
693
694     ASSERT(symbolTable.isEmpty());
695     symbolTable.push();  // COMMON_BUILTINS
696     symbolTable.push();  // ESSL1_BUILTINS
697     symbolTable.push();  // ESSL3_BUILTINS
698     symbolTable.push();  // ESSL3_1_BUILTINS
699     symbolTable.push();  // GLSL_BUILTINS
700
701     switch (shaderType)
702     {
703         case GL_FRAGMENT_SHADER:
704             symbolTable.setDefaultPrecision(EbtInt, EbpMedium);
705             break;
706         case GL_VERTEX_SHADER:
707         case GL_COMPUTE_SHADER:
708         case GL_GEOMETRY_SHADER_OES:
709             symbolTable.setDefaultPrecision(EbtInt, EbpHigh);
710             symbolTable.setDefaultPrecision(EbtFloat, EbpHigh);
711             break;
712         default:
713             UNREACHABLE();
714     }
715     // Set defaults for sampler types that have default precision, even those that are
716     // only available if an extension exists.
717     // New sampler types in ESSL3 don't have default precision. ESSL1 types do.
718     initSamplerDefaultPrecision(EbtSampler2D);
719     initSamplerDefaultPrecision(EbtSamplerCube);
720     // SamplerExternalOES is specified in the extension to have default precision.
721     initSamplerDefaultPrecision(EbtSamplerExternalOES);
722     // SamplerExternal2DY2YEXT is specified in the extension to have default precision.
723     initSamplerDefaultPrecision(EbtSamplerExternal2DY2YEXT);
724     // It isn't specified whether Sampler2DRect has default precision.
725     initSamplerDefaultPrecision(EbtSampler2DRect);
726
727     symbolTable.setDefaultPrecision(EbtAtomicCounter, EbpHigh);
728
729     InsertBuiltInFunctions(shaderType, shaderSpec, resources, symbolTable);
730
731     IdentifyBuiltIns(shaderType, shaderSpec, resources, symbolTable);
732
733     return true;
734 }
735
736 void TCompiler::initSamplerDefaultPrecision(TBasicType samplerType)
737 {
738     ASSERT(samplerType > EbtGuardSamplerBegin && samplerType < EbtGuardSamplerEnd);
739     symbolTable.setDefaultPrecision(samplerType, EbpLow);
740 }
741
742 void TCompiler::setResourceString()
743 {
744     std::ostringstream strstream;
745
746     // clang-format off
747     strstream << ":MaxVertexAttribs:" << compileResources.MaxVertexAttribs
748         << ":MaxVertexUniformVectors:" << compileResources.MaxVertexUniformVectors
749         << ":MaxVaryingVectors:" << compileResources.MaxVaryingVectors
750         << ":MaxVertexTextureImageUnits:" << compileResources.MaxVertexTextureImageUnits
751         << ":MaxCombinedTextureImageUnits:" << compileResources.MaxCombinedTextureImageUnits
752         << ":MaxTextureImageUnits:" << compileResources.MaxTextureImageUnits
753         << ":MaxFragmentUniformVectors:" << compileResources.MaxFragmentUniformVectors
754         << ":MaxDrawBuffers:" << compileResources.MaxDrawBuffers
755         << ":OES_standard_derivatives:" << compileResources.OES_standard_derivatives
756         << ":OES_EGL_image_external:" << compileResources.OES_EGL_image_external
757         << ":OES_EGL_image_external_essl3:" << compileResources.OES_EGL_image_external_essl3
758         << ":NV_EGL_stream_consumer_external:" << compileResources.NV_EGL_stream_consumer_external
759         << ":ARB_texture_rectangle:" << compileResources.ARB_texture_rectangle
760         << ":EXT_draw_buffers:" << compileResources.EXT_draw_buffers
761         << ":FragmentPrecisionHigh:" << compileResources.FragmentPrecisionHigh
762         << ":MaxExpressionComplexity:" << compileResources.MaxExpressionComplexity
763         << ":MaxCallStackDepth:" << compileResources.MaxCallStackDepth
764         << ":MaxFunctionParameters:" << compileResources.MaxFunctionParameters
765         << ":EXT_blend_func_extended:" << compileResources.EXT_blend_func_extended
766         << ":EXT_frag_depth:" << compileResources.EXT_frag_depth
767         << ":EXT_shader_texture_lod:" << compileResources.EXT_shader_texture_lod
768         << ":EXT_shader_framebuffer_fetch:" << compileResources.EXT_shader_framebuffer_fetch
769         << ":NV_shader_framebuffer_fetch:" << compileResources.NV_shader_framebuffer_fetch
770         << ":ARM_shader_framebuffer_fetch:" << compileResources.ARM_shader_framebuffer_fetch
771         << ":OVR_multiview:" << compileResources.OVR_multiview
772         << ":EXT_YUV_target:" << compileResources.EXT_YUV_target
773         << ":OES_geometry_shader:" << compileResources.OES_geometry_shader
774         << ":MaxVertexOutputVectors:" << compileResources.MaxVertexOutputVectors
775         << ":MaxFragmentInputVectors:" << compileResources.MaxFragmentInputVectors
776         << ":MinProgramTexelOffset:" << compileResources.MinProgramTexelOffset
777         << ":MaxProgramTexelOffset:" << compileResources.MaxProgramTexelOffset
778         << ":MaxDualSourceDrawBuffers:" << compileResources.MaxDualSourceDrawBuffers
779         << ":MaxViewsOVR:" << compileResources.MaxViewsOVR
780         << ":NV_draw_buffers:" << compileResources.NV_draw_buffers
781         << ":WEBGL_debug_shader_precision:" << compileResources.WEBGL_debug_shader_precision
782         << ":MinProgramTextureGatherOffset:" << compileResources.MinProgramTextureGatherOffset
783         << ":MaxProgramTextureGatherOffset:" << compileResources.MaxProgramTextureGatherOffset
784         << ":MaxImageUnits:" << compileResources.MaxImageUnits
785         << ":MaxVertexImageUniforms:" << compileResources.MaxVertexImageUniforms
786         << ":MaxFragmentImageUniforms:" << compileResources.MaxFragmentImageUniforms
787         << ":MaxComputeImageUniforms:" << compileResources.MaxComputeImageUniforms
788         << ":MaxCombinedImageUniforms:" << compileResources.MaxCombinedImageUniforms
789         << ":MaxCombinedShaderOutputResources:" << compileResources.MaxCombinedShaderOutputResources
790         << ":MaxComputeWorkGroupCountX:" << compileResources.MaxComputeWorkGroupCount[0]
791         << ":MaxComputeWorkGroupCountY:" << compileResources.MaxComputeWorkGroupCount[1]
792         << ":MaxComputeWorkGroupCountZ:" << compileResources.MaxComputeWorkGroupCount[2]
793         << ":MaxComputeWorkGroupSizeX:" << compileResources.MaxComputeWorkGroupSize[0]
794         << ":MaxComputeWorkGroupSizeY:" << compileResources.MaxComputeWorkGroupSize[1]
795         << ":MaxComputeWorkGroupSizeZ:" << compileResources.MaxComputeWorkGroupSize[2]
796         << ":MaxComputeUniformComponents:" << compileResources.MaxComputeUniformComponents
797         << ":MaxComputeTextureImageUnits:" << compileResources.MaxComputeTextureImageUnits
798         << ":MaxComputeAtomicCounters:" << compileResources.MaxComputeAtomicCounters
799         << ":MaxComputeAtomicCounterBuffers:" << compileResources.MaxComputeAtomicCounterBuffers
800         << ":MaxVertexAtomicCounters:" << compileResources.MaxVertexAtomicCounters
801         << ":MaxFragmentAtomicCounters:" << compileResources.MaxFragmentAtomicCounters
802         << ":MaxCombinedAtomicCounters:" << compileResources.MaxCombinedAtomicCounters
803         << ":MaxAtomicCounterBindings:" << compileResources.MaxAtomicCounterBindings
804         << ":MaxVertexAtomicCounterBuffers:" << compileResources.MaxVertexAtomicCounterBuffers
805         << ":MaxFragmentAtomicCounterBuffers:" << compileResources.MaxFragmentAtomicCounterBuffers
806         << ":MaxCombinedAtomicCounterBuffers:" << compileResources.MaxCombinedAtomicCounterBuffers
807         << ":MaxAtomicCounterBufferSize:" << compileResources.MaxAtomicCounterBufferSize
808         << ":MaxGeometryUniformComponents:" << compileResources.MaxGeometryUniformComponents
809         << ":MaxGeometryUniformBlocks:" << compileResources.MaxGeometryUniformBlocks
810         << ":MaxGeometryInputComponents:" << compileResources.MaxGeometryInputComponents
811         << ":MaxGeometryOutputComponents:" << compileResources.MaxGeometryOutputComponents
812         << ":MaxGeometryOutputVertices:" << compileResources.MaxGeometryOutputVertices
813         << ":MaxGeometryTotalOutputComponents:" << compileResources.MaxGeometryTotalOutputComponents
814         << ":MaxGeometryTextureImageUnits:" << compileResources.MaxGeometryTextureImageUnits
815         << ":MaxGeometryAtomicCounterBuffers:" << compileResources.MaxGeometryAtomicCounterBuffers
816         << ":MaxGeometryAtomicCounters:" << compileResources.MaxGeometryAtomicCounters
817         << ":MaxGeometryShaderStorageBlocks:" << compileResources.MaxGeometryShaderStorageBlocks
818         << ":MaxGeometryShaderInvocations:" << compileResources.MaxGeometryShaderInvocations
819         << ":MaxGeometryImageUniforms:" << compileResources.MaxGeometryImageUniforms;
820     // clang-format on
821
822     builtInResourcesString = strstream.str();
823 }
824
825 void TCompiler::collectInterfaceBlocks()
826 {
827     ASSERT(interfaceBlocks.empty());
828     interfaceBlocks.reserve(uniformBlocks.size() + shaderStorageBlocks.size() + inBlocks.size());
829     interfaceBlocks.insert(interfaceBlocks.end(), uniformBlocks.begin(), uniformBlocks.end());
830     interfaceBlocks.insert(interfaceBlocks.end(), shaderStorageBlocks.begin(),
831                            shaderStorageBlocks.end());
832     interfaceBlocks.insert(interfaceBlocks.end(), inBlocks.begin(), inBlocks.end());
833 }
834
835 void TCompiler::clearResults()
836 {
837     arrayBoundsClamper.Cleanup();
838     infoSink.info.erase();
839     infoSink.obj.erase();
840     infoSink.debug.erase();
841     mDiagnostics.resetErrorCount();
842
843     attributes.clear();
844     outputVariables.clear();
845     uniforms.clear();
846     inputVaryings.clear();
847     outputVaryings.clear();
848     interfaceBlocks.clear();
849     uniformBlocks.clear();
850     shaderStorageBlocks.clear();
851     inBlocks.clear();
852     variablesCollected = false;
853     mGLPositionInitialized = false;
854
855     mNumViews = -1;
856
857     mGeometryShaderInputPrimitiveType  = EptUndefined;
858     mGeometryShaderOutputPrimitiveType = EptUndefined;
859     mGeometryShaderInvocations         = 0;
860     mGeometryShaderMaxVertices         = -1;
861
862     builtInFunctionEmulator.cleanup();
863
864     nameMap.clear();
865
866     mSourcePath     = nullptr;
867 }
868
869 bool TCompiler::initCallDag(TIntermNode *root)
870 {
871     mCallDag.clear();
872
873     switch (mCallDag.init(root, &mDiagnostics))
874     {
875         case CallDAG::INITDAG_SUCCESS:
876             return true;
877         case CallDAG::INITDAG_RECURSION:
878         case CallDAG::INITDAG_UNDEFINED:
879             // Error message has already been written out.
880             ASSERT(mDiagnostics.numErrors() > 0);
881             return false;
882     }
883
884     UNREACHABLE();
885     return true;
886 }
887
888 bool TCompiler::checkCallDepth()
889 {
890     std::vector<int> depths(mCallDag.size());
891
892     for (size_t i = 0; i < mCallDag.size(); i++)
893     {
894         int depth    = 0;
895         auto &record = mCallDag.getRecordFromIndex(i);
896
897         for (auto &calleeIndex : record.callees)
898         {
899             depth = std::max(depth, depths[calleeIndex] + 1);
900         }
901
902         depths[i] = depth;
903
904         if (depth >= maxCallStackDepth)
905         {
906             // Trace back the function chain to have a meaningful info log.
907             std::stringstream errorStream;
908             errorStream << "Call stack too deep (larger than " << maxCallStackDepth
909                         << ") with the following call chain: " << record.name;
910
911             int currentFunction = static_cast<int>(i);
912             int currentDepth    = depth;
913
914             while (currentFunction != -1)
915             {
916                 errorStream << " -> " << mCallDag.getRecordFromIndex(currentFunction).name;
917
918                 int nextFunction = -1;
919                 for (auto &calleeIndex : mCallDag.getRecordFromIndex(currentFunction).callees)
920                 {
921                     if (depths[calleeIndex] == currentDepth - 1)
922                     {
923                         currentDepth--;
924                         nextFunction = calleeIndex;
925                     }
926                 }
927
928                 currentFunction = nextFunction;
929             }
930
931             std::string errorStr = errorStream.str();
932             mDiagnostics.globalError(errorStr.c_str());
933
934             return false;
935         }
936     }
937
938     return true;
939 }
940
941 bool TCompiler::tagUsedFunctions()
942 {
943     // Search from main, starting from the end of the DAG as it usually is the root.
944     for (size_t i = mCallDag.size(); i-- > 0;)
945     {
946         if (mCallDag.getRecordFromIndex(i).name == "main")
947         {
948             internalTagUsedFunction(i);
949             return true;
950         }
951     }
952
953     mDiagnostics.globalError("Missing main()");
954     return false;
955 }
956
957 void TCompiler::internalTagUsedFunction(size_t index)
958 {
959     if (functionMetadata[index].used)
960     {
961         return;
962     }
963
964     functionMetadata[index].used = true;
965
966     for (int calleeIndex : mCallDag.getRecordFromIndex(index).callees)
967     {
968         internalTagUsedFunction(calleeIndex);
969     }
970 }
971
972 // A predicate for the stl that returns if a top-level node is unused
973 class TCompiler::UnusedPredicate
974 {
975   public:
976     UnusedPredicate(const CallDAG *callDag, const std::vector<FunctionMetadata> *metadatas)
977         : mCallDag(callDag), mMetadatas(metadatas)
978     {
979     }
980
981     bool operator()(TIntermNode *node)
982     {
983         const TIntermFunctionPrototype *asFunctionPrototype   = node->getAsFunctionPrototypeNode();
984         const TIntermFunctionDefinition *asFunctionDefinition = node->getAsFunctionDefinition();
985
986         const TFunctionSymbolInfo *functionInfo = nullptr;
987
988         if (asFunctionDefinition)
989         {
990             functionInfo = asFunctionDefinition->getFunctionSymbolInfo();
991         }
992         else if (asFunctionPrototype)
993         {
994             functionInfo = asFunctionPrototype->getFunctionSymbolInfo();
995         }
996         if (functionInfo == nullptr)
997         {
998             return false;
999         }
1000
1001         size_t callDagIndex = mCallDag->findIndex(functionInfo);
1002         if (callDagIndex == CallDAG::InvalidIndex)
1003         {
1004             // This happens only for unimplemented prototypes which are thus unused
1005             ASSERT(asFunctionPrototype);
1006             return true;
1007         }
1008
1009         ASSERT(callDagIndex < mMetadatas->size());
1010         return !(*mMetadatas)[callDagIndex].used;
1011     }
1012
1013   private:
1014     const CallDAG *mCallDag;
1015     const std::vector<FunctionMetadata> *mMetadatas;
1016 };
1017
1018 void TCompiler::pruneUnusedFunctions(TIntermBlock *root)
1019 {
1020     UnusedPredicate isUnused(&mCallDag, &functionMetadata);
1021     TIntermSequence *sequence = root->getSequence();
1022
1023     if (!sequence->empty())
1024     {
1025         sequence->erase(std::remove_if(sequence->begin(), sequence->end(), isUnused),
1026                         sequence->end());
1027     }
1028 }
1029
1030 bool TCompiler::limitExpressionComplexity(TIntermBlock *root)
1031 {
1032     if (!IsASTDepthBelowLimit(root, maxExpressionComplexity))
1033     {
1034         mDiagnostics.globalError("Expression too complex.");
1035         return false;
1036     }
1037
1038     if (!ValidateMaxParameters(root, maxFunctionParameters))
1039     {
1040         mDiagnostics.globalError("Function has too many parameters.");
1041         return false;
1042     }
1043
1044     return true;
1045 }
1046
1047 bool TCompiler::shouldCollectVariables(ShCompileOptions compileOptions)
1048 {
1049     return (compileOptions & SH_VARIABLES) != 0;
1050 }
1051
1052 bool TCompiler::wereVariablesCollected() const
1053 {
1054     return variablesCollected;
1055 }
1056
1057 void TCompiler::initializeGLPosition(TIntermBlock *root)
1058 {
1059     InitVariableList list;
1060     sh::ShaderVariable var(GL_FLOAT_VEC4);
1061     var.name = "gl_Position";
1062     list.push_back(var);
1063     InitializeVariables(root, list, &symbolTable, shaderVersion, extensionBehavior, false);
1064 }
1065
1066 void TCompiler::useAllMembersInUnusedStandardAndSharedBlocks(TIntermBlock *root)
1067 {
1068     sh::InterfaceBlockList list;
1069
1070     for (const auto& block : uniformBlocks)
1071     {
1072         if (!block.staticUse &&
1073             (block.layout == sh::BLOCKLAYOUT_STD140 || block.layout == sh::BLOCKLAYOUT_SHARED))
1074         {
1075             list.push_back(block);
1076         }
1077     }
1078
1079     sh::UseInterfaceBlockFields(root, list, symbolTable);
1080 }
1081
1082 void TCompiler::initializeOutputVariables(TIntermBlock *root)
1083 {
1084     InitVariableList list;
1085     if (shaderType == GL_VERTEX_SHADER || shaderType == GL_GEOMETRY_SHADER_OES)
1086     {
1087         for (const auto& var : outputVaryings)
1088         {
1089             list.push_back(var);
1090             if (var.name == "gl_Position")
1091             {
1092                 ASSERT(!mGLPositionInitialized);
1093                 mGLPositionInitialized = true;
1094             }
1095         }
1096     }
1097     else
1098     {
1099         ASSERT(shaderType == GL_FRAGMENT_SHADER);
1100         for (const auto& var : outputVariables)
1101         {
1102             list.push_back(var);
1103         }
1104     }
1105     InitializeVariables(root, list, &symbolTable, shaderVersion, extensionBehavior, false);
1106 }
1107
1108 const TExtensionBehavior &TCompiler::getExtensionBehavior() const
1109 {
1110     return extensionBehavior;
1111 }
1112
1113 const char *TCompiler::getSourcePath() const
1114 {
1115     return mSourcePath;
1116 }
1117
1118 const ShBuiltInResources &TCompiler::getResources() const
1119 {
1120     return compileResources;
1121 }
1122
1123 const ArrayBoundsClamper &TCompiler::getArrayBoundsClamper() const
1124 {
1125     return arrayBoundsClamper;
1126 }
1127
1128 ShArrayIndexClampingStrategy TCompiler::getArrayIndexClampingStrategy() const
1129 {
1130     return clampingStrategy;
1131 }
1132
1133 const BuiltInFunctionEmulator &TCompiler::getBuiltInFunctionEmulator() const
1134 {
1135     return builtInFunctionEmulator;
1136 }
1137
1138 void TCompiler::writePragma(ShCompileOptions compileOptions)
1139 {
1140     if (!(compileOptions & SH_FLATTEN_PRAGMA_STDGL_INVARIANT_ALL))
1141     {
1142         TInfoSinkBase &sink = infoSink.obj;
1143         if (mPragma.stdgl.invariantAll)
1144             sink << "#pragma STDGL invariant(all)\n";
1145     }
1146 }
1147
1148 bool TCompiler::isVaryingDefined(const char *varyingName)
1149 {
1150     ASSERT(variablesCollected);
1151     for (size_t ii = 0; ii < inputVaryings.size(); ++ii)
1152     {
1153         if (inputVaryings[ii].name == varyingName)
1154         {
1155             return true;
1156         }
1157     }
1158     for (size_t ii = 0; ii < outputVaryings.size(); ++ii)
1159     {
1160         if (outputVaryings[ii].name == varyingName)
1161         {
1162             return true;
1163         }
1164     }
1165
1166     return false;
1167 }
1168
1169 }  // namespace sh