The Tor Browser: gfx/angle/src/compiler/ShHandle.h@141e0f1194b1 (annotated)

gfx/angle/src/compiler/ShHandle.h@141e0f1194b1 (annotated)

gfx/angle/src/compiler/ShHandle.h

Wed, 31 Dec 2014 07:16:47 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:16:47 +0100
branch: TOR_BUG_9701
changeset 3: 141e0f1194b1
permissions: -rw-r--r--

Revert simplistic fix pending revisit of Mozilla integration attempt.

 //
 // Copyright (c) 2002-2012 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.
 //
 #ifndef _SHHANDLE_INCLUDED_
 #define _SHHANDLE_INCLUDED_
 //
 // Machine independent part of the compiler private objects
 // sent as ShHandle to the driver.
 //
 // This should not be included by driver code.
 //
 #include "GLSLANG/ShaderLang.h"
 #include "compiler/BuiltInFunctionEmulator.h"
 #include "compiler/ExtensionBehavior.h"
 #include "compiler/HashNames.h"
 #include "compiler/InfoSink.h"
 #include "compiler/SymbolTable.h"
 #include "compiler/VariableInfo.h"
 #include "third_party/compiler/ArrayBoundsClamper.h"
 class LongNameMap;
 class TCompiler;
 class TDependencyGraph;
 class TranslatorHLSL;
 //
 // Helper function to identify specs that are based on the WebGL spec,
 // like the CSS Shaders spec.
 //
 bool isWebGLBasedSpec(ShShaderSpec spec);
 //
 // The base class used to back handles returned to the driver.
 //
 class TShHandleBase {
 public:
     TShHandleBase();
     virtual ~TShHandleBase();
     virtual TCompiler* getAsCompiler() { return 0; }
     virtual TranslatorHLSL* getAsTranslatorHLSL() { return 0; }
 protected:
     // Memory allocator. Allocates and tracks memory required by the compiler.
     // Deallocates all memory when compiler is destructed.
     TPoolAllocator allocator;
 };
 //
 // The base class for the machine dependent compiler to derive from
 // for managing object code from the compile.
 //
 class TCompiler : public TShHandleBase {
 public:
     TCompiler(ShShaderType type, ShShaderSpec spec);
     virtual ~TCompiler();
     virtual TCompiler* getAsCompiler() { return this; }
     bool Init(const ShBuiltInResources& resources);
     bool compile(const char* const shaderStrings[],
                  size_t numStrings,
                  int compileOptions);
     // Get results of the last compilation.
     TInfoSink& getInfoSink() { return infoSink; }
     const TVariableInfoList& getAttribs() const { return attribs; }
     const TVariableInfoList& getUniforms() const { return uniforms; }
     int getMappedNameMaxLength() const;
     ShHashFunction64 getHashFunction() const { return hashFunction; }
     NameMap& getNameMap() { return nameMap; }
     TSymbolTable& getSymbolTable() { return symbolTable; }
 protected:
     ShShaderType getShaderType() const { return shaderType; }
     ShShaderSpec getShaderSpec() const { return shaderSpec; }
     // Initialize symbol-table with built-in symbols.
     bool InitBuiltInSymbolTable(const ShBuiltInResources& resources);
     // Clears the results from the previous compilation.
     void clearResults();
     // Return true if function recursion is detected or call depth exceeded.
     bool detectCallDepth(TIntermNode* root, TInfoSink& infoSink, bool limitCallStackDepth);
     // Rewrites a shader's intermediate tree according to the CSS Shaders spec.
     void rewriteCSSShader(TIntermNode* root);
     // Returns true if the given shader does not exceed the minimum
     // functionality mandated in GLSL 1.0 spec Appendix A.
     bool validateLimitations(TIntermNode* root);
     // Collect info for all attribs and uniforms.
     void collectAttribsUniforms(TIntermNode* root);
     // Map long variable names into shorter ones.
     void mapLongVariableNames(TIntermNode* root);
     // Translate to object code.
     virtual void translate(TIntermNode* root) = 0;
     // Returns true if, after applying the packing rules in the GLSL 1.017 spec
     // Appendix A, section 7, the shader does not use too many uniforms.
     bool enforcePackingRestrictions();
     // Returns true if the shader passes the restrictions that aim to prevent timing attacks.
     bool enforceTimingRestrictions(TIntermNode* root, bool outputGraph);
     // Returns true if the shader does not use samplers.
     bool enforceVertexShaderTimingRestrictions(TIntermNode* root);
     // Returns true if the shader does not use sampler dependent values to affect control
     // flow or in operations whose time can depend on the input values.
     bool enforceFragmentShaderTimingRestrictions(const TDependencyGraph& graph);
     // Return true if the maximum expression complexity below the limit.
     bool limitExpressionComplexity(TIntermNode* root);
     // Get built-in extensions with default behavior.
     const TExtensionBehavior& getExtensionBehavior() const;
     // Get the resources set by InitBuiltInSymbolTable
     const ShBuiltInResources& getResources() const;
     const ArrayBoundsClamper& getArrayBoundsClamper() const;
     ShArrayIndexClampingStrategy getArrayIndexClampingStrategy() const;
     const BuiltInFunctionEmulator& getBuiltInFunctionEmulator() const;
 private:
     ShShaderType shaderType;
     ShShaderSpec shaderSpec;
     int maxUniformVectors;
     int maxExpressionComplexity;
     int maxCallStackDepth;
     ShBuiltInResources compileResources;
     // Built-in symbol table for the given language, spec, and resources.
     // It is preserved from compile-to-compile.
     TSymbolTable symbolTable;
     // Built-in extensions with default behavior.
     TExtensionBehavior extensionBehavior;
     bool fragmentPrecisionHigh;
     ArrayBoundsClamper arrayBoundsClamper;
     ShArrayIndexClampingStrategy clampingStrategy;
     BuiltInFunctionEmulator builtInFunctionEmulator;
     // Results of compilation.
     TInfoSink infoSink;  // Output sink.
     TVariableInfoList attribs;  // Active attributes in the compiled shader.
     TVariableInfoList uniforms;  // Active uniforms in the compiled shader.
     // Cached copy of the ref-counted singleton.
     LongNameMap* longNameMap;
     // name hashing.
     ShHashFunction64 hashFunction;
     NameMap nameMap;
 };
 //
 // This is the interface between the machine independent code
 // and the machine dependent code.
 //
 // The machine dependent code should derive from the classes
 // above. Then Construct*() and Delete*() will create and
 // destroy the machine dependent objects, which contain the
 // above machine independent information.
 //
 TCompiler* ConstructCompiler(
     ShShaderType type, ShShaderSpec spec, ShShaderOutput output);
 void DeleteCompiler(TCompiler*);
 #endif // _SHHANDLE_INCLUDED_

The Tor Browser / annotate

gfx/angle/src/compiler/ShHandle.h@141e0f1194b1 (annotated)

gfx/angle/src/compiler/ShHandle.h