be63facd80
Allow constructors to and from references to be constant folded. Section 4.3.3 says constructors whose arguments are all constant expressions must fold. Disallow 'const' on buffer reference types. It is not a 'non-void transparent basic data type' (it is not considered 'basic'). Handle buffer reference constants (which can be assigned to a non-const reference, or can be further folded to another type of constant) by converting to 'constructor(uint64_t constant)' in addConversion. Disallow == and != operators on reference types.
897 lines
35 KiB
C++
897 lines
35 KiB
C++
//
|
|
// Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
|
// Copyright (C) 2016 LunarG, Inc.
|
|
// Copyright (C) 2017 ARM Limited.
|
|
// Copyright (C) 2015-2018 Google, Inc.
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
//
|
|
// Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
//
|
|
// Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
//
|
|
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
|
|
#ifndef _LOCAL_INTERMEDIATE_INCLUDED_
|
|
#define _LOCAL_INTERMEDIATE_INCLUDED_
|
|
|
|
#include "../Include/intermediate.h"
|
|
#include "../Public/ShaderLang.h"
|
|
#include "Versions.h"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <set>
|
|
#include <array>
|
|
|
|
class TInfoSink;
|
|
|
|
namespace glslang {
|
|
|
|
struct TMatrixSelector {
|
|
int coord1; // stay agnostic about column/row; this is parse order
|
|
int coord2;
|
|
};
|
|
|
|
typedef int TVectorSelector;
|
|
|
|
const int MaxSwizzleSelectors = 4;
|
|
|
|
template<typename selectorType>
|
|
class TSwizzleSelectors {
|
|
public:
|
|
TSwizzleSelectors() : size_(0) { }
|
|
|
|
void push_back(selectorType comp)
|
|
{
|
|
if (size_ < MaxSwizzleSelectors)
|
|
components[size_++] = comp;
|
|
}
|
|
void resize(int s)
|
|
{
|
|
assert(s <= size_);
|
|
size_ = s;
|
|
}
|
|
int size() const { return size_; }
|
|
selectorType operator[](int i) const
|
|
{
|
|
assert(i < MaxSwizzleSelectors);
|
|
return components[i];
|
|
}
|
|
|
|
private:
|
|
int size_;
|
|
selectorType components[MaxSwizzleSelectors];
|
|
};
|
|
|
|
//
|
|
// Some helper structures for TIntermediate. Their contents are encapsulated
|
|
// by TIntermediate.
|
|
//
|
|
|
|
// Used for call-graph algorithms for detecting recursion, missing bodies, and dead bodies.
|
|
// A "call" is a pair: <caller, callee>.
|
|
// There can be duplicates. General assumption is the list is small.
|
|
struct TCall {
|
|
TCall(const TString& pCaller, const TString& pCallee) : caller(pCaller), callee(pCallee) { }
|
|
TString caller;
|
|
TString callee;
|
|
bool visited;
|
|
bool currentPath;
|
|
bool errorGiven;
|
|
int calleeBodyPosition;
|
|
};
|
|
|
|
// A generic 1-D range.
|
|
struct TRange {
|
|
TRange(int start, int last) : start(start), last(last) { }
|
|
bool overlap(const TRange& rhs) const
|
|
{
|
|
return last >= rhs.start && start <= rhs.last;
|
|
}
|
|
int start;
|
|
int last;
|
|
};
|
|
|
|
// An IO range is a 3-D rectangle; the set of (location, component, index) triples all lying
|
|
// within the same location range, component range, and index value. Locations don't alias unless
|
|
// all other dimensions of their range overlap.
|
|
struct TIoRange {
|
|
TIoRange(TRange location, TRange component, TBasicType basicType, int index)
|
|
: location(location), component(component), basicType(basicType), index(index) { }
|
|
bool overlap(const TIoRange& rhs) const
|
|
{
|
|
return location.overlap(rhs.location) && component.overlap(rhs.component) && index == rhs.index;
|
|
}
|
|
TRange location;
|
|
TRange component;
|
|
TBasicType basicType;
|
|
int index;
|
|
};
|
|
|
|
// An offset range is a 2-D rectangle; the set of (binding, offset) pairs all lying
|
|
// within the same binding and offset range.
|
|
struct TOffsetRange {
|
|
TOffsetRange(TRange binding, TRange offset)
|
|
: binding(binding), offset(offset) { }
|
|
bool overlap(const TOffsetRange& rhs) const
|
|
{
|
|
return binding.overlap(rhs.binding) && offset.overlap(rhs.offset);
|
|
}
|
|
TRange binding;
|
|
TRange offset;
|
|
};
|
|
|
|
// Things that need to be tracked per xfb buffer.
|
|
struct TXfbBuffer {
|
|
#ifdef AMD_EXTENSIONS
|
|
TXfbBuffer() : stride(TQualifier::layoutXfbStrideEnd), implicitStride(0), contains64BitType(false),
|
|
contains32BitType(false), contains16BitType(false) { }
|
|
#else
|
|
TXfbBuffer() : stride(TQualifier::layoutXfbStrideEnd), implicitStride(0), contains64BitType(false) { }
|
|
#endif
|
|
std::vector<TRange> ranges; // byte offsets that have already been assigned
|
|
unsigned int stride;
|
|
unsigned int implicitStride;
|
|
bool contains64BitType;
|
|
#ifdef AMD_EXTENSIONS
|
|
bool contains32BitType;
|
|
bool contains16BitType;
|
|
#endif
|
|
};
|
|
|
|
// Track a set of strings describing how the module was processed.
|
|
// Using the form:
|
|
// process arg0 arg1 arg2 ...
|
|
// process arg0 arg1 arg2 ...
|
|
// where everything is textual, and there can be zero or more arguments
|
|
class TProcesses {
|
|
public:
|
|
TProcesses() {}
|
|
~TProcesses() {}
|
|
|
|
void addProcess(const char* process)
|
|
{
|
|
processes.push_back(process);
|
|
}
|
|
void addProcess(const std::string& process)
|
|
{
|
|
processes.push_back(process);
|
|
}
|
|
void addArgument(int arg)
|
|
{
|
|
processes.back().append(" ");
|
|
std::string argString = std::to_string(arg);
|
|
processes.back().append(argString);
|
|
}
|
|
void addArgument(const char* arg)
|
|
{
|
|
processes.back().append(" ");
|
|
processes.back().append(arg);
|
|
}
|
|
void addArgument(const std::string& arg)
|
|
{
|
|
processes.back().append(" ");
|
|
processes.back().append(arg);
|
|
}
|
|
void addIfNonZero(const char* process, int value)
|
|
{
|
|
if (value != 0) {
|
|
addProcess(process);
|
|
addArgument(value);
|
|
}
|
|
}
|
|
|
|
const std::vector<std::string>& getProcesses() const { return processes; }
|
|
|
|
private:
|
|
std::vector<std::string> processes;
|
|
};
|
|
|
|
class TSymbolTable;
|
|
class TSymbol;
|
|
class TVariable;
|
|
|
|
#ifdef NV_EXTENSIONS
|
|
//
|
|
// Texture and Sampler transformation mode.
|
|
//
|
|
enum ComputeDerivativeMode {
|
|
LayoutDerivativeNone, // default layout as SPV_NV_compute_shader_derivatives not enabled
|
|
LayoutDerivativeGroupQuads, // derivative_group_quadsNV
|
|
LayoutDerivativeGroupLinear, // derivative_group_linearNV
|
|
};
|
|
#endif
|
|
|
|
//
|
|
// Set of helper functions to help parse and build the tree.
|
|
//
|
|
class TIntermediate {
|
|
public:
|
|
explicit TIntermediate(EShLanguage l, int v = 0, EProfile p = ENoProfile) :
|
|
implicitThisName("@this"), implicitCounterName("@count"),
|
|
language(l), source(EShSourceNone), profile(p), version(v), treeRoot(0),
|
|
numEntryPoints(0), numErrors(0), numPushConstants(0), recursive(false),
|
|
invocations(TQualifier::layoutNotSet), vertices(TQualifier::layoutNotSet),
|
|
inputPrimitive(ElgNone), outputPrimitive(ElgNone),
|
|
pixelCenterInteger(false), originUpperLeft(false),
|
|
vertexSpacing(EvsNone), vertexOrder(EvoNone), pointMode(false), earlyFragmentTests(false),
|
|
postDepthCoverage(false), depthLayout(EldNone), depthReplacing(false),
|
|
hlslFunctionality1(false),
|
|
blendEquations(0), xfbMode(false), multiStream(false),
|
|
#ifdef NV_EXTENSIONS
|
|
layoutOverrideCoverage(false),
|
|
geoPassthroughEXT(false),
|
|
numShaderRecordNVBlocks(0),
|
|
computeDerivativeMode(LayoutDerivativeNone),
|
|
primitives(TQualifier::layoutNotSet),
|
|
numTaskNVBlocks(0),
|
|
#endif
|
|
autoMapBindings(false),
|
|
autoMapLocations(false),
|
|
invertY(false),
|
|
flattenUniformArrays(false),
|
|
useUnknownFormat(false),
|
|
hlslOffsets(false),
|
|
useStorageBuffer(false),
|
|
useVulkanMemoryModel(false),
|
|
hlslIoMapping(false),
|
|
useVariablePointers(false),
|
|
textureSamplerTransformMode(EShTexSampTransKeep),
|
|
needToLegalize(false),
|
|
binaryDoubleOutput(false),
|
|
usePhysicalStorageBuffer(false),
|
|
uniformLocationBase(0)
|
|
{
|
|
localSize[0] = 1;
|
|
localSize[1] = 1;
|
|
localSize[2] = 1;
|
|
localSizeSpecId[0] = TQualifier::layoutNotSet;
|
|
localSizeSpecId[1] = TQualifier::layoutNotSet;
|
|
localSizeSpecId[2] = TQualifier::layoutNotSet;
|
|
xfbBuffers.resize(TQualifier::layoutXfbBufferEnd);
|
|
|
|
shiftBinding.fill(0);
|
|
}
|
|
void setLimits(const TBuiltInResource& r) { resources = r; }
|
|
|
|
bool postProcess(TIntermNode*, EShLanguage);
|
|
void output(TInfoSink&, bool tree);
|
|
void removeTree();
|
|
|
|
void setSource(EShSource s) { source = s; }
|
|
EShSource getSource() const { return source; }
|
|
void setEntryPointName(const char* ep)
|
|
{
|
|
entryPointName = ep;
|
|
processes.addProcess("entry-point");
|
|
processes.addArgument(entryPointName);
|
|
}
|
|
void setEntryPointMangledName(const char* ep) { entryPointMangledName = ep; }
|
|
const std::string& getEntryPointName() const { return entryPointName; }
|
|
const std::string& getEntryPointMangledName() const { return entryPointMangledName; }
|
|
|
|
void setShiftBinding(TResourceType res, unsigned int shift)
|
|
{
|
|
shiftBinding[res] = shift;
|
|
|
|
const char* name = getResourceName(res);
|
|
if (name != nullptr)
|
|
processes.addIfNonZero(name, shift);
|
|
}
|
|
|
|
unsigned int getShiftBinding(TResourceType res) const { return shiftBinding[res]; }
|
|
|
|
void setShiftBindingForSet(TResourceType res, unsigned int shift, unsigned int set)
|
|
{
|
|
if (shift == 0) // ignore if there's no shift: it's a no-op.
|
|
return;
|
|
|
|
shiftBindingForSet[res][set] = shift;
|
|
|
|
const char* name = getResourceName(res);
|
|
if (name != nullptr) {
|
|
processes.addProcess(name);
|
|
processes.addArgument(shift);
|
|
processes.addArgument(set);
|
|
}
|
|
}
|
|
|
|
int getShiftBindingForSet(TResourceType res, unsigned int set) const
|
|
{
|
|
const auto shift = shiftBindingForSet[res].find(set);
|
|
return shift == shiftBindingForSet[res].end() ? -1 : shift->second;
|
|
}
|
|
bool hasShiftBindingForSet(TResourceType res) const { return !shiftBindingForSet[res].empty(); }
|
|
|
|
void setResourceSetBinding(const std::vector<std::string>& shift)
|
|
{
|
|
resourceSetBinding = shift;
|
|
if (shift.size() > 0) {
|
|
processes.addProcess("resource-set-binding");
|
|
for (int s = 0; s < (int)shift.size(); ++s)
|
|
processes.addArgument(shift[s]);
|
|
}
|
|
}
|
|
const std::vector<std::string>& getResourceSetBinding() const { return resourceSetBinding; }
|
|
void setAutoMapBindings(bool map)
|
|
{
|
|
autoMapBindings = map;
|
|
if (autoMapBindings)
|
|
processes.addProcess("auto-map-bindings");
|
|
}
|
|
bool getAutoMapBindings() const { return autoMapBindings; }
|
|
void setAutoMapLocations(bool map)
|
|
{
|
|
autoMapLocations = map;
|
|
if (autoMapLocations)
|
|
processes.addProcess("auto-map-locations");
|
|
}
|
|
bool getAutoMapLocations() const { return autoMapLocations; }
|
|
void setInvertY(bool invert)
|
|
{
|
|
invertY = invert;
|
|
if (invertY)
|
|
processes.addProcess("invert-y");
|
|
}
|
|
bool getInvertY() const { return invertY; }
|
|
|
|
void setFlattenUniformArrays(bool flatten)
|
|
{
|
|
flattenUniformArrays = flatten;
|
|
if (flattenUniformArrays)
|
|
processes.addProcess("flatten-uniform-arrays");
|
|
}
|
|
bool getFlattenUniformArrays() const { return flattenUniformArrays; }
|
|
void setNoStorageFormat(bool b)
|
|
{
|
|
useUnknownFormat = b;
|
|
if (useUnknownFormat)
|
|
processes.addProcess("no-storage-format");
|
|
}
|
|
bool getNoStorageFormat() const { return useUnknownFormat; }
|
|
void setHlslOffsets()
|
|
{
|
|
hlslOffsets = true;
|
|
if (hlslOffsets)
|
|
processes.addProcess("hlsl-offsets");
|
|
}
|
|
bool usingHlslOffsets() const { return hlslOffsets; }
|
|
void setUseStorageBuffer()
|
|
{
|
|
useStorageBuffer = true;
|
|
processes.addProcess("use-storage-buffer");
|
|
}
|
|
bool usingStorageBuffer() const { return useStorageBuffer; }
|
|
void setHlslIoMapping(bool b)
|
|
{
|
|
hlslIoMapping = b;
|
|
if (hlslIoMapping)
|
|
processes.addProcess("hlsl-iomap");
|
|
}
|
|
bool usingHlslIoMapping() { return hlslIoMapping; }
|
|
void setUseVulkanMemoryModel()
|
|
{
|
|
useVulkanMemoryModel = true;
|
|
processes.addProcess("use-vulkan-memory-model");
|
|
}
|
|
bool usingVulkanMemoryModel() const { return useVulkanMemoryModel; }
|
|
void setUsePhysicalStorageBuffer()
|
|
{
|
|
usePhysicalStorageBuffer = true;
|
|
}
|
|
bool usingPhysicalStorageBuffer() const { return usePhysicalStorageBuffer; }
|
|
void setUseVariablePointers()
|
|
{
|
|
useVariablePointers = true;
|
|
processes.addProcess("use-variable-pointers");
|
|
}
|
|
bool usingVariablePointers() const { return useVariablePointers; }
|
|
|
|
template<class T> T addCounterBufferName(const T& name) const { return name + implicitCounterName; }
|
|
bool hasCounterBufferName(const TString& name) const {
|
|
size_t len = strlen(implicitCounterName);
|
|
return name.size() > len &&
|
|
name.compare(name.size() - len, len, implicitCounterName) == 0;
|
|
}
|
|
|
|
void setTextureSamplerTransformMode(EShTextureSamplerTransformMode mode) { textureSamplerTransformMode = mode; }
|
|
|
|
void setVersion(int v) { version = v; }
|
|
int getVersion() const { return version; }
|
|
void setProfile(EProfile p) { profile = p; }
|
|
EProfile getProfile() const { return profile; }
|
|
void setSpv(const SpvVersion& s)
|
|
{
|
|
spvVersion = s;
|
|
|
|
// client processes
|
|
if (spvVersion.vulkan > 0)
|
|
processes.addProcess("client vulkan100");
|
|
if (spvVersion.openGl > 0)
|
|
processes.addProcess("client opengl100");
|
|
|
|
// target SPV
|
|
switch (spvVersion.spv) {
|
|
case 0:
|
|
break;
|
|
case EShTargetSpv_1_0:
|
|
break;
|
|
case EShTargetSpv_1_1:
|
|
processes.addProcess("target-env spirv1.1");
|
|
break;
|
|
case EShTargetSpv_1_2:
|
|
processes.addProcess("target-env spirv1.2");
|
|
break;
|
|
case EShTargetSpv_1_3:
|
|
processes.addProcess("target-env spirv1.3");
|
|
break;
|
|
default:
|
|
processes.addProcess("target-env spirvUnknown");
|
|
break;
|
|
}
|
|
|
|
// target-environment processes
|
|
switch (spvVersion.vulkan) {
|
|
case 0:
|
|
break;
|
|
case EShTargetVulkan_1_0:
|
|
processes.addProcess("target-env vulkan1.0");
|
|
break;
|
|
case EShTargetVulkan_1_1:
|
|
processes.addProcess("target-env vulkan1.1");
|
|
break;
|
|
default:
|
|
processes.addProcess("target-env vulkanUnknown");
|
|
break;
|
|
}
|
|
if (spvVersion.openGl > 0)
|
|
processes.addProcess("target-env opengl");
|
|
}
|
|
const SpvVersion& getSpv() const { return spvVersion; }
|
|
EShLanguage getStage() const { return language; }
|
|
void addRequestedExtension(const char* extension) { requestedExtensions.insert(extension); }
|
|
const std::set<std::string>& getRequestedExtensions() const { return requestedExtensions; }
|
|
|
|
void setTreeRoot(TIntermNode* r) { treeRoot = r; }
|
|
TIntermNode* getTreeRoot() const { return treeRoot; }
|
|
void incrementEntryPointCount() { ++numEntryPoints; }
|
|
int getNumEntryPoints() const { return numEntryPoints; }
|
|
int getNumErrors() const { return numErrors; }
|
|
void addPushConstantCount() { ++numPushConstants; }
|
|
#ifdef NV_EXTENSIONS
|
|
void addShaderRecordNVCount() { ++numShaderRecordNVBlocks; }
|
|
void addTaskNVCount() { ++numTaskNVBlocks; }
|
|
#endif
|
|
|
|
bool isRecursive() const { return recursive; }
|
|
|
|
TIntermSymbol* addSymbol(const TVariable&);
|
|
TIntermSymbol* addSymbol(const TVariable&, const TSourceLoc&);
|
|
TIntermSymbol* addSymbol(const TType&, const TSourceLoc&);
|
|
TIntermSymbol* addSymbol(const TIntermSymbol&);
|
|
TIntermTyped* addConversion(TOperator, const TType&, TIntermTyped*);
|
|
std::tuple<TIntermTyped*, TIntermTyped*> addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* node1);
|
|
TIntermTyped* addUniShapeConversion(TOperator, const TType&, TIntermTyped*);
|
|
TIntermTyped* addConversion(TBasicType convertTo, TIntermTyped* node) const;
|
|
void addBiShapeConversion(TOperator, TIntermTyped*& lhsNode, TIntermTyped*& rhsNode);
|
|
TIntermTyped* addShapeConversion(const TType&, TIntermTyped*);
|
|
TIntermTyped* addConstantReferenceConversion(TIntermTyped* node);
|
|
TIntermTyped* addBinaryMath(TOperator, TIntermTyped* left, TIntermTyped* right, TSourceLoc);
|
|
TIntermTyped* addAssign(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc);
|
|
TIntermTyped* addIndex(TOperator op, TIntermTyped* base, TIntermTyped* index, TSourceLoc);
|
|
TIntermTyped* addUnaryMath(TOperator, TIntermTyped* child, TSourceLoc);
|
|
TIntermTyped* addBuiltInFunctionCall(const TSourceLoc& line, TOperator, bool unary, TIntermNode*, const TType& returnType);
|
|
bool canImplicitlyPromote(TBasicType from, TBasicType to, TOperator op = EOpNull) const;
|
|
bool isIntegralPromotion(TBasicType from, TBasicType to) const;
|
|
bool isFPPromotion(TBasicType from, TBasicType to) const;
|
|
bool isIntegralConversion(TBasicType from, TBasicType to) const;
|
|
bool isFPConversion(TBasicType from, TBasicType to) const;
|
|
bool isFPIntegralConversion(TBasicType from, TBasicType to) const;
|
|
TOperator mapTypeToConstructorOp(const TType&) const;
|
|
TIntermAggregate* growAggregate(TIntermNode* left, TIntermNode* right);
|
|
TIntermAggregate* growAggregate(TIntermNode* left, TIntermNode* right, const TSourceLoc&);
|
|
TIntermAggregate* makeAggregate(TIntermNode* node);
|
|
TIntermAggregate* makeAggregate(TIntermNode* node, const TSourceLoc&);
|
|
TIntermAggregate* makeAggregate(const TSourceLoc&);
|
|
TIntermTyped* setAggregateOperator(TIntermNode*, TOperator, const TType& type, TSourceLoc);
|
|
bool areAllChildConst(TIntermAggregate* aggrNode);
|
|
TIntermSelection* addSelection(TIntermTyped* cond, TIntermNodePair code, const TSourceLoc&);
|
|
TIntermTyped* addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, const TSourceLoc&);
|
|
TIntermTyped* addComma(TIntermTyped* left, TIntermTyped* right, const TSourceLoc&);
|
|
TIntermTyped* addMethod(TIntermTyped*, const TType&, const TString*, const TSourceLoc&);
|
|
TIntermConstantUnion* addConstantUnion(const TConstUnionArray&, const TType&, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(signed char, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(unsigned char, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(signed short, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(unsigned short, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(int, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(unsigned int, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(long long, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(unsigned long long, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(bool, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(double, TBasicType, const TSourceLoc&, bool literal = false) const;
|
|
TIntermConstantUnion* addConstantUnion(const TString*, const TSourceLoc&, bool literal = false) const;
|
|
TIntermTyped* promoteConstantUnion(TBasicType, TIntermConstantUnion*) const;
|
|
bool parseConstTree(TIntermNode*, TConstUnionArray, TOperator, const TType&, bool singleConstantParam = false);
|
|
TIntermLoop* addLoop(TIntermNode*, TIntermTyped*, TIntermTyped*, bool testFirst, const TSourceLoc&);
|
|
TIntermAggregate* addForLoop(TIntermNode*, TIntermNode*, TIntermTyped*, TIntermTyped*, bool testFirst,
|
|
const TSourceLoc&, TIntermLoop*&);
|
|
TIntermBranch* addBranch(TOperator, const TSourceLoc&);
|
|
TIntermBranch* addBranch(TOperator, TIntermTyped*, const TSourceLoc&);
|
|
template<typename selectorType> TIntermTyped* addSwizzle(TSwizzleSelectors<selectorType>&, const TSourceLoc&);
|
|
|
|
// Low level functions to add nodes (no conversions or other higher level transformations)
|
|
// If a type is provided, the node's type will be set to it.
|
|
TIntermBinary* addBinaryNode(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc) const;
|
|
TIntermBinary* addBinaryNode(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc, const TType&) const;
|
|
TIntermUnary* addUnaryNode(TOperator op, TIntermTyped* child, TSourceLoc) const;
|
|
TIntermUnary* addUnaryNode(TOperator op, TIntermTyped* child, TSourceLoc, const TType&) const;
|
|
|
|
// Constant folding (in Constant.cpp)
|
|
TIntermTyped* fold(TIntermAggregate* aggrNode);
|
|
TIntermTyped* foldConstructor(TIntermAggregate* aggrNode);
|
|
TIntermTyped* foldDereference(TIntermTyped* node, int index, const TSourceLoc&);
|
|
TIntermTyped* foldSwizzle(TIntermTyped* node, TSwizzleSelectors<TVectorSelector>& fields, const TSourceLoc&);
|
|
|
|
// Tree ops
|
|
static const TIntermTyped* findLValueBase(const TIntermTyped*, bool swizzleOkay);
|
|
|
|
// Linkage related
|
|
void addSymbolLinkageNodes(TIntermAggregate*& linkage, EShLanguage, TSymbolTable&);
|
|
void addSymbolLinkageNode(TIntermAggregate*& linkage, const TSymbol&);
|
|
|
|
bool setInvocations(int i)
|
|
{
|
|
if (invocations != TQualifier::layoutNotSet)
|
|
return invocations == i;
|
|
invocations = i;
|
|
return true;
|
|
}
|
|
int getInvocations() const { return invocations; }
|
|
bool setVertices(int m)
|
|
{
|
|
if (vertices != TQualifier::layoutNotSet)
|
|
return vertices == m;
|
|
vertices = m;
|
|
return true;
|
|
}
|
|
int getVertices() const { return vertices; }
|
|
bool setInputPrimitive(TLayoutGeometry p)
|
|
{
|
|
if (inputPrimitive != ElgNone)
|
|
return inputPrimitive == p;
|
|
inputPrimitive = p;
|
|
return true;
|
|
}
|
|
TLayoutGeometry getInputPrimitive() const { return inputPrimitive; }
|
|
bool setVertexSpacing(TVertexSpacing s)
|
|
{
|
|
if (vertexSpacing != EvsNone)
|
|
return vertexSpacing == s;
|
|
vertexSpacing = s;
|
|
return true;
|
|
}
|
|
TVertexSpacing getVertexSpacing() const { return vertexSpacing; }
|
|
bool setVertexOrder(TVertexOrder o)
|
|
{
|
|
if (vertexOrder != EvoNone)
|
|
return vertexOrder == o;
|
|
vertexOrder = o;
|
|
return true;
|
|
}
|
|
TVertexOrder getVertexOrder() const { return vertexOrder; }
|
|
void setPointMode() { pointMode = true; }
|
|
bool getPointMode() const { return pointMode; }
|
|
|
|
bool setLocalSize(int dim, int size)
|
|
{
|
|
if (localSize[dim] > 1)
|
|
return size == localSize[dim];
|
|
localSize[dim] = size;
|
|
return true;
|
|
}
|
|
unsigned int getLocalSize(int dim) const { return localSize[dim]; }
|
|
|
|
bool setLocalSizeSpecId(int dim, int id)
|
|
{
|
|
if (localSizeSpecId[dim] != TQualifier::layoutNotSet)
|
|
return id == localSizeSpecId[dim];
|
|
localSizeSpecId[dim] = id;
|
|
return true;
|
|
}
|
|
int getLocalSizeSpecId(int dim) const { return localSizeSpecId[dim]; }
|
|
|
|
void setXfbMode() { xfbMode = true; }
|
|
bool getXfbMode() const { return xfbMode; }
|
|
void setMultiStream() { multiStream = true; }
|
|
bool isMultiStream() const { return multiStream; }
|
|
bool setOutputPrimitive(TLayoutGeometry p)
|
|
{
|
|
if (outputPrimitive != ElgNone)
|
|
return outputPrimitive == p;
|
|
outputPrimitive = p;
|
|
return true;
|
|
}
|
|
TLayoutGeometry getOutputPrimitive() const { return outputPrimitive; }
|
|
void setOriginUpperLeft() { originUpperLeft = true; }
|
|
bool getOriginUpperLeft() const { return originUpperLeft; }
|
|
void setPixelCenterInteger() { pixelCenterInteger = true; }
|
|
bool getPixelCenterInteger() const { return pixelCenterInteger; }
|
|
void setEarlyFragmentTests() { earlyFragmentTests = true; }
|
|
bool getEarlyFragmentTests() const { return earlyFragmentTests; }
|
|
void setPostDepthCoverage() { postDepthCoverage = true; }
|
|
bool getPostDepthCoverage() const { return postDepthCoverage; }
|
|
bool setDepth(TLayoutDepth d)
|
|
{
|
|
if (depthLayout != EldNone)
|
|
return depthLayout == d;
|
|
depthLayout = d;
|
|
return true;
|
|
}
|
|
TLayoutDepth getDepth() const { return depthLayout; }
|
|
void setDepthReplacing() { depthReplacing = true; }
|
|
bool isDepthReplacing() const { return depthReplacing; }
|
|
|
|
void setHlslFunctionality1() { hlslFunctionality1 = true; }
|
|
bool getHlslFunctionality1() const { return hlslFunctionality1; }
|
|
|
|
void addBlendEquation(TBlendEquationShift b) { blendEquations |= (1 << b); }
|
|
unsigned int getBlendEquations() const { return blendEquations; }
|
|
|
|
void addToCallGraph(TInfoSink&, const TString& caller, const TString& callee);
|
|
void merge(TInfoSink&, TIntermediate&);
|
|
void finalCheck(TInfoSink&, bool keepUncalled);
|
|
|
|
void addIoAccessed(const TString& name) { ioAccessed.insert(name); }
|
|
bool inIoAccessed(const TString& name) const { return ioAccessed.find(name) != ioAccessed.end(); }
|
|
|
|
int addUsedLocation(const TQualifier&, const TType&, bool& typeCollision);
|
|
int checkLocationRange(int set, const TIoRange& range, const TType&, bool& typeCollision);
|
|
int addUsedOffsets(int binding, int offset, int numOffsets);
|
|
bool addUsedConstantId(int id);
|
|
static int computeTypeLocationSize(const TType&, EShLanguage);
|
|
static int computeTypeUniformLocationSize(const TType&);
|
|
|
|
bool setXfbBufferStride(int buffer, unsigned stride)
|
|
{
|
|
if (xfbBuffers[buffer].stride != TQualifier::layoutXfbStrideEnd)
|
|
return xfbBuffers[buffer].stride == stride;
|
|
xfbBuffers[buffer].stride = stride;
|
|
return true;
|
|
}
|
|
unsigned getXfbStride(int buffer) const { return xfbBuffers[buffer].stride; }
|
|
int addXfbBufferOffset(const TType&);
|
|
#ifdef AMD_EXTENSIONS
|
|
unsigned int computeTypeXfbSize(const TType&, bool& contains64BitType, bool& contains32BitType, bool& contains16BitType) const;
|
|
#else
|
|
unsigned int computeTypeXfbSize(const TType&, bool& contains64BitType) const;
|
|
#endif
|
|
static int getBaseAlignmentScalar(const TType&, int& size);
|
|
static int getBaseAlignment(const TType&, int& size, int& stride, TLayoutPacking layoutPacking, bool rowMajor);
|
|
static int getScalarAlignment(const TType&, int& size, int& stride, bool rowMajor);
|
|
static int getMemberAlignment(const TType&, int& size, int& stride, TLayoutPacking layoutPacking, bool rowMajor);
|
|
static bool improperStraddle(const TType& type, int size, int offset);
|
|
bool promote(TIntermOperator*);
|
|
|
|
#ifdef NV_EXTENSIONS
|
|
void setLayoutOverrideCoverage() { layoutOverrideCoverage = true; }
|
|
bool getLayoutOverrideCoverage() const { return layoutOverrideCoverage; }
|
|
void setGeoPassthroughEXT() { geoPassthroughEXT = true; }
|
|
bool getGeoPassthroughEXT() const { return geoPassthroughEXT; }
|
|
void setLayoutDerivativeMode(ComputeDerivativeMode mode) { computeDerivativeMode = mode; }
|
|
ComputeDerivativeMode getLayoutDerivativeModeNone() const { return computeDerivativeMode; }
|
|
bool setPrimitives(int m)
|
|
{
|
|
if (primitives != TQualifier::layoutNotSet)
|
|
return primitives == m;
|
|
primitives = m;
|
|
return true;
|
|
}
|
|
int getPrimitives() const { return primitives; }
|
|
#endif
|
|
|
|
const char* addSemanticName(const TString& name)
|
|
{
|
|
return semanticNameSet.insert(name).first->c_str();
|
|
}
|
|
|
|
void setSourceFile(const char* file) { if (file != nullptr) sourceFile = file; }
|
|
const std::string& getSourceFile() const { return sourceFile; }
|
|
void addSourceText(const char* text, size_t len) { sourceText.append(text, len); }
|
|
const std::string& getSourceText() const { return sourceText; }
|
|
const std::map<std::string, std::string>& getIncludeText() const { return includeText; }
|
|
void addIncludeText(const char* name, const char* text, size_t len) { includeText[name].assign(text,len); }
|
|
void addProcesses(const std::vector<std::string>& p)
|
|
{
|
|
for (int i = 0; i < (int)p.size(); ++i)
|
|
processes.addProcess(p[i]);
|
|
}
|
|
void addProcess(const std::string& process) { processes.addProcess(process); }
|
|
void addProcessArgument(const std::string& arg) { processes.addArgument(arg); }
|
|
const std::vector<std::string>& getProcesses() const { return processes.getProcesses(); }
|
|
|
|
void addUniformLocationOverride(const char* nameStr, int location)
|
|
{
|
|
std::string name = nameStr;
|
|
uniformLocationOverrides[name] = location;
|
|
}
|
|
|
|
int getUniformLocationOverride(const char* nameStr) const
|
|
{
|
|
std::string name = nameStr;
|
|
auto pos = uniformLocationOverrides.find(name);
|
|
if (pos == uniformLocationOverrides.end())
|
|
return -1;
|
|
else
|
|
return pos->second;
|
|
}
|
|
|
|
void setUniformLocationBase(int base) { uniformLocationBase = base; }
|
|
int getUniformLocationBase() const { return uniformLocationBase; }
|
|
|
|
void setNeedsLegalization() { needToLegalize = true; }
|
|
bool needsLegalization() const { return needToLegalize; }
|
|
|
|
void setBinaryDoubleOutput() { binaryDoubleOutput = true; }
|
|
bool getBinaryDoubleOutput() { return binaryDoubleOutput; }
|
|
|
|
const char* const implicitThisName;
|
|
const char* const implicitCounterName;
|
|
|
|
protected:
|
|
TIntermSymbol* addSymbol(int Id, const TString&, const TType&, const TConstUnionArray&, TIntermTyped* subtree, const TSourceLoc&);
|
|
void error(TInfoSink& infoSink, const char*);
|
|
void warn(TInfoSink& infoSink, const char*);
|
|
void mergeCallGraphs(TInfoSink&, TIntermediate&);
|
|
void mergeModes(TInfoSink&, TIntermediate&);
|
|
void mergeTrees(TInfoSink&, TIntermediate&);
|
|
void seedIdMap(TMap<TString, int>& idMap, int& maxId);
|
|
void remapIds(const TMap<TString, int>& idMap, int idShift, TIntermediate&);
|
|
void mergeBodies(TInfoSink&, TIntermSequence& globals, const TIntermSequence& unitGlobals);
|
|
void mergeLinkerObjects(TInfoSink&, TIntermSequence& linkerObjects, const TIntermSequence& unitLinkerObjects);
|
|
void mergeImplicitArraySizes(TType&, const TType&);
|
|
void mergeErrorCheck(TInfoSink&, const TIntermSymbol&, const TIntermSymbol&, bool crossStage);
|
|
void checkCallGraphCycles(TInfoSink&);
|
|
void checkCallGraphBodies(TInfoSink&, bool keepUncalled);
|
|
void inOutLocationCheck(TInfoSink&);
|
|
TIntermAggregate* findLinkerObjects() const;
|
|
bool userOutputUsed() const;
|
|
bool isSpecializationOperation(const TIntermOperator&) const;
|
|
bool isNonuniformPropagating(TOperator) const;
|
|
bool promoteUnary(TIntermUnary&);
|
|
bool promoteBinary(TIntermBinary&);
|
|
void addSymbolLinkageNode(TIntermAggregate*& linkage, TSymbolTable&, const TString&);
|
|
bool promoteAggregate(TIntermAggregate&);
|
|
void pushSelector(TIntermSequence&, const TVectorSelector&, const TSourceLoc&);
|
|
void pushSelector(TIntermSequence&, const TMatrixSelector&, const TSourceLoc&);
|
|
bool specConstantPropagates(const TIntermTyped&, const TIntermTyped&);
|
|
void performTextureUpgradeAndSamplerRemovalTransformation(TIntermNode* root);
|
|
bool isConversionAllowed(TOperator op, TIntermTyped* node) const;
|
|
TIntermTyped* createConversion(TBasicType convertTo, TIntermTyped* node) const;
|
|
std::tuple<TBasicType, TBasicType> getConversionDestinatonType(TBasicType type0, TBasicType type1, TOperator op) const;
|
|
bool extensionRequested(const char *extension) const {return requestedExtensions.find(extension) != requestedExtensions.end();}
|
|
static const char* getResourceName(TResourceType);
|
|
|
|
const EShLanguage language; // stage, known at construction time
|
|
EShSource source; // source language, known a bit later
|
|
std::string entryPointName;
|
|
std::string entryPointMangledName;
|
|
typedef std::list<TCall> TGraph;
|
|
TGraph callGraph;
|
|
|
|
EProfile profile; // source profile
|
|
int version; // source version
|
|
SpvVersion spvVersion;
|
|
TIntermNode* treeRoot;
|
|
std::set<std::string> requestedExtensions; // cumulation of all enabled or required extensions; not connected to what subset of the shader used them
|
|
TBuiltInResource resources;
|
|
int numEntryPoints;
|
|
int numErrors;
|
|
int numPushConstants;
|
|
bool recursive;
|
|
int invocations;
|
|
int vertices;
|
|
TLayoutGeometry inputPrimitive;
|
|
TLayoutGeometry outputPrimitive;
|
|
bool pixelCenterInteger;
|
|
bool originUpperLeft;
|
|
TVertexSpacing vertexSpacing;
|
|
TVertexOrder vertexOrder;
|
|
bool pointMode;
|
|
int localSize[3];
|
|
int localSizeSpecId[3];
|
|
bool earlyFragmentTests;
|
|
bool postDepthCoverage;
|
|
TLayoutDepth depthLayout;
|
|
bool depthReplacing;
|
|
bool hlslFunctionality1;
|
|
int blendEquations; // an 'or'ing of masks of shifts of TBlendEquationShift
|
|
bool xfbMode;
|
|
std::vector<TXfbBuffer> xfbBuffers; // all the data we need to track per xfb buffer
|
|
bool multiStream;
|
|
|
|
#ifdef NV_EXTENSIONS
|
|
bool layoutOverrideCoverage;
|
|
bool geoPassthroughEXT;
|
|
int numShaderRecordNVBlocks;
|
|
ComputeDerivativeMode computeDerivativeMode;
|
|
int primitives;
|
|
int numTaskNVBlocks;
|
|
#endif
|
|
|
|
// Base shift values
|
|
std::array<unsigned int, EResCount> shiftBinding;
|
|
|
|
// Per-descriptor-set shift values
|
|
std::array<std::map<int, int>, EResCount> shiftBindingForSet;
|
|
|
|
std::vector<std::string> resourceSetBinding;
|
|
bool autoMapBindings;
|
|
bool autoMapLocations;
|
|
bool invertY;
|
|
bool flattenUniformArrays;
|
|
bool useUnknownFormat;
|
|
bool hlslOffsets;
|
|
bool useStorageBuffer;
|
|
bool useVulkanMemoryModel;
|
|
bool hlslIoMapping;
|
|
bool useVariablePointers;
|
|
|
|
std::set<TString> ioAccessed; // set of names of statically read/written I/O that might need extra checking
|
|
std::vector<TIoRange> usedIo[4]; // sets of used locations, one for each of in, out, uniform, and buffers
|
|
std::vector<TOffsetRange> usedAtomics; // sets of bindings used by atomic counters
|
|
std::unordered_set<int> usedConstantId; // specialization constant ids used
|
|
std::set<TString> semanticNameSet;
|
|
|
|
EShTextureSamplerTransformMode textureSamplerTransformMode;
|
|
|
|
// source code of shader, useful as part of debug information
|
|
std::string sourceFile;
|
|
std::string sourceText;
|
|
|
|
// Included text. First string is a name, second is the included text
|
|
std::map<std::string, std::string> includeText;
|
|
|
|
// for OpModuleProcessed, or equivalent
|
|
TProcesses processes;
|
|
|
|
bool needToLegalize;
|
|
bool binaryDoubleOutput;
|
|
bool usePhysicalStorageBuffer;
|
|
|
|
std::unordered_map<std::string, int> uniformLocationOverrides;
|
|
int uniformLocationBase;
|
|
|
|
private:
|
|
void operator=(TIntermediate&); // prevent assignments
|
|
};
|
|
|
|
} // end namespace glslang
|
|
|
|
#endif // _LOCAL_INTERMEDIATE_INCLUDED_
|