blob: 9ac2e8dc87e3d06b28b96740b5d92e763ccaf059 [file] [log] [blame]
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
#include "intermediate.h"
#include "ParseHelper.h"
#include "Shader/PixelShader.hpp"
#include "Shader/VertexShader.hpp"
#include <list>
#include <set>
#include <map>
namespace es2
class Shader;
typedef unsigned int GLenum;
namespace glsl
struct BlockMemberInfo
BlockMemberInfo() : offset(-1), arrayStride(-1), matrixStride(-1), isRowMajorMatrix(false) {}
BlockMemberInfo(int offset, int arrayStride, int matrixStride, bool isRowMajorMatrix)
: offset(offset),
static BlockMemberInfo getDefaultBlockInfo()
return BlockMemberInfo(-1, -1, -1, false);
int offset;
int arrayStride;
int matrixStride;
bool isRowMajorMatrix;
struct ShaderVariable
ShaderVariable(const TType& type, const std::string& name, int registerIndex);
GLenum type;
GLenum precision;
std::string name;
int arraySize;
int registerIndex;
std::vector<ShaderVariable> fields;
struct Uniform : public ShaderVariable
Uniform(const TType& type, const std::string &name, int registerIndex, int blockId, const BlockMemberInfo& blockMemberInfo);
int blockId;
BlockMemberInfo blockInfo;
typedef std::vector<Uniform> ActiveUniforms;
struct UniformBlock
UniformBlock(const std::string& name, unsigned int dataSize, unsigned int arraySize,
TLayoutBlockStorage layout, bool isRowMajorLayout, int registerIndex, int blockId);
std::string name;
unsigned int dataSize;
unsigned int arraySize;
TLayoutBlockStorage layout;
bool isRowMajorLayout;
std::vector<int> fields;
int registerIndex;
int blockId;
class BlockLayoutEncoder
virtual ~BlockLayoutEncoder() {}
BlockMemberInfo encodeType(const TType &type);
size_t getBlockSize() const { return mCurrentOffset * BytesPerComponent; }
virtual void enterAggregateType() = 0;
virtual void exitAggregateType() = 0;
static const size_t BytesPerComponent = 4u;
static const unsigned int ComponentsPerRegister = 4u;
static size_t getBlockRegister(const BlockMemberInfo &info);
static size_t getBlockRegisterElement(const BlockMemberInfo &info);
size_t mCurrentOffset;
void nextRegister();
virtual void getBlockLayoutInfo(const TType &type, unsigned int arraySize, bool isRowMajorMatrix, int *arrayStrideOut, int *matrixStrideOut) = 0;
virtual void advanceOffset(const TType &type, unsigned int arraySize, bool isRowMajorMatrix, int arrayStride, int matrixStride) = 0;
// Block layout according to the std140 block layout
// See "Standard Uniform Block Layout" in Section 2.11.6 of the OpenGL ES 3.0 specification
class Std140BlockEncoder : public BlockLayoutEncoder
void enterAggregateType() override;
void exitAggregateType() override;
void getBlockLayoutInfo(const TType &type, unsigned int arraySize, bool isRowMajorMatrix, int *arrayStrideOut, int *matrixStrideOut) override;
void advanceOffset(const TType &type, unsigned int arraySize, bool isRowMajorMatrix, int arrayStride, int matrixStride) override;
typedef std::vector<UniformBlock> ActiveUniformBlocks;
struct Attribute
Attribute(GLenum type, const std::string &name, int arraySize, int layoutLocation, int registerIndex);
GLenum type;
std::string name;
int arraySize;
int layoutLocation;
int registerIndex;
typedef std::vector<Attribute> ActiveAttributes;
struct Varying : public ShaderVariable
Varying(const TType& type, const std::string &name, int reg = -1, int col = -1)
: ShaderVariable(type, name, reg), qualifier(type.getQualifier()), column(col)
bool isArray() const
return arraySize >= 1;
int size() const // Unify with es2::Uniform?
return arraySize > 0 ? arraySize : 1;
TQualifier qualifier;
int column; // First register element, assigned during link
typedef std::list<Varying> VaryingList;
class Shader
friend class OutputASM;
virtual ~Shader() {}
virtual sw::Shader *getShader() const = 0;
virtual sw::PixelShader *getPixelShader() const;
virtual sw::VertexShader *getVertexShader() const;
int getShaderVersion() const { return shaderVersion; }
VaryingList varyings;
ActiveUniforms activeUniforms;
ActiveUniforms activeUniformStructs;
ActiveAttributes activeAttributes;
ActiveUniformBlocks activeUniformBlocks;
int shaderVersion;
struct Function
Function(int label, const char *name, TIntermSequence *arg, TIntermTyped *ret) : label(label), name(name), arg(arg), ret(ret)
Function(int label, const TString &name, TIntermSequence *arg, TIntermTyped *ret) : label(label), name(name), arg(arg), ret(ret)
int label;
TString name;
TIntermSequence *arg;
TIntermTyped *ret;
typedef sw::Shader::Instruction Instruction;
class Temporary;
class OutputASM : public TIntermTraverser
explicit OutputASM(TParseContext &context, Shader *shaderObject);
void output();
void freeTemporary(Temporary *temporary);
enum Scope
struct TextureFunction
TextureFunction(const TString& name);
enum Method
IMPLICIT, // Mipmap LOD determined implicitly (standard lookup)
SIZE, // textureSize()
Method method;
bool proj;
bool offset;
void emitShader(Scope scope);
// Visit AST nodes and output their code to the body stream
void visitSymbol(TIntermSymbol*) override;
bool visitBinary(Visit visit, TIntermBinary*) override;
bool visitUnary(Visit visit, TIntermUnary*) override;
bool visitSelection(Visit visit, TIntermSelection*) override;
bool visitAggregate(Visit visit, TIntermAggregate*) override;
bool visitLoop(Visit visit, TIntermLoop*) override;
bool visitBranch(Visit visit, TIntermBranch*) override;
bool visitSwitch(Visit, TIntermSwitch*) override;
sw::Shader::Opcode getOpcode(sw::Shader::Opcode op, TIntermTyped *in) const;
Instruction *emit(sw::Shader::Opcode op, TIntermTyped *dst = 0, TIntermNode *src0 = 0, TIntermNode *src1 = 0, TIntermNode *src2 = 0, TIntermNode *src3 = 0, TIntermNode *src4 = 0);
Instruction *emit(sw::Shader::Opcode op, TIntermTyped *dst, int dstIndex, TIntermNode *src0 = 0, int index0 = 0, TIntermNode *src1 = 0, int index1 = 0,
TIntermNode *src2 = 0, int index2 = 0, TIntermNode *src3 = 0, int index3 = 0, TIntermNode *src4 = 0, int index4 = 0);
Instruction *emitCast(TIntermTyped *dst, TIntermTyped *src);
Instruction *emitCast(TIntermTyped *dst, int dstIndex, TIntermTyped *src, int srcIndex);
void emitBinary(sw::Shader::Opcode op, TIntermTyped *dst = 0, TIntermNode *src0 = 0, TIntermNode *src1 = 0, TIntermNode *src2 = 0);
void emitAssign(sw::Shader::Opcode op, TIntermTyped *result, TIntermTyped *lhs, TIntermTyped *src0, TIntermTyped *src1 = 0);
void emitCmp(sw::Shader::Control cmpOp, TIntermTyped *dst, TIntermNode *left, TIntermNode *right, int index = 0);
void emitDeterminant(TIntermTyped *result, TIntermTyped *arg, int size, int col = -1, int row = -1, int outCol = 0, int outRow = 0);
void source(sw::Shader::SourceParameter &parameter, TIntermNode *argument, int index = 0);
void destination(sw::Shader::DestinationParameter &parameter, TIntermTyped *argument, int index = 0);
void copy(TIntermTyped *dst, TIntermNode *src, int offset = 0);
void assignLvalue(TIntermTyped *dst, TIntermTyped *src);
void evaluateRvalue(TIntermTyped *node);
int lvalue(sw::Shader::DestinationParameter &dst, TIntermTyped *node);
int lvalue(TIntermTyped *&root, unsigned int &offset, sw::Shader::Relative &rel, unsigned char &mask, Temporary &address, TIntermTyped *node);
sw::Shader::ParameterType registerType(TIntermTyped *operand);
bool hasFlatQualifier(TIntermTyped *operand);
unsigned int registerIndex(TIntermTyped *operand);
int writeMask(TIntermTyped *destination, int index = 0);
int readSwizzle(TIntermTyped *argument, int size);
bool trivial(TIntermTyped *expression, int budget); // Fast to compute and no side effects
int cost(TIntermNode *expression, int budget);
const Function *findFunction(const TString &name);
int temporaryRegister(TIntermTyped *temporary);
int varyingRegister(TIntermTyped *varying);
void setPixelShaderInputs(const TType& type, int var, bool flat);
void declareVarying(TIntermTyped *varying, int reg);
void declareVarying(const TType &type, const TString &name, int registerIndex);
void declareFragmentOutput(TIntermTyped *fragmentOutput);
int uniformRegister(TIntermTyped *uniform);
int attributeRegister(TIntermTyped *attribute);
int fragmentOutputRegister(TIntermTyped *fragmentOutput);
int samplerRegister(TIntermTyped *sampler);
int samplerRegister(TIntermSymbol *sampler);
bool isSamplerRegister(TIntermTyped *operand);
bool arrayExceedsLimits(TIntermTyped *operand);
typedef std::vector<TIntermTyped*> VariableArray;
int lookup(VariableArray &list, TIntermTyped *variable);
int lookup(VariableArray &list, TInterfaceBlock *block);
int blockMemberLookup(const TType &type, const TString &name, int registerIndex);
// Returns -1 if it fails to allocate variable.
int allocate(VariableArray &list, TIntermTyped *variable, bool samplersOnly = false);
void free(VariableArray &list, TIntermTyped *variable);
void declareUniform(const TType &type, const TString &name, int registerIndex, bool samplersOnly, int blockId = -1, BlockLayoutEncoder* encoder = nullptr);
static int dim(TIntermNode *v);
static int dim2(TIntermNode *m);
struct LoopInfo
LoopInfo(TIntermLoop *node);
bool isDeterministic()
return (iterations != ~0u);
unsigned int iterations = ~0u;
TIntermSymbol *index = nullptr;
TOperator comparator = EOpNull;
int initial = 0;
int limit = 0;
int increment = 0;
Shader *const shaderObject;
sw::Shader *shader;
sw::PixelShader *pixelShader;
sw::VertexShader *vertexShader;
VariableArray temporaries;
VariableArray uniforms;
VariableArray varyings;
VariableArray attributes;
VariableArray samplers;
VariableArray fragmentOutputs;
struct TypedMemberInfo : public BlockMemberInfo
TypedMemberInfo(const BlockMemberInfo& b, const TType& t) : BlockMemberInfo(b), type(t) {}
TType type;
struct ArgumentInfo
ArgumentInfo(const BlockMemberInfo& b, const TType& t, int clampedIndex, int bufferIndex) :
typedMemberInfo(b, t), clampedIndex(clampedIndex), bufferIndex(bufferIndex) {}
TypedMemberInfo typedMemberInfo;
int clampedIndex;
int bufferIndex;
int getBlockId(TIntermTyped *argument);
ArgumentInfo getArgumentInfo(TIntermTyped *argument, int index);
typedef std::map<int, TypedMemberInfo> BlockDefinitionIndexMap;
std::vector<BlockDefinitionIndexMap> blockDefinitions;
Scope emitScope;
Scope currentScope;
int currentFunction;
std::vector<Function> functionArray;
TQualifier outputQualifier;
std::set<int> deterministicVariables;
TParseContext &mContext;
class LoopUnrollable : public TIntermTraverser
bool traverse(TIntermLoop *loop, int loopIndexId);
void visitSymbol(TIntermSymbol *node) override;
bool visitBinary(Visit visit, TIntermBinary *node) override;
bool visitUnary(Visit visit, TIntermUnary *node) override;
bool visitBranch(Visit visit, TIntermBranch *node) override;
bool visitAggregate(Visit visit, TIntermAggregate *node) override;
bool loopUnrollable;
int loopIndexId;