The Tor Browser: comparison gfx/angle/src/compiler/ShHandle.h

--1:000000000000
+:d544ba737072
+//
+// 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 / file comparison

comparison: gfx/angle/src/compiler/ShHandle.h

gfx/angle/src/compiler/ShHandle.h