submodule/skia/src/sksl/codegen/SkSLMetalCodeGenerator.h

   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_METALCODEGENERATOR
   9 #define SKSL_METALCODEGENERATOR
  10
  11 #include "include/private/SkSLDefines.h"
  12 #include "include/private/SkTArray.h"
  13 #include "include/private/SkTHash.h"
  14 #include "include/sksl/SkSLOperator.h"
  15 #include "src/sksl/SkSLStringStream.h"
  16 #include "src/sksl/codegen/SkSLCodeGenerator.h"
  17 #include "src/sksl/ir/SkSLType.h"
  18
  19 #include <stdint.h>
  20 #include <initializer_list>
  21 #include <set>
  22 #include <string>
  23 #include <string_view>
  24 #include <vector>
  25
  26 namespace SkSL {
  27
  28 class AnyConstructor;
  29 class BinaryExpression;
  30 class Block;
  31 class ConstructorArrayCast;
  32 class ConstructorCompound;
  33 class ConstructorMatrixResize;
  34 class Context;
  35 class DoStatement;
  36 class Expression;
  37 class ExpressionStatement;
  38 class Extension;
  39 class FieldAccess;
  40 class ForStatement;
  41 class FunctionCall;
  42 class FunctionDeclaration;
  43 class FunctionDefinition;
  44 class FunctionPrototype;
  45 class IfStatement;
  46 class InterfaceBlock;
  47 class Literal;
  48 class OutputStream;
  49 class Position;
  50 class PostfixExpression;
  51 class PrefixExpression;
  52 class ProgramElement;
  53 class ReturnStatement;
  54 class Setting;
  55 class Statement;
  56 class StructDefinition;
  57 class SwitchStatement;
  58 class TernaryExpression;
  59 class VarDeclaration;
  60 class Variable;
  61 class VariableReference;
  62 enum IntrinsicKind : int8_t;
  63 struct IndexExpression;
  64 struct Layout;
  65 struct Modifiers;
  66 struct Program;
  67 struct Swizzle;
  68
  69 /**
  70  * Converts a Program into Metal code.
  71  */
  72 class MetalCodeGenerator : public CodeGenerator {
  73 public:
  74     inline static constexpr const char* SAMPLER_SUFFIX = "Smplr";
  75     inline static constexpr const char* PACKED_PREFIX = "packed_";
  76
  77     MetalCodeGenerator(const Context* context, const Program* program, OutputStream* out)
  78     : INHERITED(context, program, out)
  79     , fReservedWords({"atan2", "rsqrt", "rint", "dfdx", "dfdy", "vertex", "fragment"})
  80     , fLineEnding("\n") {}
  81
  82     bool generateCode() override;
  83
  84 protected:
  85     using Precedence = Operator::Precedence;
  86
  87     typedef int Requirements;
  88     inline static constexpr Requirements kNo_Requirements       = 0;
  89     inline static constexpr Requirements kInputs_Requirement    = 1 << 0;
  90     inline static constexpr Requirements kOutputs_Requirement   = 1 << 1;
  91     inline static constexpr Requirements kUniforms_Requirement  = 1 << 2;
  92     inline static constexpr Requirements kGlobals_Requirement   = 1 << 3;
  93     inline static constexpr Requirements kFragCoord_Requirement = 1 << 4;
  94
  95     class GlobalStructVisitor;
  96     void visitGlobalStruct(GlobalStructVisitor* visitor);
  97
  98     void write(std::string_view s);
  99
 100     void writeLine(std::string_view s = std::string_view());
 101
 102     void finishLine();
 103
 104     void writeHeader();
 105
 106     void writeUniformStruct();
 107
 108     void writeInputStruct();
 109
 110     void writeOutputStruct();
 111
 112     void writeInterfaceBlocks();
 113
 114     void writeStructDefinitions();
 115
 116     void writeFields(const std::vector<Type::Field>& fields, Position pos,
 117                      const InterfaceBlock* parentIntf = nullptr);
 118
 119     int size(const Type* type, bool isPacked) const;
 120
 121     int alignment(const Type* type, bool isPacked) const;
 122
 123     void writeGlobalStruct();
 124
 125     void writeGlobalInit();
 126
 127     void writePrecisionModifier();
 128
 129     std::string typeName(const Type& type);
 130
 131     void writeStructDefinition(const StructDefinition& s);
 132
 133     void writeType(const Type& type);
 134
 135     void writeExtension(const Extension& ext);
 136
 137     void writeInterfaceBlock(const InterfaceBlock& intf);
 138
 139     void writeFunctionRequirementParams(const FunctionDeclaration& f,
 140                                         const char*& separator);
 141
 142     void writeFunctionRequirementArgs(const FunctionDeclaration& f, const char*& separator);
 143
 144     bool writeFunctionDeclaration(const FunctionDeclaration& f);
 145
 146     void writeFunction(const FunctionDefinition& f);
 147
 148     void writeFunctionPrototype(const FunctionPrototype& f);
 149
 150     void writeLayout(const Layout& layout);
 151
 152     void writeModifiers(const Modifiers& modifiers);
 153
 154     void writeVarInitializer(const Variable& var, const Expression& value);
 155
 156     void writeName(std::string_view name);
 157
 158     void writeVarDeclaration(const VarDeclaration& decl);
 159
 160     void writeFragCoord();
 161
 162     void writeVariableReference(const VariableReference& ref);
 163
 164     void writeExpression(const Expression& expr, Precedence parentPrecedence);
 165
 166     void writeMinAbsHack(Expression& absExpr, Expression& otherExpr);
 167
 168     std::string getOutParamHelper(const FunctionCall& c,
 169                              const ExpressionArray& arguments,
 170                              const SkTArray<VariableReference*>& outVars);
 171
 172     std::string getInversePolyfill(const ExpressionArray& arguments);
 173
 174     std::string getBitcastIntrinsic(const Type& outType);
 175
 176     std::string getTempVariable(const Type& varType);
 177
 178     void writeFunctionCall(const FunctionCall& c);
 179
 180     bool matrixConstructHelperIsNeeded(const ConstructorCompound& c);
 181     std::string getMatrixConstructHelper(const AnyConstructor& c);
 182     void assembleMatrixFromMatrix(const Type& sourceMatrix, int rows, int columns);
 183     void assembleMatrixFromExpressions(const AnyConstructor& ctor, int rows, int columns);
 184
 185     void writeMatrixCompMult();
 186
 187     void writeOuterProduct();
 188
 189     void writeMatrixTimesEqualHelper(const Type& left, const Type& right, const Type& result);
 190
 191     void writeMatrixDivisionHelpers(const Type& type);
 192
 193     void writeMatrixEqualityHelpers(const Type& left, const Type& right);
 194
 195     std::string getVectorFromMat2x2ConstructorHelper(const Type& matrixType);
 196
 197     void writeArrayEqualityHelpers(const Type& type);
 198
 199     void writeStructEqualityHelpers(const Type& type);
 200
 201     void writeEqualityHelpers(const Type& leftType, const Type& rightType);
 202
 203     void writeArgumentList(const ExpressionArray& arguments);
 204
 205     void writeSimpleIntrinsic(const FunctionCall& c);
 206
 207     bool writeIntrinsicCall(const FunctionCall& c, IntrinsicKind kind);
 208
 209     void writeConstructorCompound(const ConstructorCompound& c, Precedence parentPrecedence);
 210
 211     void writeConstructorCompoundVector(const ConstructorCompound& c, Precedence parentPrecedence);
 212
 213     void writeConstructorCompoundMatrix(const ConstructorCompound& c, Precedence parentPrecedence);
 214
 215     void writeConstructorMatrixResize(const ConstructorMatrixResize& c,
 216                                       Precedence parentPrecedence);
 217
 218     void writeAnyConstructor(const AnyConstructor& c,
 219                              const char* leftBracket,
 220                              const char* rightBracket,
 221                              Precedence parentPrecedence);
 222
 223     void writeCastConstructor(const AnyConstructor& c,
 224                               const char* leftBracket,
 225                               const char* rightBracket,
 226                               Precedence parentPrecedence);
 227
 228     void writeConstructorArrayCast(const ConstructorArrayCast& c, Precedence parentPrecedence);
 229
 230     void writeFieldAccess(const FieldAccess& f);
 231
 232     void writeSwizzle(const Swizzle& swizzle);
 233
 234     // Splats a scalar expression across a matrix of arbitrary size.
 235     void writeNumberAsMatrix(const Expression& expr, const Type& matrixType);
 236
 237     void writeBinaryExpression(const BinaryExpression& b, Precedence parentPrecedence);
 238
 239     void writeTernaryExpression(const TernaryExpression& t, Precedence parentPrecedence);
 240
 241     void writeIndexExpression(const IndexExpression& expr);
 242
 243     void writePrefixExpression(const PrefixExpression& p, Precedence parentPrecedence);
 244
 245     void writePostfixExpression(const PostfixExpression& p, Precedence parentPrecedence);
 246
 247     void writeLiteral(const Literal& f);
 248
 249     void writeSetting(const Setting& s);
 250
 251     void writeStatement(const Statement& s);
 252
 253     void writeStatements(const StatementArray& statements);
 254
 255     void writeBlock(const Block& b);
 256
 257     void writeIfStatement(const IfStatement& stmt);
 258
 259     void writeForStatement(const ForStatement& f);
 260
 261     void writeDoStatement(const DoStatement& d);
 262
 263     void writeExpressionStatement(const ExpressionStatement& s);
 264
 265     void writeSwitchStatement(const SwitchStatement& s);
 266
 267     void writeReturnStatementFromMain();
 268
 269     void writeReturnStatement(const ReturnStatement& r);
 270
 271     void writeProgramElement(const ProgramElement& e);
 272
 273     Requirements requirements(const FunctionDeclaration& f);
 274
 275     Requirements requirements(const Expression* e);
 276
 277     Requirements requirements(const Statement* s);
 278
 279     int getUniformBinding(const Modifiers& m);
 280
 281     int getUniformSet(const Modifiers& m);
 282
 283     SkTHashSet<std::string_view> fReservedWords;
 284     SkTHashMap<const Type::Field*, const InterfaceBlock*> fInterfaceBlockMap;
 285     SkTHashMap<const InterfaceBlock*, std::string_view> fInterfaceBlockNameMap;
 286     int fAnonInterfaceCount = 0;
 287     int fPaddingCount = 0;
 288     const char* fLineEnding;
 289     std::string fFunctionHeader;
 290     StringStream fExtraFunctions;
 291     StringStream fExtraFunctionPrototypes;
 292     int fVarCount = 0;
 293     int fIndentation = 0;
 294     bool fAtLineStart = false;
 295     std::set<std::string> fWrittenIntrinsics;
 296     // true if we have run into usages of dFdx / dFdy
 297     bool fFoundDerivatives = false;
 298     SkTHashMap<const FunctionDeclaration*, Requirements> fRequirements;
 299     SkTHashSet<std::string> fHelpers;
 300     int fUniformBuffer = -1;
 301     std::string fRTFlipName;
 302     const FunctionDeclaration* fCurrentFunction = nullptr;
 303     int fSwizzleHelperCount = 0;
 304     bool fIgnoreVariableReferenceModifiers = false;
 305
 306     using INHERITED = CodeGenerator;
 307 };
 308
 309 }  // namespace SkSL
 310
 311 #endif