| /* |
| * Copyright 2016 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef SKSL_COMPILER |
| #define SKSL_COMPILER |
| |
| #include <map> |
| #include <set> |
| #include <unordered_set> |
| #include <vector> |
| #include "src/sksl/SkSLASTFile.h" |
| #include "src/sksl/SkSLCFGGenerator.h" |
| #include "src/sksl/SkSLContext.h" |
| #include "src/sksl/SkSLErrorReporter.h" |
| #include "src/sksl/SkSLLexer.h" |
| #include "src/sksl/ir/SkSLProgram.h" |
| #include "src/sksl/ir/SkSLSymbolTable.h" |
| |
| #if !defined(SKSL_STANDALONE) && SK_SUPPORT_GPU |
| #include "src/gpu/GrShaderVar.h" |
| #endif |
| |
| #define SK_FRAGCOLOR_BUILTIN 10001 |
| #define SK_IN_BUILTIN 10002 |
| #define SK_INCOLOR_BUILTIN 10003 |
| #define SK_OUTCOLOR_BUILTIN 10004 |
| #define SK_TRANSFORMEDCOORDS2D_BUILTIN 10005 |
| #define SK_TEXTURESAMPLERS_BUILTIN 10006 |
| #define SK_OUT_BUILTIN 10007 |
| #define SK_LASTFRAGCOLOR_BUILTIN 10008 |
| #define SK_MAIN_COORDS_BUILTIN 10009 |
| #define SK_WIDTH_BUILTIN 10011 |
| #define SK_HEIGHT_BUILTIN 10012 |
| #define SK_FRAGCOORD_BUILTIN 15 |
| #define SK_CLOCKWISE_BUILTIN 17 |
| #define SK_SAMPLEMASK_BUILTIN 20 |
| #define SK_VERTEXID_BUILTIN 42 |
| #define SK_INSTANCEID_BUILTIN 43 |
| #define SK_CLIPDISTANCE_BUILTIN 3 |
| #define SK_INVOCATIONID_BUILTIN 8 |
| #define SK_POSITION_BUILTIN 0 |
| |
| namespace SkSL { |
| |
| class ByteCode; |
| class ExternalValue; |
| class IRGenerator; |
| struct PipelineStageArgs; |
| |
| /** |
| * Main compiler entry point. This is a traditional compiler design which first parses the .sksl |
| * file into an abstract syntax tree (a tree of ASTNodes), then performs semantic analysis to |
| * produce a Program (a tree of IRNodes), then feeds the Program into a CodeGenerator to produce |
| * compiled output. |
| * |
| * See the README for information about SkSL. |
| */ |
| class SK_API Compiler : public ErrorReporter { |
| public: |
| static constexpr const char* RTADJUST_NAME = "sk_RTAdjust"; |
| static constexpr const char* PERVERTEX_NAME = "sk_PerVertex"; |
| |
| enum Flags { |
| kNone_Flags = 0, |
| // permits static if/switch statements to be used with non-constant tests. This is used when |
| // producing H and CPP code; the static tests don't have to have constant values *yet*, but |
| // the generated code will contain a static test which then does have to be a constant. |
| kPermitInvalidStaticTests_Flag = 1, |
| }; |
| |
| // An invalid (otherwise unused) character to mark where FormatArgs are inserted |
| static constexpr char kFormatArgPlaceholder = '\001'; |
| static constexpr const char* kFormatArgPlaceholderStr = "\001"; |
| |
| struct FormatArg { |
| enum class Kind { |
| kInput, |
| kOutput, |
| kCoords, |
| kUniform, |
| kChildProcessor, |
| kChildProcessorWithMatrix, |
| kFunctionName |
| }; |
| |
| FormatArg(Kind kind) |
| : fKind(kind) {} |
| |
| FormatArg(Kind kind, int index) |
| : fKind(kind) |
| , fIndex(index) {} |
| |
| Kind fKind; |
| int fIndex; |
| String fCoords; |
| }; |
| |
| #if !defined(SKSL_STANDALONE) && SK_SUPPORT_GPU |
| /** |
| * Represents the arguments to GrGLSLShaderBuilder::emitFunction. |
| */ |
| struct GLSLFunction { |
| GrSLType fReturnType; |
| SkString fName; |
| std::vector<GrShaderVar> fParameters; |
| String fBody; |
| std::vector<Compiler::FormatArg> fFormatArgs; |
| }; |
| #endif |
| |
| Compiler(Flags flags = kNone_Flags); |
| |
| ~Compiler() override; |
| |
| Compiler(const Compiler&) = delete; |
| Compiler& operator=(const Compiler&) = delete; |
| |
| /** |
| * Registers an ExternalValue as a top-level symbol which is visible in the global namespace. |
| */ |
| void registerExternalValue(ExternalValue* value); |
| |
| std::unique_ptr<Program> convertProgram(Program::Kind kind, String text, |
| const Program::Settings& settings); |
| |
| bool optimize(Program& program); |
| |
| std::unique_ptr<Program> specialize(Program& program, |
| const std::unordered_map<SkSL::String, SkSL::Program::Settings::Value>& inputs); |
| |
| bool toSPIRV(Program& program, OutputStream& out); |
| |
| bool toSPIRV(Program& program, String* out); |
| |
| bool toGLSL(Program& program, OutputStream& out); |
| |
| bool toGLSL(Program& program, String* out); |
| |
| bool toHLSL(Program& program, String* out); |
| |
| bool toMetal(Program& program, OutputStream& out); |
| |
| bool toMetal(Program& program, String* out); |
| |
| bool toCPP(Program& program, String name, OutputStream& out); |
| |
| bool toH(Program& program, String name, OutputStream& out); |
| |
| std::unique_ptr<ByteCode> toByteCode(Program& program); |
| |
| #if !defined(SKSL_STANDALONE) && SK_SUPPORT_GPU |
| bool toPipelineStage(const Program& program, PipelineStageArgs* outArgs); |
| #endif |
| |
| /** |
| * Takes ownership of the given symbol. It will be destroyed when the compiler is destroyed. |
| */ |
| Symbol* takeOwnership(std::unique_ptr<Symbol> symbol); |
| |
| void error(int offset, String msg) override; |
| |
| String errorText(); |
| |
| void writeErrorCount(); |
| |
| int errorCount() override { |
| return fErrorCount; |
| } |
| |
| Context& context() { |
| return *fContext; |
| } |
| |
| static const char* OperatorName(Token::Kind token); |
| |
| static bool IsAssignment(Token::Kind token); |
| |
| private: |
| void processIncludeFile(Program::Kind kind, const char* src, size_t length, |
| std::shared_ptr<SymbolTable> base, |
| std::vector<std::unique_ptr<ProgramElement>>* outElements, |
| std::shared_ptr<SymbolTable>* outSymbolTable); |
| |
| void addDefinition(const Expression* lvalue, std::unique_ptr<Expression>* expr, |
| DefinitionMap* definitions); |
| |
| void addDefinitions(const BasicBlock::Node& node, DefinitionMap* definitions); |
| |
| void scanCFG(CFG* cfg, BlockId block, std::set<BlockId>* workList); |
| |
| void computeDataFlow(CFG* cfg); |
| |
| /** |
| * Simplifies the expression pointed to by iter (in both the IR and CFG structures), if |
| * possible. |
| */ |
| void simplifyExpression(DefinitionMap& definitions, |
| BasicBlock& b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| std::unordered_set<const Variable*>* undefinedVariables, |
| bool* outUpdated, |
| bool* outNeedsRescan); |
| |
| /** |
| * Simplifies the statement pointed to by iter (in both the IR and CFG structures), if |
| * possible. |
| */ |
| void simplifyStatement(DefinitionMap& definitions, |
| BasicBlock& b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| std::unordered_set<const Variable*>* undefinedVariables, |
| bool* outUpdated, |
| bool* outNeedsRescan); |
| |
| void scanCFG(FunctionDefinition& f); |
| |
| Position position(int offset); |
| |
| std::map<String, std::pair<std::unique_ptr<ProgramElement>, bool>> fGPUIntrinsics; |
| std::map<String, std::pair<std::unique_ptr<ProgramElement>, bool>> fInterpreterIntrinsics; |
| std::unique_ptr<ASTFile> fGpuIncludeSource; |
| std::shared_ptr<SymbolTable> fGpuSymbolTable; |
| std::vector<std::unique_ptr<ProgramElement>> fVertexInclude; |
| std::shared_ptr<SymbolTable> fVertexSymbolTable; |
| std::vector<std::unique_ptr<ProgramElement>> fFragmentInclude; |
| std::shared_ptr<SymbolTable> fFragmentSymbolTable; |
| std::vector<std::unique_ptr<ProgramElement>> fGeometryInclude; |
| std::shared_ptr<SymbolTable> fGeometrySymbolTable; |
| std::vector<std::unique_ptr<ProgramElement>> fPipelineInclude; |
| std::shared_ptr<SymbolTable> fPipelineSymbolTable; |
| std::vector<std::unique_ptr<ProgramElement>> fInterpreterInclude; |
| std::shared_ptr<SymbolTable> fInterpreterSymbolTable; |
| |
| std::shared_ptr<SymbolTable> fTypes; |
| IRGenerator* fIRGenerator; |
| int fFlags; |
| |
| const String* fSource; |
| std::shared_ptr<Context> fContext; |
| int fErrorCount; |
| String fErrorText; |
| }; |
| |
| #if !defined(SKSL_STANDALONE) && SK_SUPPORT_GPU |
| struct PipelineStageArgs { |
| String fCode; |
| std::vector<Compiler::FormatArg> fFormatArgs; |
| std::vector<Compiler::GLSLFunction> fFunctions; |
| }; |
| #endif |
| |
| } // namespace |
| |
| #endif |