1 /* 2 * Copyright 2016 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SKSL_IRGENERATOR 9 #define SKSL_IRGENERATOR 10 11 #include "SkSLErrorReporter.h" 12 #include "ast/SkSLASTBinaryExpression.h" 13 #include "ast/SkSLASTBlock.h" 14 #include "ast/SkSLASTBreakStatement.h" 15 #include "ast/SkSLASTCallSuffix.h" 16 #include "ast/SkSLASTContinueStatement.h" 17 #include "ast/SkSLASTDiscardStatement.h" 18 #include "ast/SkSLASTDoStatement.h" 19 #include "ast/SkSLASTExpression.h" 20 #include "ast/SkSLASTExpressionStatement.h" 21 #include "ast/SkSLASTExtension.h" 22 #include "ast/SkSLASTForStatement.h" 23 #include "ast/SkSLASTFunction.h" 24 #include "ast/SkSLASTIdentifier.h" 25 #include "ast/SkSLASTIfStatement.h" 26 #include "ast/SkSLASTInterfaceBlock.h" 27 #include "ast/SkSLASTModifiersDeclaration.h" 28 #include "ast/SkSLASTPrefixExpression.h" 29 #include "ast/SkSLASTReturnStatement.h" 30 #include "ast/SkSLASTSection.h" 31 #include "ast/SkSLASTStatement.h" 32 #include "ast/SkSLASTSuffixExpression.h" 33 #include "ast/SkSLASTSwitchStatement.h" 34 #include "ast/SkSLASTTernaryExpression.h" 35 #include "ast/SkSLASTVarDeclaration.h" 36 #include "ast/SkSLASTVarDeclarationStatement.h" 37 #include "ast/SkSLASTWhileStatement.h" 38 #include "ir/SkSLBlock.h" 39 #include "ir/SkSLExpression.h" 40 #include "ir/SkSLExtension.h" 41 #include "ir/SkSLFunctionDefinition.h" 42 #include "ir/SkSLInterfaceBlock.h" 43 #include "ir/SkSLModifiers.h" 44 #include "ir/SkSLModifiersDeclaration.h" 45 #include "ir/SkSLProgram.h" 46 #include "ir/SkSLSection.h" 47 #include "ir/SkSLSymbolTable.h" 48 #include "ir/SkSLStatement.h" 49 #include "ir/SkSLType.h" 50 #include "ir/SkSLTypeReference.h" 51 #include "ir/SkSLVarDeclarations.h" 52 53 namespace SkSL { 54 55 /** 56 * Performs semantic analysis on an abstract syntax tree (AST) and produces the corresponding 57 * (unoptimized) intermediate representation (IR). 58 */ 59 class IRGenerator { 60 public: 61 IRGenerator(const Context* context, std::shared_ptr<SymbolTable> root, 62 ErrorReporter& errorReporter); 63 64 void convertProgram(String text, 65 SymbolTable& types, 66 Modifiers::Flag* defaultPrecision, 67 std::vector<std::unique_ptr<ProgramElement>>* result); 68 69 /** 70 * If both operands are compile-time constants and can be folded, returns an expression 71 * representing the folded value. Otherwise, returns null. Note that unlike most other functions 72 * here, null does not represent a compilation error. 73 */ 74 std::unique_ptr<Expression> constantFold(const Expression& left, 75 Token::Kind op, 76 const Expression& right) const; 77 Program::Inputs fInputs; 78 const Program::Settings* fSettings; 79 const Context& fContext; 80 81 private: 82 /** 83 * Prepare to compile a program. Resets state, pushes a new symbol table, and installs the 84 * settings. 85 */ 86 void start(const Program::Settings* settings); 87 88 /** 89 * Performs cleanup after compilation is complete. 90 */ 91 void finish(); 92 93 void pushSymbolTable(); 94 void popSymbolTable(); 95 96 std::unique_ptr<VarDeclarations> convertVarDeclarations(const ASTVarDeclarations& decl, 97 Variable::Storage storage); 98 void convertFunction(const ASTFunction& f, 99 std::vector<std::unique_ptr<ProgramElement>>* out); 100 std::unique_ptr<Statement> convertStatement(const ASTStatement& statement); 101 std::unique_ptr<Expression> convertExpression(const ASTExpression& expression); 102 std::unique_ptr<ModifiersDeclaration> convertModifiersDeclaration( 103 const ASTModifiersDeclaration& m); 104 105 const Type* convertType(const ASTType& type); 106 std::unique_ptr<Expression> call(Position position, 107 const FunctionDeclaration& function, 108 std::vector<std::unique_ptr<Expression>> arguments); 109 bool determineCallCost(const FunctionDeclaration& function, 110 const std::vector<std::unique_ptr<Expression>>& arguments, 111 int* outCost); 112 std::unique_ptr<Expression> call(Position position, std::unique_ptr<Expression> function, 113 std::vector<std::unique_ptr<Expression>> arguments); 114 std::unique_ptr<Expression> coerce(std::unique_ptr<Expression> expr, const Type& type); 115 std::unique_ptr<Block> convertBlock(const ASTBlock& block); 116 std::unique_ptr<Statement> convertBreak(const ASTBreakStatement& b); 117 std::unique_ptr<Expression> convertNumberConstructor( 118 Position position, 119 const Type& type, 120 std::vector<std::unique_ptr<Expression>> params); 121 std::unique_ptr<Expression> convertCompoundConstructor( 122 Position position, 123 const Type& type, 124 std::vector<std::unique_ptr<Expression>> params); 125 std::unique_ptr<Expression> convertConstructor(Position position, 126 const Type& type, 127 std::vector<std::unique_ptr<Expression>> params); 128 std::unique_ptr<Statement> convertContinue(const ASTContinueStatement& c); 129 std::unique_ptr<Statement> convertDiscard(const ASTDiscardStatement& d); 130 std::unique_ptr<Statement> convertDo(const ASTDoStatement& d); 131 std::unique_ptr<Statement> convertSwitch(const ASTSwitchStatement& s); 132 std::unique_ptr<Expression> convertBinaryExpression(const ASTBinaryExpression& expression); 133 std::unique_ptr<Extension> convertExtension(const ASTExtension& e); 134 std::unique_ptr<Statement> convertExpressionStatement(const ASTExpressionStatement& s); 135 std::unique_ptr<Statement> convertFor(const ASTForStatement& f); 136 std::unique_ptr<Expression> convertIdentifier(const ASTIdentifier& identifier); 137 std::unique_ptr<Statement> convertIf(const ASTIfStatement& s); 138 std::unique_ptr<Expression> convertIndex(std::unique_ptr<Expression> base, 139 const ASTExpression& index); 140 std::unique_ptr<InterfaceBlock> convertInterfaceBlock(const ASTInterfaceBlock& s); 141 Modifiers convertModifiers(const Modifiers& m); 142 std::unique_ptr<Expression> convertPrefixExpression(const ASTPrefixExpression& expression); 143 std::unique_ptr<Statement> convertReturn(const ASTReturnStatement& r); 144 std::unique_ptr<Section> convertSection(const ASTSection& e); 145 std::unique_ptr<Expression> getCap(Position position, String name); 146 std::unique_ptr<Expression> getArg(Position position, String name); 147 std::unique_ptr<Expression> convertSuffixExpression(const ASTSuffixExpression& expression); 148 std::unique_ptr<Expression> convertField(std::unique_ptr<Expression> base, 149 const String& field); 150 std::unique_ptr<Expression> convertSwizzle(std::unique_ptr<Expression> base, 151 const String& fields); 152 std::unique_ptr<Expression> convertTernaryExpression(const ASTTernaryExpression& expression); 153 std::unique_ptr<Statement> convertVarDeclarationStatement(const ASTVarDeclarationStatement& s); 154 std::unique_ptr<Statement> convertWhile(const ASTWhileStatement& w); 155 std::unique_ptr<Block> applyInvocationIDWorkaround( 156 std::unique_ptr<Block> main, 157 std::vector<std::unique_ptr<ProgramElement>>* out); 158 159 /** 160 * Wraps an expression in code that applies a colorspace transformation to it. This is used 161 * to implement texture(sampler, coord, colorSpaceXForm). 162 */ 163 std::unique_ptr<Expression> applyColorSpace(std::unique_ptr<Expression> texture, 164 std::unique_ptr<Expression> xform); 165 void fixRectSampling(std::vector<std::unique_ptr<Expression>>& arguments); 166 void checkValid(const Expression& expr); 167 void markWrittenTo(const Expression& expr, bool readWrite); 168 169 const FunctionDeclaration* fCurrentFunction; 170 std::unordered_map<String, Program::Settings::Value> fCapsMap; 171 std::shared_ptr<SymbolTable> fRootSymbolTable; 172 std::shared_ptr<SymbolTable> fSymbolTable; 173 // holds extra temp variable declarations needed for the current function 174 std::vector<std::unique_ptr<Statement>> fExtraVars; 175 int fLoopLevel; 176 int fSwitchLevel; 177 // count of temporary variables we have created 178 int fTmpCount; 179 ErrorReporter& fErrors; 180 int fInvocations; 181 182 friend class AutoSymbolTable; 183 friend class AutoLoopLevel; 184 friend class AutoSwitchLevel; 185 friend class Compiler; 186 }; 187 188 } 189 190 #endif 191
