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/SkSLASTEnum.h" 20 #include "ast/SkSLASTExpression.h" 21 #include "ast/SkSLASTExpressionStatement.h" 22 #include "ast/SkSLASTExtension.h" 23 #include "ast/SkSLASTForStatement.h" 24 #include "ast/SkSLASTFunction.h" 25 #include "ast/SkSLASTIdentifier.h" 26 #include "ast/SkSLASTIfStatement.h" 27 #include "ast/SkSLASTInterfaceBlock.h" 28 #include "ast/SkSLASTModifiersDeclaration.h" 29 #include "ast/SkSLASTPrefixExpression.h" 30 #include "ast/SkSLASTReturnStatement.h" 31 #include "ast/SkSLASTSection.h" 32 #include "ast/SkSLASTStatement.h" 33 #include "ast/SkSLASTSuffixExpression.h" 34 #include "ast/SkSLASTSwitchStatement.h" 35 #include "ast/SkSLASTTernaryExpression.h" 36 #include "ast/SkSLASTVarDeclaration.h" 37 #include "ast/SkSLASTVarDeclarationStatement.h" 38 #include "ast/SkSLASTWhileStatement.h" 39 #include "ir/SkSLBlock.h" 40 #include "ir/SkSLExpression.h" 41 #include "ir/SkSLExtension.h" 42 #include "ir/SkSLFunctionDefinition.h" 43 #include "ir/SkSLInterfaceBlock.h" 44 #include "ir/SkSLModifiers.h" 45 #include "ir/SkSLModifiersDeclaration.h" 46 #include "ir/SkSLProgram.h" 47 #include "ir/SkSLSection.h" 48 #include "ir/SkSLSymbolTable.h" 49 #include "ir/SkSLStatement.h" 50 #include "ir/SkSLType.h" 51 #include "ir/SkSLTypeReference.h" 52 #include "ir/SkSLVarDeclarations.h" 53 54 namespace SkSL { 55 56 /** 57 * Performs semantic analysis on an abstract syntax tree (AST) and produces the corresponding 58 * (unoptimized) intermediate representation (IR). 59 */ 60 class IRGenerator { 61 public: 62 IRGenerator(const Context* context, std::shared_ptr<SymbolTable> root, 63 ErrorReporter& errorReporter); 64 65 void convertProgram(Program::Kind kind, 66 const char* text, 67 size_t length, 68 SymbolTable& types, 69 std::vector<std::unique_ptr<ProgramElement>>* result); 70 71 /** 72 * If both operands are compile-time constants and can be folded, returns an expression 73 * representing the folded value. Otherwise, returns null. Note that unlike most other functions 74 * here, null does not represent a compilation error. 75 */ 76 std::unique_ptr<Expression> constantFold(const Expression& left, 77 Token::Kind op, 78 const Expression& right) const; 79 Program::Inputs fInputs; 80 const Program::Settings* fSettings; 81 const Context& fContext; 82 83 private: 84 /** 85 * Prepare to compile a program. Resets state, pushes a new symbol table, and installs the 86 * settings. 87 */ 88 void start(const Program::Settings* settings); 89 90 /** 91 * Performs cleanup after compilation is complete. 92 */ 93 void finish(); 94 95 void pushSymbolTable(); 96 void popSymbolTable(); 97 98 std::unique_ptr<VarDeclarations> convertVarDeclarations(const ASTVarDeclarations& decl, 99 Variable::Storage storage); 100 void convertFunction(const ASTFunction& f); 101 std::unique_ptr<Statement> convertStatement(const ASTStatement& statement); 102 std::unique_ptr<Expression> convertExpression(const ASTExpression& expression); 103 std::unique_ptr<ModifiersDeclaration> convertModifiersDeclaration( 104 const ASTModifiersDeclaration& m); 105 106 const Type* convertType(const ASTType& type); 107 std::unique_ptr<Expression> call(int offset, 108 const FunctionDeclaration& function, 109 std::vector<std::unique_ptr<Expression>> arguments); 110 int callCost(const FunctionDeclaration& function, 111 const std::vector<std::unique_ptr<Expression>>& arguments); 112 std::unique_ptr<Expression> call(int offset, std::unique_ptr<Expression> function, 113 std::vector<std::unique_ptr<Expression>> arguments); 114 int coercionCost(const Expression& expr, const Type& type); 115 std::unique_ptr<Expression> coerce(std::unique_ptr<Expression> expr, const Type& type); 116 std::unique_ptr<Block> convertBlock(const ASTBlock& block); 117 std::unique_ptr<Statement> convertBreak(const ASTBreakStatement& b); 118 std::unique_ptr<Expression> convertNumberConstructor( 119 int offset, 120 const Type& type, 121 std::vector<std::unique_ptr<Expression>> params); 122 std::unique_ptr<Expression> convertCompoundConstructor( 123 int offset, 124 const Type& type, 125 std::vector<std::unique_ptr<Expression>> params); 126 std::unique_ptr<Expression> convertConstructor(int offset, 127 const Type& type, 128 std::vector<std::unique_ptr<Expression>> params); 129 std::unique_ptr<Statement> convertContinue(const ASTContinueStatement& c); 130 std::unique_ptr<Statement> convertDiscard(const ASTDiscardStatement& d); 131 std::unique_ptr<Statement> convertDo(const ASTDoStatement& d); 132 std::unique_ptr<Statement> convertSwitch(const ASTSwitchStatement& s); 133 std::unique_ptr<Expression> convertBinaryExpression(const ASTBinaryExpression& expression); 134 std::unique_ptr<Extension> convertExtension(const ASTExtension& e); 135 std::unique_ptr<Statement> convertExpressionStatement(const ASTExpressionStatement& s); 136 std::unique_ptr<Statement> convertFor(const ASTForStatement& f); 137 std::unique_ptr<Expression> convertIdentifier(const ASTIdentifier& identifier); 138 std::unique_ptr<Statement> convertIf(const ASTIfStatement& s); 139 std::unique_ptr<Expression> convertIndex(std::unique_ptr<Expression> base, 140 const ASTExpression& index); 141 std::unique_ptr<InterfaceBlock> convertInterfaceBlock(const ASTInterfaceBlock& s); 142 Modifiers convertModifiers(const Modifiers& m); 143 std::unique_ptr<Expression> convertPrefixExpression(const ASTPrefixExpression& expression); 144 std::unique_ptr<Statement> convertReturn(const ASTReturnStatement& r); 145 std::unique_ptr<Section> convertSection(const ASTSection& e); 146 std::unique_ptr<Expression> getCap(int offset, String name); 147 std::unique_ptr<Expression> getArg(int offset, String name); 148 std::unique_ptr<Expression> convertSuffixExpression(const ASTSuffixExpression& expression); 149 std::unique_ptr<Expression> convertTypeField(int offset, const Type& type, 150 StringFragment field); 151 std::unique_ptr<Expression> convertField(std::unique_ptr<Expression> base, 152 StringFragment field); 153 std::unique_ptr<Expression> convertSwizzle(std::unique_ptr<Expression> base, 154 StringFragment fields); 155 std::unique_ptr<Expression> convertTernaryExpression(const ASTTernaryExpression& expression); 156 std::unique_ptr<Statement> convertVarDeclarationStatement(const ASTVarDeclarationStatement& s); 157 std::unique_ptr<Statement> convertWhile(const ASTWhileStatement& w); 158 void convertEnum(const ASTEnum& e); 159 std::unique_ptr<Block> applyInvocationIDWorkaround(std::unique_ptr<Block> main); 160 // returns a statement which converts sk_Position from device to normalized coordinates 161 std::unique_ptr<Statement> getNormalizeSkPositionCode(); 162 163 void fixRectSampling(std::vector<std::unique_ptr<Expression>>& arguments); 164 void checkValid(const Expression& expr); 165 void markWrittenTo(const Expression& expr, bool readWrite); 166 void getConstantInt(const Expression& value, int64_t* out); 167 168 Program::Kind fKind; 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 std::vector<std::unique_ptr<ProgramElement>>* fProgramElements; 182 Variable* fSkPerVertex; 183 Variable* fRTAdjust; 184 Variable* fRTAdjustInterfaceBlock; 185 int fRTAdjustFieldIndex; 186 187 friend class AutoSymbolTable; 188 friend class AutoLoopLevel; 189 friend class AutoSwitchLevel; 190 friend class Compiler; 191 }; 192 193 } 194 195 #endif 196