/* * Copyright 2016 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "src/sksl/SkSLSPIRVCodeGenerator.h" #include "src/sksl/GLSL.std.450.h" #include "src/sksl/SkSLCompiler.h" #include "src/sksl/ir/SkSLExpressionStatement.h" #include "src/sksl/ir/SkSLExtension.h" #include "src/sksl/ir/SkSLIndexExpression.h" #include "src/sksl/ir/SkSLVariableReference.h" namespace SkSL { static const int32_t SKSL_MAGIC = 0x0; // FIXME: we should probably register a magic number void SPIRVCodeGenerator::setupIntrinsics() { #define ALL_GLSL(x) std::make_tuple(kGLSL_STD_450_IntrinsicKind, GLSLstd450 ## x, GLSLstd450 ## x, \ GLSLstd450 ## x, GLSLstd450 ## x) #define BY_TYPE_GLSL(ifFloat, ifInt, ifUInt) std::make_tuple(kGLSL_STD_450_IntrinsicKind, \ GLSLstd450 ## ifFloat, \ GLSLstd450 ## ifInt, \ GLSLstd450 ## ifUInt, \ SpvOpUndef) #define ALL_SPIRV(x) std::make_tuple(kSPIRV_IntrinsicKind, SpvOp ## x, SpvOp ## x, SpvOp ## x, \ SpvOp ## x) #define SPECIAL(x) std::make_tuple(kSpecial_IntrinsicKind, k ## x ## _SpecialIntrinsic, \ k ## x ## _SpecialIntrinsic, k ## x ## _SpecialIntrinsic, \ k ## x ## _SpecialIntrinsic) fIntrinsicMap[String("round")] = ALL_GLSL(Round); fIntrinsicMap[String("roundEven")] = ALL_GLSL(RoundEven); fIntrinsicMap[String("trunc")] = ALL_GLSL(Trunc); fIntrinsicMap[String("abs")] = BY_TYPE_GLSL(FAbs, SAbs, SAbs); fIntrinsicMap[String("sign")] = BY_TYPE_GLSL(FSign, SSign, SSign); fIntrinsicMap[String("floor")] = ALL_GLSL(Floor); fIntrinsicMap[String("ceil")] = ALL_GLSL(Ceil); fIntrinsicMap[String("fract")] = ALL_GLSL(Fract); fIntrinsicMap[String("radians")] = ALL_GLSL(Radians); fIntrinsicMap[String("degrees")] = ALL_GLSL(Degrees); fIntrinsicMap[String("sin")] = ALL_GLSL(Sin); fIntrinsicMap[String("cos")] = ALL_GLSL(Cos); fIntrinsicMap[String("tan")] = ALL_GLSL(Tan); fIntrinsicMap[String("asin")] = ALL_GLSL(Asin); fIntrinsicMap[String("acos")] = ALL_GLSL(Acos); fIntrinsicMap[String("atan")] = SPECIAL(Atan); fIntrinsicMap[String("sinh")] = ALL_GLSL(Sinh); fIntrinsicMap[String("cosh")] = ALL_GLSL(Cosh); fIntrinsicMap[String("tanh")] = ALL_GLSL(Tanh); fIntrinsicMap[String("asinh")] = ALL_GLSL(Asinh); fIntrinsicMap[String("acosh")] = ALL_GLSL(Acosh); fIntrinsicMap[String("atanh")] = ALL_GLSL(Atanh); fIntrinsicMap[String("pow")] = ALL_GLSL(Pow); fIntrinsicMap[String("exp")] = ALL_GLSL(Exp); fIntrinsicMap[String("log")] = ALL_GLSL(Log); fIntrinsicMap[String("exp2")] = ALL_GLSL(Exp2); fIntrinsicMap[String("log2")] = ALL_GLSL(Log2); fIntrinsicMap[String("sqrt")] = ALL_GLSL(Sqrt); fIntrinsicMap[String("inverse")] = ALL_GLSL(MatrixInverse); fIntrinsicMap[String("transpose")] = ALL_SPIRV(Transpose); fIntrinsicMap[String("inversesqrt")] = ALL_GLSL(InverseSqrt); fIntrinsicMap[String("determinant")] = ALL_GLSL(Determinant); fIntrinsicMap[String("matrixInverse")] = ALL_GLSL(MatrixInverse); fIntrinsicMap[String("mod")] = SPECIAL(Mod); fIntrinsicMap[String("min")] = SPECIAL(Min); fIntrinsicMap[String("max")] = SPECIAL(Max); fIntrinsicMap[String("clamp")] = SPECIAL(Clamp); fIntrinsicMap[String("saturate")] = SPECIAL(Saturate); fIntrinsicMap[String("dot")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDot, SpvOpUndef, SpvOpUndef, SpvOpUndef); fIntrinsicMap[String("mix")] = SPECIAL(Mix); fIntrinsicMap[String("step")] = ALL_GLSL(Step); fIntrinsicMap[String("smoothstep")] = ALL_GLSL(SmoothStep); fIntrinsicMap[String("fma")] = ALL_GLSL(Fma); fIntrinsicMap[String("frexp")] = ALL_GLSL(Frexp); fIntrinsicMap[String("ldexp")] = ALL_GLSL(Ldexp); #define PACK(type) fIntrinsicMap[String("pack" #type)] = ALL_GLSL(Pack ## type); \ fIntrinsicMap[String("unpack" #type)] = ALL_GLSL(Unpack ## type) PACK(Snorm4x8); PACK(Unorm4x8); PACK(Snorm2x16); PACK(Unorm2x16); PACK(Half2x16); PACK(Double2x32); fIntrinsicMap[String("length")] = ALL_GLSL(Length); fIntrinsicMap[String("distance")] = ALL_GLSL(Distance); fIntrinsicMap[String("cross")] = ALL_GLSL(Cross); fIntrinsicMap[String("normalize")] = ALL_GLSL(Normalize); fIntrinsicMap[String("faceForward")] = ALL_GLSL(FaceForward); fIntrinsicMap[String("reflect")] = ALL_GLSL(Reflect); fIntrinsicMap[String("refract")] = ALL_GLSL(Refract); fIntrinsicMap[String("findLSB")] = ALL_GLSL(FindILsb); fIntrinsicMap[String("findMSB")] = BY_TYPE_GLSL(FindSMsb, FindSMsb, FindUMsb); fIntrinsicMap[String("dFdx")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDPdx, SpvOpUndef, SpvOpUndef, SpvOpUndef); fIntrinsicMap[String("dFdy")] = SPECIAL(DFdy); fIntrinsicMap[String("fwidth")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFwidth, SpvOpUndef, SpvOpUndef, SpvOpUndef); fIntrinsicMap[String("texture")] = SPECIAL(Texture); fIntrinsicMap[String("subpassLoad")] = SPECIAL(SubpassLoad); fIntrinsicMap[String("any")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpUndef, SpvOpUndef, SpvOpUndef, SpvOpAny); fIntrinsicMap[String("all")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpUndef, SpvOpUndef, SpvOpUndef, SpvOpAll); fIntrinsicMap[String("equal")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFOrdEqual, SpvOpIEqual, SpvOpIEqual, SpvOpLogicalEqual); fIntrinsicMap[String("notEqual")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFOrdNotEqual, SpvOpINotEqual, SpvOpINotEqual, SpvOpLogicalNotEqual); fIntrinsicMap[String("lessThan")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFOrdLessThan, SpvOpSLessThan, SpvOpULessThan, SpvOpUndef); fIntrinsicMap[String("lessThanEqual")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFOrdLessThanEqual, SpvOpSLessThanEqual, SpvOpULessThanEqual, SpvOpUndef); fIntrinsicMap[String("greaterThan")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFOrdGreaterThan, SpvOpSGreaterThan, SpvOpUGreaterThan, SpvOpUndef); fIntrinsicMap[String("greaterThanEqual")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFOrdGreaterThanEqual, SpvOpSGreaterThanEqual, SpvOpUGreaterThanEqual, SpvOpUndef); fIntrinsicMap[String("EmitVertex")] = ALL_SPIRV(EmitVertex); fIntrinsicMap[String("EndPrimitive")] = ALL_SPIRV(EndPrimitive); // interpolateAt* not yet supported... } void SPIRVCodeGenerator::writeWord(int32_t word, OutputStream& out) { out.write((const char*) &word, sizeof(word)); } static bool is_float(const Context& context, const Type& type) { if (type.columns() > 1) { return is_float(context, type.componentType()); } return type == *context.fFloat_Type || type == *context.fHalf_Type || type == *context.fDouble_Type; } static bool is_signed(const Context& context, const Type& type) { if (type.kind() == Type::kVector_Kind) { return is_signed(context, type.componentType()); } return type == *context.fInt_Type || type == *context.fShort_Type || type == *context.fByte_Type; } static bool is_unsigned(const Context& context, const Type& type) { if (type.kind() == Type::kVector_Kind) { return is_unsigned(context, type.componentType()); } return type == *context.fUInt_Type || type == *context.fUShort_Type || type == *context.fUByte_Type; } static bool is_bool(const Context& context, const Type& type) { if (type.kind() == Type::kVector_Kind) { return is_bool(context, type.componentType()); } return type == *context.fBool_Type; } static bool is_out(const Variable& var) { return (var.fModifiers.fFlags & Modifiers::kOut_Flag) != 0; } void SPIRVCodeGenerator::writeOpCode(SpvOp_ opCode, int length, OutputStream& out) { SkASSERT(opCode != SpvOpLoad || &out != &fConstantBuffer); SkASSERT(opCode != SpvOpUndef); switch (opCode) { case SpvOpReturn: // fall through case SpvOpReturnValue: // fall through case SpvOpKill: // fall through case SpvOpBranch: // fall through case SpvOpBranchConditional: SkASSERT(fCurrentBlock); fCurrentBlock = 0; break; case SpvOpConstant: // fall through case SpvOpConstantTrue: // fall through case SpvOpConstantFalse: // fall through case SpvOpConstantComposite: // fall through case SpvOpTypeVoid: // fall through case SpvOpTypeInt: // fall through case SpvOpTypeFloat: // fall through case SpvOpTypeBool: // fall through case SpvOpTypeVector: // fall through case SpvOpTypeMatrix: // fall through case SpvOpTypeArray: // fall through case SpvOpTypePointer: // fall through case SpvOpTypeFunction: // fall through case SpvOpTypeRuntimeArray: // fall through case SpvOpTypeStruct: // fall through case SpvOpTypeImage: // fall through case SpvOpTypeSampledImage: // fall through case SpvOpVariable: // fall through case SpvOpFunction: // fall through case SpvOpFunctionParameter: // fall through case SpvOpFunctionEnd: // fall through case SpvOpExecutionMode: // fall through case SpvOpMemoryModel: // fall through case SpvOpCapability: // fall through case SpvOpExtInstImport: // fall through case SpvOpEntryPoint: // fall through case SpvOpSource: // fall through case SpvOpSourceExtension: // fall through case SpvOpName: // fall through case SpvOpMemberName: // fall through case SpvOpDecorate: // fall through case SpvOpMemberDecorate: break; default: SkASSERT(fCurrentBlock); } this->writeWord((length << 16) | opCode, out); } void SPIRVCodeGenerator::writeLabel(SpvId label, OutputStream& out) { fCurrentBlock = label; this->writeInstruction(SpvOpLabel, label, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, OutputStream& out) { this->writeOpCode(opCode, 1, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, OutputStream& out) { this->writeOpCode(opCode, 2, out); this->writeWord(word1, out); } void SPIRVCodeGenerator::writeString(const char* string, size_t length, OutputStream& out) { out.write(string, length); switch (length % 4) { case 1: out.write8(0); // fall through case 2: out.write8(0); // fall through case 3: out.write8(0); break; default: this->writeWord(0, out); } } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, StringFragment string, OutputStream& out) { this->writeOpCode(opCode, 1 + (string.fLength + 4) / 4, out); this->writeString(string.fChars, string.fLength, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, StringFragment string, OutputStream& out) { this->writeOpCode(opCode, 2 + (string.fLength + 4) / 4, out); this->writeWord(word1, out); this->writeString(string.fChars, string.fLength, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, StringFragment string, OutputStream& out) { this->writeOpCode(opCode, 3 + (string.fLength + 4) / 4, out); this->writeWord(word1, out); this->writeWord(word2, out); this->writeString(string.fChars, string.fLength, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, OutputStream& out) { this->writeOpCode(opCode, 3, out); this->writeWord(word1, out); this->writeWord(word2, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, OutputStream& out) { this->writeOpCode(opCode, 4, out); this->writeWord(word1, out); this->writeWord(word2, out); this->writeWord(word3, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4, OutputStream& out) { this->writeOpCode(opCode, 5, out); this->writeWord(word1, out); this->writeWord(word2, out); this->writeWord(word3, out); this->writeWord(word4, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4, int32_t word5, OutputStream& out) { this->writeOpCode(opCode, 6, out); this->writeWord(word1, out); this->writeWord(word2, out); this->writeWord(word3, out); this->writeWord(word4, out); this->writeWord(word5, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4, int32_t word5, int32_t word6, OutputStream& out) { this->writeOpCode(opCode, 7, out); this->writeWord(word1, out); this->writeWord(word2, out); this->writeWord(word3, out); this->writeWord(word4, out); this->writeWord(word5, out); this->writeWord(word6, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4, int32_t word5, int32_t word6, int32_t word7, OutputStream& out) { this->writeOpCode(opCode, 8, out); this->writeWord(word1, out); this->writeWord(word2, out); this->writeWord(word3, out); this->writeWord(word4, out); this->writeWord(word5, out); this->writeWord(word6, out); this->writeWord(word7, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4, int32_t word5, int32_t word6, int32_t word7, int32_t word8, OutputStream& out) { this->writeOpCode(opCode, 9, out); this->writeWord(word1, out); this->writeWord(word2, out); this->writeWord(word3, out); this->writeWord(word4, out); this->writeWord(word5, out); this->writeWord(word6, out); this->writeWord(word7, out); this->writeWord(word8, out); } void SPIRVCodeGenerator::writeCapabilities(OutputStream& out) { for (uint64_t i = 0, bit = 1; i <= kLast_Capability; i++, bit <<= 1) { if (fCapabilities & bit) { this->writeInstruction(SpvOpCapability, (SpvId) i, out); } } if (fProgram.fKind == Program::kGeometry_Kind) { this->writeInstruction(SpvOpCapability, SpvCapabilityGeometry, out); } else { this->writeInstruction(SpvOpCapability, SpvCapabilityShader, out); } } SpvId SPIRVCodeGenerator::nextId() { return fIdCount++; } void SPIRVCodeGenerator::writeStruct(const Type& type, const MemoryLayout& memoryLayout, SpvId resultId) { this->writeInstruction(SpvOpName, resultId, type.name().c_str(), fNameBuffer); // go ahead and write all of the field types, so we don't inadvertently write them while we're // in the middle of writing the struct instruction std::vector types; for (const auto& f : type.fields()) { types.push_back(this->getType(*f.fType, memoryLayout)); } this->writeOpCode(SpvOpTypeStruct, 2 + (int32_t) types.size(), fConstantBuffer); this->writeWord(resultId, fConstantBuffer); for (SpvId id : types) { this->writeWord(id, fConstantBuffer); } size_t offset = 0; for (int32_t i = 0; i < (int32_t) type.fields().size(); i++) { const Type::Field& field = type.fields()[i]; size_t size = memoryLayout.size(*field.fType); size_t alignment = memoryLayout.alignment(*field.fType); const Layout& fieldLayout = field.fModifiers.fLayout; if (fieldLayout.fOffset >= 0) { if (fieldLayout.fOffset < (int) offset) { fErrors.error(type.fOffset, "offset of field '" + field.fName + "' must be at " "least " + to_string((int) offset)); } if (fieldLayout.fOffset % alignment) { fErrors.error(type.fOffset, "offset of field '" + field.fName + "' must be a multiple" " of " + to_string((int) alignment)); } offset = fieldLayout.fOffset; } else { size_t mod = offset % alignment; if (mod) { offset += alignment - mod; } } this->writeInstruction(SpvOpMemberName, resultId, i, field.fName, fNameBuffer); this->writeLayout(fieldLayout, resultId, i); if (field.fModifiers.fLayout.fBuiltin < 0) { this->writeInstruction(SpvOpMemberDecorate, resultId, (SpvId) i, SpvDecorationOffset, (SpvId) offset, fDecorationBuffer); } if (field.fType->kind() == Type::kMatrix_Kind) { this->writeInstruction(SpvOpMemberDecorate, resultId, i, SpvDecorationColMajor, fDecorationBuffer); this->writeInstruction(SpvOpMemberDecorate, resultId, i, SpvDecorationMatrixStride, (SpvId) memoryLayout.stride(*field.fType), fDecorationBuffer); } if (!field.fType->highPrecision()) { this->writeInstruction(SpvOpMemberDecorate, resultId, (SpvId) i, SpvDecorationRelaxedPrecision, fDecorationBuffer); } offset += size; Type::Kind kind = field.fType->kind(); if ((kind == Type::kArray_Kind || kind == Type::kStruct_Kind) && offset % alignment != 0) { offset += alignment - offset % alignment; } } } Type SPIRVCodeGenerator::getActualType(const Type& type) { if (type.isFloat()) { return *fContext.fFloat_Type; } if (type.isSigned()) { return *fContext.fInt_Type; } if (type.isUnsigned()) { return *fContext.fUInt_Type; } if (type.kind() == Type::kMatrix_Kind || type.kind() == Type::kVector_Kind) { if (type.componentType() == *fContext.fHalf_Type) { return fContext.fFloat_Type->toCompound(fContext, type.columns(), type.rows()); } if (type.componentType() == *fContext.fShort_Type || type.componentType() == *fContext.fByte_Type) { return fContext.fInt_Type->toCompound(fContext, type.columns(), type.rows()); } if (type.componentType() == *fContext.fUShort_Type || type.componentType() == *fContext.fUByte_Type) { return fContext.fUInt_Type->toCompound(fContext, type.columns(), type.rows()); } } return type; } SpvId SPIRVCodeGenerator::getType(const Type& type) { return this->getType(type, fDefaultLayout); } SpvId SPIRVCodeGenerator::getType(const Type& rawType, const MemoryLayout& layout) { Type type = this->getActualType(rawType); String key = type.name() + to_string((int) layout.fStd); auto entry = fTypeMap.find(key); if (entry == fTypeMap.end()) { SpvId result = this->nextId(); switch (type.kind()) { case Type::kScalar_Kind: if (type == *fContext.fBool_Type) { this->writeInstruction(SpvOpTypeBool, result, fConstantBuffer); } else if (type == *fContext.fInt_Type || type == *fContext.fShort_Type || type == *fContext.fIntLiteral_Type) { this->writeInstruction(SpvOpTypeInt, result, 32, 1, fConstantBuffer); } else if (type == *fContext.fUInt_Type || type == *fContext.fUShort_Type) { this->writeInstruction(SpvOpTypeInt, result, 32, 0, fConstantBuffer); } else if (type == *fContext.fFloat_Type || type == *fContext.fHalf_Type || type == *fContext.fFloatLiteral_Type) { this->writeInstruction(SpvOpTypeFloat, result, 32, fConstantBuffer); } else if (type == *fContext.fDouble_Type) { this->writeInstruction(SpvOpTypeFloat, result, 64, fConstantBuffer); } else { SkASSERT(false); } break; case Type::kVector_Kind: this->writeInstruction(SpvOpTypeVector, result, this->getType(type.componentType(), layout), type.columns(), fConstantBuffer); break; case Type::kMatrix_Kind: this->writeInstruction(SpvOpTypeMatrix, result, this->getType(index_type(fContext, type), layout), type.columns(), fConstantBuffer); break; case Type::kStruct_Kind: this->writeStruct(type, layout, result); break; case Type::kArray_Kind: { if (type.columns() > 0) { IntLiteral count(fContext, -1, type.columns()); this->writeInstruction(SpvOpTypeArray, result, this->getType(type.componentType(), layout), this->writeIntLiteral(count), fConstantBuffer); this->writeInstruction(SpvOpDecorate, result, SpvDecorationArrayStride, (int32_t) layout.stride(type), fDecorationBuffer); } else { SkASSERT(false); // we shouldn't have any runtime-sized arrays right now this->writeInstruction(SpvOpTypeRuntimeArray, result, this->getType(type.componentType(), layout), fConstantBuffer); this->writeInstruction(SpvOpDecorate, result, SpvDecorationArrayStride, (int32_t) layout.stride(type), fDecorationBuffer); } break; } case Type::kSampler_Kind: { SpvId image = result; if (SpvDimSubpassData != type.dimensions()) { image = this->nextId(); } if (SpvDimBuffer == type.dimensions()) { fCapabilities |= (((uint64_t) 1) << SpvCapabilitySampledBuffer); } this->writeInstruction(SpvOpTypeImage, image, this->getType(*fContext.fFloat_Type, layout), type.dimensions(), type.isDepth(), type.isArrayed(), type.isMultisampled(), type.isSampled() ? 1 : 2, SpvImageFormatUnknown, fConstantBuffer); fImageTypeMap[key] = image; if (SpvDimSubpassData != type.dimensions()) { this->writeInstruction(SpvOpTypeSampledImage, result, image, fConstantBuffer); } break; } default: if (type == *fContext.fVoid_Type) { this->writeInstruction(SpvOpTypeVoid, result, fConstantBuffer); } else { ABORT("invalid type: %s", type.description().c_str()); } } fTypeMap[key] = result; return result; } return entry->second; } SpvId SPIRVCodeGenerator::getImageType(const Type& type) { SkASSERT(type.kind() == Type::kSampler_Kind); this->getType(type); String key = type.name() + to_string((int) fDefaultLayout.fStd); SkASSERT(fImageTypeMap.find(key) != fImageTypeMap.end()); return fImageTypeMap[key]; } SpvId SPIRVCodeGenerator::getFunctionType(const FunctionDeclaration& function) { String key = function.fReturnType.description() + "("; String separator; for (size_t i = 0; i < function.fParameters.size(); i++) { key += separator; separator = ", "; key += function.fParameters[i]->fType.description(); } key += ")"; auto entry = fTypeMap.find(key); if (entry == fTypeMap.end()) { SpvId result = this->nextId(); int32_t length = 3 + (int32_t) function.fParameters.size(); SpvId returnType = this->getType(function.fReturnType); std::vector parameterTypes; for (size_t i = 0; i < function.fParameters.size(); i++) { // glslang seems to treat all function arguments as pointers whether they need to be or // not. I was initially puzzled by this until I ran bizarre failures with certain // patterns of function calls and control constructs, as exemplified by this minimal // failure case: // // void sphere(float x) { // } // // void map() { // sphere(1.0); // } // // void main() { // for (int i = 0; i < 1; i++) { // map(); // } // } // // As of this writing, compiling this in the "obvious" way (with sphere taking a float) // crashes. Making it take a float* and storing the argument in a temporary variable, // as glslang does, fixes it. It's entirely possible I simply missed whichever part of // the spec makes this make sense. // if (is_out(function->fParameters[i])) { parameterTypes.push_back(this->getPointerType(function.fParameters[i]->fType, SpvStorageClassFunction)); // } else { // parameterTypes.push_back(this->getType(function.fParameters[i]->fType)); // } } this->writeOpCode(SpvOpTypeFunction, length, fConstantBuffer); this->writeWord(result, fConstantBuffer); this->writeWord(returnType, fConstantBuffer); for (SpvId id : parameterTypes) { this->writeWord(id, fConstantBuffer); } fTypeMap[key] = result; return result; } return entry->second; } SpvId SPIRVCodeGenerator::getPointerType(const Type& type, SpvStorageClass_ storageClass) { return this->getPointerType(type, fDefaultLayout, storageClass); } SpvId SPIRVCodeGenerator::getPointerType(const Type& rawType, const MemoryLayout& layout, SpvStorageClass_ storageClass) { Type type = this->getActualType(rawType); String key = type.description() + "*" + to_string(layout.fStd) + to_string(storageClass); auto entry = fTypeMap.find(key); if (entry == fTypeMap.end()) { SpvId result = this->nextId(); this->writeInstruction(SpvOpTypePointer, result, storageClass, this->getType(type), fConstantBuffer); fTypeMap[key] = result; return result; } return entry->second; } SpvId SPIRVCodeGenerator::writeExpression(const Expression& expr, OutputStream& out) { switch (expr.fKind) { case Expression::kBinary_Kind: return this->writeBinaryExpression((BinaryExpression&) expr, out); case Expression::kBoolLiteral_Kind: return this->writeBoolLiteral((BoolLiteral&) expr); case Expression::kConstructor_Kind: return this->writeConstructor((Constructor&) expr, out); case Expression::kIntLiteral_Kind: return this->writeIntLiteral((IntLiteral&) expr); case Expression::kFieldAccess_Kind: return this->writeFieldAccess(((FieldAccess&) expr), out); case Expression::kFloatLiteral_Kind: return this->writeFloatLiteral(((FloatLiteral&) expr)); case Expression::kFunctionCall_Kind: return this->writeFunctionCall((FunctionCall&) expr, out); case Expression::kPrefix_Kind: return this->writePrefixExpression((PrefixExpression&) expr, out); case Expression::kPostfix_Kind: return this->writePostfixExpression((PostfixExpression&) expr, out); case Expression::kSwizzle_Kind: return this->writeSwizzle((Swizzle&) expr, out); case Expression::kVariableReference_Kind: return this->writeVariableReference((VariableReference&) expr, out); case Expression::kTernary_Kind: return this->writeTernaryExpression((TernaryExpression&) expr, out); case Expression::kIndex_Kind: return this->writeIndexExpression((IndexExpression&) expr, out); default: ABORT("unsupported expression: %s", expr.description().c_str()); } return -1; } SpvId SPIRVCodeGenerator::writeIntrinsicCall(const FunctionCall& c, OutputStream& out) { auto intrinsic = fIntrinsicMap.find(c.fFunction.fName); SkASSERT(intrinsic != fIntrinsicMap.end()); int32_t intrinsicId; if (c.fArguments.size() > 0) { const Type& type = c.fArguments[0]->fType; if (std::get<0>(intrinsic->second) == kSpecial_IntrinsicKind || is_float(fContext, type)) { intrinsicId = std::get<1>(intrinsic->second); } else if (is_signed(fContext, type)) { intrinsicId = std::get<2>(intrinsic->second); } else if (is_unsigned(fContext, type)) { intrinsicId = std::get<3>(intrinsic->second); } else if (is_bool(fContext, type)) { intrinsicId = std::get<4>(intrinsic->second); } else { intrinsicId = std::get<1>(intrinsic->second); } } else { intrinsicId = std::get<1>(intrinsic->second); } switch (std::get<0>(intrinsic->second)) { case kGLSL_STD_450_IntrinsicKind: { SpvId result = this->nextId(); std::vector arguments; for (size_t i = 0; i < c.fArguments.size(); i++) { if (c.fFunction.fParameters[i]->fModifiers.fFlags & Modifiers::kOut_Flag) { arguments.push_back(this->getLValue(*c.fArguments[i], out)->getPointer()); } else { arguments.push_back(this->writeExpression(*c.fArguments[i], out)); } } this->writeOpCode(SpvOpExtInst, 5 + (int32_t) arguments.size(), out); this->writeWord(this->getType(c.fType), out); this->writeWord(result, out); this->writeWord(fGLSLExtendedInstructions, out); this->writeWord(intrinsicId, out); for (SpvId id : arguments) { this->writeWord(id, out); } return result; } case kSPIRV_IntrinsicKind: { SpvId result = this->nextId(); std::vector arguments; for (size_t i = 0; i < c.fArguments.size(); i++) { if (c.fFunction.fParameters[i]->fModifiers.fFlags & Modifiers::kOut_Flag) { arguments.push_back(this->getLValue(*c.fArguments[i], out)->getPointer()); } else { arguments.push_back(this->writeExpression(*c.fArguments[i], out)); } } if (c.fType != *fContext.fVoid_Type) { this->writeOpCode((SpvOp_) intrinsicId, 3 + (int32_t) arguments.size(), out); this->writeWord(this->getType(c.fType), out); this->writeWord(result, out); } else { this->writeOpCode((SpvOp_) intrinsicId, 1 + (int32_t) arguments.size(), out); } for (SpvId id : arguments) { this->writeWord(id, out); } return result; } case kSpecial_IntrinsicKind: return this->writeSpecialIntrinsic(c, (SpecialIntrinsic) intrinsicId, out); default: ABORT("unsupported intrinsic kind"); } } std::vector SPIRVCodeGenerator::vectorize( const std::vector>& args, OutputStream& out) { int vectorSize = 0; for (const auto& a : args) { if (a->fType.kind() == Type::kVector_Kind) { if (vectorSize) { SkASSERT(a->fType.columns() == vectorSize); } else { vectorSize = a->fType.columns(); } } } std::vector result; for (const auto& a : args) { SpvId raw = this->writeExpression(*a, out); if (vectorSize && a->fType.kind() == Type::kScalar_Kind) { SpvId vector = this->nextId(); this->writeOpCode(SpvOpCompositeConstruct, 3 + vectorSize, out); this->writeWord(this->getType(a->fType.toCompound(fContext, vectorSize, 1)), out); this->writeWord(vector, out); for (int i = 0; i < vectorSize; i++) { this->writeWord(raw, out); } this->writePrecisionModifier(a->fType, vector); result.push_back(vector); } else { result.push_back(raw); } } return result; } void SPIRVCodeGenerator::writeGLSLExtendedInstruction(const Type& type, SpvId id, SpvId floatInst, SpvId signedInst, SpvId unsignedInst, const std::vector& args, OutputStream& out) { this->writeOpCode(SpvOpExtInst, 5 + args.size(), out); this->writeWord(this->getType(type), out); this->writeWord(id, out); this->writeWord(fGLSLExtendedInstructions, out); if (is_float(fContext, type)) { this->writeWord(floatInst, out); } else if (is_signed(fContext, type)) { this->writeWord(signedInst, out); } else if (is_unsigned(fContext, type)) { this->writeWord(unsignedInst, out); } else { SkASSERT(false); } for (SpvId a : args) { this->writeWord(a, out); } } SpvId SPIRVCodeGenerator::writeSpecialIntrinsic(const FunctionCall& c, SpecialIntrinsic kind, OutputStream& out) { SpvId result = this->nextId(); switch (kind) { case kAtan_SpecialIntrinsic: { std::vector arguments; for (size_t i = 0; i < c.fArguments.size(); i++) { arguments.push_back(this->writeExpression(*c.fArguments[i], out)); } this->writeOpCode(SpvOpExtInst, 5 + (int32_t) arguments.size(), out); this->writeWord(this->getType(c.fType), out); this->writeWord(result, out); this->writeWord(fGLSLExtendedInstructions, out); this->writeWord(arguments.size() == 2 ? GLSLstd450Atan2 : GLSLstd450Atan, out); for (SpvId id : arguments) { this->writeWord(id, out); } break; } case kSubpassLoad_SpecialIntrinsic: { SpvId img = this->writeExpression(*c.fArguments[0], out); std::vector> args; args.emplace_back(new FloatLiteral(fContext, -1, 0.0)); args.emplace_back(new FloatLiteral(fContext, -1, 0.0)); Constructor ctor(-1, *fContext.fFloat2_Type, std::move(args)); SpvId coords = this->writeConstantVector(ctor); if (1 == c.fArguments.size()) { this->writeInstruction(SpvOpImageRead, this->getType(c.fType), result, img, coords, out); } else { SkASSERT(2 == c.fArguments.size()); SpvId sample = this->writeExpression(*c.fArguments[1], out); this->writeInstruction(SpvOpImageRead, this->getType(c.fType), result, img, coords, SpvImageOperandsSampleMask, sample, out); } break; } case kTexture_SpecialIntrinsic: { SpvOp_ op = SpvOpImageSampleImplicitLod; switch (c.fArguments[0]->fType.dimensions()) { case SpvDim1D: if (c.fArguments[1]->fType == *fContext.fFloat2_Type) { op = SpvOpImageSampleProjImplicitLod; } else { SkASSERT(c.fArguments[1]->fType == *fContext.fFloat_Type); } break; case SpvDim2D: if (c.fArguments[1]->fType == *fContext.fFloat3_Type) { op = SpvOpImageSampleProjImplicitLod; } else { SkASSERT(c.fArguments[1]->fType == *fContext.fFloat2_Type); } break; case SpvDim3D: if (c.fArguments[1]->fType == *fContext.fFloat4_Type) { op = SpvOpImageSampleProjImplicitLod; } else { SkASSERT(c.fArguments[1]->fType == *fContext.fFloat3_Type); } break; case SpvDimCube: // fall through case SpvDimRect: // fall through case SpvDimBuffer: // fall through case SpvDimSubpassData: break; } SpvId type = this->getType(c.fType); SpvId sampler = this->writeExpression(*c.fArguments[0], out); SpvId uv = this->writeExpression(*c.fArguments[1], out); if (c.fArguments.size() == 3) { this->writeInstruction(op, type, result, sampler, uv, SpvImageOperandsBiasMask, this->writeExpression(*c.fArguments[2], out), out); } else { SkASSERT(c.fArguments.size() == 2); if (fProgram.fSettings.fSharpenTextures) { FloatLiteral lodBias(fContext, -1, -0.5); this->writeInstruction(op, type, result, sampler, uv, SpvImageOperandsBiasMask, this->writeFloatLiteral(lodBias), out); } else { this->writeInstruction(op, type, result, sampler, uv, out); } } break; } case kMod_SpecialIntrinsic: { std::vector args = this->vectorize(c.fArguments, out); SkASSERT(args.size() == 2); const Type& operandType = c.fArguments[0]->fType; SpvOp_ op; if (is_float(fContext, operandType)) { op = SpvOpFMod; } else if (is_signed(fContext, operandType)) { op = SpvOpSMod; } else if (is_unsigned(fContext, operandType)) { op = SpvOpUMod; } else { SkASSERT(false); return 0; } this->writeOpCode(op, 5, out); this->writeWord(this->getType(operandType), out); this->writeWord(result, out); this->writeWord(args[0], out); this->writeWord(args[1], out); break; } case kDFdy_SpecialIntrinsic: { SpvId fn = this->writeExpression(*c.fArguments[0], out); this->writeOpCode(SpvOpDPdy, 4, out); this->writeWord(this->getType(c.fType), out); this->writeWord(result, out); this->writeWord(fn, out); if (fProgram.fSettings.fFlipY) { // Flipping Y also negates the Y derivatives. SpvId flipped = this->nextId(); this->writeInstruction(SpvOpFNegate, this->getType(c.fType), flipped, result, out); this->writePrecisionModifier(c.fType, flipped); return flipped; } break; } case kClamp_SpecialIntrinsic: { std::vector args = this->vectorize(c.fArguments, out); SkASSERT(args.size() == 3); this->writeGLSLExtendedInstruction(c.fType, result, GLSLstd450FClamp, GLSLstd450SClamp, GLSLstd450UClamp, args, out); break; } case kMax_SpecialIntrinsic: { std::vector args = this->vectorize(c.fArguments, out); SkASSERT(args.size() == 2); this->writeGLSLExtendedInstruction(c.fType, result, GLSLstd450FMax, GLSLstd450SMax, GLSLstd450UMax, args, out); break; } case kMin_SpecialIntrinsic: { std::vector args = this->vectorize(c.fArguments, out); SkASSERT(args.size() == 2); this->writeGLSLExtendedInstruction(c.fType, result, GLSLstd450FMin, GLSLstd450SMin, GLSLstd450UMin, args, out); break; } case kMix_SpecialIntrinsic: { std::vector args = this->vectorize(c.fArguments, out); SkASSERT(args.size() == 3); this->writeGLSLExtendedInstruction(c.fType, result, GLSLstd450FMix, SpvOpUndef, SpvOpUndef, args, out); break; } case kSaturate_SpecialIntrinsic: { SkASSERT(c.fArguments.size() == 1); std::vector> finalArgs; finalArgs.push_back(c.fArguments[0]->clone()); finalArgs.emplace_back(new FloatLiteral(fContext, -1, 0)); finalArgs.emplace_back(new FloatLiteral(fContext, -1, 1)); std::vector spvArgs = this->vectorize(finalArgs, out); this->writeGLSLExtendedInstruction(c.fType, result, GLSLstd450FClamp, GLSLstd450SClamp, GLSLstd450UClamp, spvArgs, out); break; } } return result; } SpvId SPIRVCodeGenerator::writeFunctionCall(const FunctionCall& c, OutputStream& out) { const auto& entry = fFunctionMap.find(&c.fFunction); if (entry == fFunctionMap.end()) { return this->writeIntrinsicCall(c, out); } // stores (variable, type, lvalue) pairs to extract and save after the function call is complete std::vector>> lvalues; std::vector arguments; for (size_t i = 0; i < c.fArguments.size(); i++) { // id of temporary variable that we will use to hold this argument, or 0 if it is being // passed directly SpvId tmpVar; // if we need a temporary var to store this argument, this is the value to store in the var SpvId tmpValueId; if (is_out(*c.fFunction.fParameters[i])) { std::unique_ptr lv = this->getLValue(*c.fArguments[i], out); SpvId ptr = lv->getPointer(); if (ptr) { arguments.push_back(ptr); continue; } else { // lvalue cannot simply be read and written via a pointer (e.g. a swizzle). Need to // copy it into a temp, call the function, read the value out of the temp, and then // update the lvalue. tmpValueId = lv->load(out); tmpVar = this->nextId(); lvalues.push_back(std::make_tuple(tmpVar, &c.fArguments[i]->fType, std::move(lv))); } } else { // see getFunctionType for an explanation of why we're always using pointer parameters tmpValueId = this->writeExpression(*c.fArguments[i], out); tmpVar = this->nextId(); } this->writeInstruction(SpvOpVariable, this->getPointerType(c.fArguments[i]->fType, SpvStorageClassFunction), tmpVar, SpvStorageClassFunction, fVariableBuffer); this->writeInstruction(SpvOpStore, tmpVar, tmpValueId, out); arguments.push_back(tmpVar); } SpvId result = this->nextId(); this->writeOpCode(SpvOpFunctionCall, 4 + (int32_t) c.fArguments.size(), out); this->writeWord(this->getType(c.fType), out); this->writeWord(result, out); this->writeWord(entry->second, out); for (SpvId id : arguments) { this->writeWord(id, out); } // now that the call is complete, we may need to update some lvalues with the new values of out // arguments for (const auto& tuple : lvalues) { SpvId load = this->nextId(); this->writeInstruction(SpvOpLoad, getType(*std::get<1>(tuple)), load, std::get<0>(tuple), out); this->writePrecisionModifier(*std::get<1>(tuple), load); std::get<2>(tuple)->store(load, out); } return result; } SpvId SPIRVCodeGenerator::writeConstantVector(const Constructor& c) { SkASSERT(c.fType.kind() == Type::kVector_Kind && c.isConstant()); SpvId result = this->nextId(); std::vector arguments; for (size_t i = 0; i < c.fArguments.size(); i++) { arguments.push_back(this->writeExpression(*c.fArguments[i], fConstantBuffer)); } SpvId type = this->getType(c.fType); if (c.fArguments.size() == 1) { // with a single argument, a vector will have all of its entries equal to the argument this->writeOpCode(SpvOpConstantComposite, 3 + c.fType.columns(), fConstantBuffer); this->writeWord(type, fConstantBuffer); this->writeWord(result, fConstantBuffer); for (int i = 0; i < c.fType.columns(); i++) { this->writeWord(arguments[0], fConstantBuffer); } } else { this->writeOpCode(SpvOpConstantComposite, 3 + (int32_t) c.fArguments.size(), fConstantBuffer); this->writeWord(type, fConstantBuffer); this->writeWord(result, fConstantBuffer); for (SpvId id : arguments) { this->writeWord(id, fConstantBuffer); } } return result; } SpvId SPIRVCodeGenerator::writeFloatConstructor(const Constructor& c, OutputStream& out) { SkASSERT(c.fType.isFloat()); SkASSERT(c.fArguments.size() == 1); SkASSERT(c.fArguments[0]->fType.isNumber()); SpvId result = this->nextId(); SpvId parameter = this->writeExpression(*c.fArguments[0], out); if (c.fArguments[0]->fType.isSigned()) { this->writeInstruction(SpvOpConvertSToF, this->getType(c.fType), result, parameter, out); } else { SkASSERT(c.fArguments[0]->fType.isUnsigned()); this->writeInstruction(SpvOpConvertUToF, this->getType(c.fType), result, parameter, out); } return result; } SpvId SPIRVCodeGenerator::writeIntConstructor(const Constructor& c, OutputStream& out) { SkASSERT(c.fType.isSigned()); SkASSERT(c.fArguments.size() == 1); SkASSERT(c.fArguments[0]->fType.isNumber()); SpvId result = this->nextId(); SpvId parameter = this->writeExpression(*c.fArguments[0], out); if (c.fArguments[0]->fType.isFloat()) { this->writeInstruction(SpvOpConvertFToS, this->getType(c.fType), result, parameter, out); } else { SkASSERT(c.fArguments[0]->fType.isUnsigned()); this->writeInstruction(SpvOpBitcast, this->getType(c.fType), result, parameter, out); } return result; } SpvId SPIRVCodeGenerator::writeUIntConstructor(const Constructor& c, OutputStream& out) { SkASSERT(c.fType.isUnsigned()); SkASSERT(c.fArguments.size() == 1); SkASSERT(c.fArguments[0]->fType.isNumber()); SpvId result = this->nextId(); SpvId parameter = this->writeExpression(*c.fArguments[0], out); if (c.fArguments[0]->fType.isFloat()) { this->writeInstruction(SpvOpConvertFToU, this->getType(c.fType), result, parameter, out); } else { SkASSERT(c.fArguments[0]->fType.isSigned()); this->writeInstruction(SpvOpBitcast, this->getType(c.fType), result, parameter, out); } return result; } void SPIRVCodeGenerator::writeUniformScaleMatrix(SpvId id, SpvId diagonal, const Type& type, OutputStream& out) { FloatLiteral zero(fContext, -1, 0); SpvId zeroId = this->writeFloatLiteral(zero); std::vector columnIds; for (int column = 0; column < type.columns(); column++) { this->writeOpCode(SpvOpCompositeConstruct, 3 + type.rows(), out); this->writeWord(this->getType(type.componentType().toCompound(fContext, type.rows(), 1)), out); SpvId columnId = this->nextId(); this->writeWord(columnId, out); columnIds.push_back(columnId); for (int row = 0; row < type.columns(); row++) { this->writeWord(row == column ? diagonal : zeroId, out); } this->writePrecisionModifier(type, columnId); } this->writeOpCode(SpvOpCompositeConstruct, 3 + type.columns(), out); this->writeWord(this->getType(type), out); this->writeWord(id, out); for (SpvId id : columnIds) { this->writeWord(id, out); } this->writePrecisionModifier(type, id); } void SPIRVCodeGenerator::writeMatrixCopy(SpvId id, SpvId src, const Type& srcType, const Type& dstType, OutputStream& out) { SkASSERT(srcType.kind() == Type::kMatrix_Kind); SkASSERT(dstType.kind() == Type::kMatrix_Kind); SkASSERT(srcType.componentType() == dstType.componentType()); SpvId srcColumnType = this->getType(srcType.componentType().toCompound(fContext, srcType.rows(), 1)); SpvId dstColumnType = this->getType(dstType.componentType().toCompound(fContext, dstType.rows(), 1)); SpvId zeroId; if (dstType.componentType() == *fContext.fFloat_Type) { FloatLiteral zero(fContext, -1, 0.0); zeroId = this->writeFloatLiteral(zero); } else if (dstType.componentType() == *fContext.fInt_Type) { IntLiteral zero(fContext, -1, 0); zeroId = this->writeIntLiteral(zero); } else { ABORT("unsupported matrix component type"); } SpvId zeroColumn = 0; SpvId columns[4]; for (int i = 0; i < dstType.columns(); i++) { if (i < srcType.columns()) { // we're still inside the src matrix, copy the column SpvId srcColumn = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, srcColumnType, srcColumn, src, i, out); this->writePrecisionModifier(dstType, srcColumn); SpvId dstColumn; if (srcType.rows() == dstType.rows()) { // columns are equal size, don't need to do anything dstColumn = srcColumn; } else if (dstType.rows() > srcType.rows()) { // dst column is bigger, need to zero-pad it dstColumn = this->nextId(); int delta = dstType.rows() - srcType.rows(); this->writeOpCode(SpvOpCompositeConstruct, 4 + delta, out); this->writeWord(dstColumnType, out); this->writeWord(dstColumn, out); this->writeWord(srcColumn, out); for (int i = 0; i < delta; ++i) { this->writeWord(zeroId, out); } this->writePrecisionModifier(dstType, dstColumn); } else { // dst column is smaller, need to swizzle the src column dstColumn = this->nextId(); int count = dstType.rows(); this->writeOpCode(SpvOpVectorShuffle, 5 + count, out); this->writeWord(dstColumnType, out); this->writeWord(dstColumn, out); this->writeWord(srcColumn, out); this->writeWord(srcColumn, out); for (int i = 0; i < count; i++) { this->writeWord(i, out); } this->writePrecisionModifier(dstType, dstColumn); } columns[i] = dstColumn; } else { // we're past the end of the src matrix, need a vector of zeroes if (!zeroColumn) { zeroColumn = this->nextId(); this->writeOpCode(SpvOpCompositeConstruct, 3 + dstType.rows(), out); this->writeWord(dstColumnType, out); this->writeWord(zeroColumn, out); for (int i = 0; i < dstType.rows(); ++i) { this->writeWord(zeroId, out); } this->writePrecisionModifier(dstType, zeroColumn); } columns[i] = zeroColumn; } } this->writeOpCode(SpvOpCompositeConstruct, 3 + dstType.columns(), out); this->writeWord(this->getType(dstType), out); this->writeWord(id, out); for (int i = 0; i < dstType.columns(); i++) { this->writeWord(columns[i], out); } this->writePrecisionModifier(dstType, id); } void SPIRVCodeGenerator::addColumnEntry(SpvId columnType, Precision precision, std::vector* currentColumn, std::vector* columnIds, int* currentCount, int rows, SpvId entry, OutputStream& out) { SkASSERT(*currentCount < rows); ++(*currentCount); currentColumn->push_back(entry); if (*currentCount == rows) { *currentCount = 0; this->writeOpCode(SpvOpCompositeConstruct, 3 + currentColumn->size(), out); this->writeWord(columnType, out); SpvId columnId = this->nextId(); this->writeWord(columnId, out); columnIds->push_back(columnId); for (SpvId id : *currentColumn) { this->writeWord(id, out); } currentColumn->clear(); this->writePrecisionModifier(precision, columnId); } } SpvId SPIRVCodeGenerator::writeMatrixConstructor(const Constructor& c, OutputStream& out) { SkASSERT(c.fType.kind() == Type::kMatrix_Kind); // go ahead and write the arguments so we don't try to write new instructions in the middle of // an instruction std::vector arguments; for (size_t i = 0; i < c.fArguments.size(); i++) { arguments.push_back(this->writeExpression(*c.fArguments[i], out)); } SpvId result = this->nextId(); int rows = c.fType.rows(); int columns = c.fType.columns(); if (arguments.size() == 1 && c.fArguments[0]->fType.kind() == Type::kScalar_Kind) { this->writeUniformScaleMatrix(result, arguments[0], c.fType, out); } else if (arguments.size() == 1 && c.fArguments[0]->fType.kind() == Type::kMatrix_Kind) { this->writeMatrixCopy(result, arguments[0], c.fArguments[0]->fType, c.fType, out); } else if (arguments.size() == 1 && c.fArguments[0]->fType.kind() == Type::kVector_Kind) { SkASSERT(c.fType.rows() == 2 && c.fType.columns() == 2); SkASSERT(c.fArguments[0]->fType.columns() == 4); SpvId componentType = this->getType(c.fType.componentType()); SpvId v[4]; for (int i = 0; i < 4; ++i) { v[i] = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, componentType, v[i], arguments[0], i, out); } SpvId columnType = this->getType(c.fType.componentType().toCompound(fContext, 2, 1)); SpvId column1 = this->nextId(); this->writeInstruction(SpvOpCompositeConstruct, columnType, column1, v[0], v[1], out); SpvId column2 = this->nextId(); this->writeInstruction(SpvOpCompositeConstruct, columnType, column2, v[2], v[3], out); this->writeInstruction(SpvOpCompositeConstruct, this->getType(c.fType), result, column1, column2, out); } else { SpvId columnType = this->getType(c.fType.componentType().toCompound(fContext, rows, 1)); std::vector columnIds; // ids of vectors and scalars we have written to the current column so far std::vector currentColumn; // the total number of scalars represented by currentColumn's entries int currentCount = 0; Precision precision = c.fType.highPrecision() ? Precision::kHigh : Precision::kLow; for (size_t i = 0; i < arguments.size(); i++) { if (currentCount == 0 && c.fArguments[i]->fType.kind() == Type::kVector_Kind && c.fArguments[i]->fType.columns() == c.fType.rows()) { // this is a complete column by itself columnIds.push_back(arguments[i]); } else { if (c.fArguments[i]->fType.columns() == 1) { this->addColumnEntry(columnType, precision, ¤tColumn, &columnIds, ¤tCount, rows, arguments[i], out); } else { SpvId componentType = this->getType(c.fArguments[i]->fType.componentType()); for (int j = 0; j < c.fArguments[i]->fType.columns(); ++j) { SpvId swizzle = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, componentType, swizzle, arguments[i], j, out); this->addColumnEntry(columnType, precision, ¤tColumn, &columnIds, ¤tCount, rows, swizzle, out); } } } } SkASSERT(columnIds.size() == (size_t) columns); this->writeOpCode(SpvOpCompositeConstruct, 3 + columns, out); this->writeWord(this->getType(c.fType), out); this->writeWord(result, out); for (SpvId id : columnIds) { this->writeWord(id, out); } } this->writePrecisionModifier(c.fType, result); return result; } SpvId SPIRVCodeGenerator::writeVectorConstructor(const Constructor& c, OutputStream& out) { SkASSERT(c.fType.kind() == Type::kVector_Kind); if (c.isConstant()) { return this->writeConstantVector(c); } // go ahead and write the arguments so we don't try to write new instructions in the middle of // an instruction std::vector arguments; for (size_t i = 0; i < c.fArguments.size(); i++) { if (c.fArguments[i]->fType.kind() == Type::kVector_Kind) { // SPIR-V doesn't support vector(vector-of-different-type) directly, so we need to // extract the components and convert them in that case manually. On top of that, // as of this writing there's a bug in the Intel Vulkan driver where OpCreateComposite // doesn't handle vector arguments at all, so we always extract vector components and // pass them into OpCreateComposite individually. SpvId vec = this->writeExpression(*c.fArguments[i], out); SpvOp_ op = SpvOpUndef; const Type& src = c.fArguments[i]->fType.componentType(); const Type& dst = c.fType.componentType(); if (dst == *fContext.fFloat_Type || dst == *fContext.fHalf_Type) { if (src == *fContext.fFloat_Type || src == *fContext.fHalf_Type) { if (c.fArguments.size() == 1) { return vec; } } else if (src == *fContext.fInt_Type || src == *fContext.fShort_Type || src == *fContext.fByte_Type) { op = SpvOpConvertSToF; } else if (src == *fContext.fUInt_Type || src == *fContext.fUShort_Type || src == *fContext.fUByte_Type) { op = SpvOpConvertUToF; } else { SkASSERT(false); } } else if (dst == *fContext.fInt_Type || dst == *fContext.fShort_Type || dst == *fContext.fByte_Type) { if (src == *fContext.fFloat_Type || src == *fContext.fHalf_Type) { op = SpvOpConvertFToS; } else if (src == *fContext.fInt_Type || src == *fContext.fShort_Type || src == *fContext.fByte_Type) { if (c.fArguments.size() == 1) { return vec; } } else if (src == *fContext.fUInt_Type || src == *fContext.fUShort_Type || src == *fContext.fUByte_Type) { op = SpvOpBitcast; } else { SkASSERT(false); } } else if (dst == *fContext.fUInt_Type || dst == *fContext.fUShort_Type || dst == *fContext.fUByte_Type) { if (src == *fContext.fFloat_Type || src == *fContext.fHalf_Type) { op = SpvOpConvertFToS; } else if (src == *fContext.fInt_Type || src == *fContext.fShort_Type || src == *fContext.fByte_Type) { op = SpvOpBitcast; } else if (src == *fContext.fUInt_Type || src == *fContext.fUShort_Type || src == *fContext.fUByte_Type) { if (c.fArguments.size() == 1) { return vec; } } else { SkASSERT(false); } } for (int j = 0; j < c.fArguments[i]->fType.columns(); j++) { SpvId swizzle = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, this->getType(src), swizzle, vec, j, out); if (op != SpvOpUndef) { SpvId cast = this->nextId(); this->writeInstruction(op, this->getType(dst), cast, swizzle, out); arguments.push_back(cast); } else { arguments.push_back(swizzle); } } } else { arguments.push_back(this->writeExpression(*c.fArguments[i], out)); } } SpvId result = this->nextId(); if (arguments.size() == 1 && c.fArguments[0]->fType.kind() == Type::kScalar_Kind) { this->writeOpCode(SpvOpCompositeConstruct, 3 + c.fType.columns(), out); this->writeWord(this->getType(c.fType), out); this->writeWord(result, out); for (int i = 0; i < c.fType.columns(); i++) { this->writeWord(arguments[0], out); } } else { SkASSERT(arguments.size() > 1); this->writeOpCode(SpvOpCompositeConstruct, 3 + (int32_t) arguments.size(), out); this->writeWord(this->getType(c.fType), out); this->writeWord(result, out); for (SpvId id : arguments) { this->writeWord(id, out); } } return result; } SpvId SPIRVCodeGenerator::writeArrayConstructor(const Constructor& c, OutputStream& out) { SkASSERT(c.fType.kind() == Type::kArray_Kind); // go ahead and write the arguments so we don't try to write new instructions in the middle of // an instruction std::vector arguments; for (size_t i = 0; i < c.fArguments.size(); i++) { arguments.push_back(this->writeExpression(*c.fArguments[i], out)); } SpvId result = this->nextId(); this->writeOpCode(SpvOpCompositeConstruct, 3 + (int32_t) c.fArguments.size(), out); this->writeWord(this->getType(c.fType), out); this->writeWord(result, out); for (SpvId id : arguments) { this->writeWord(id, out); } return result; } SpvId SPIRVCodeGenerator::writeConstructor(const Constructor& c, OutputStream& out) { if (c.fArguments.size() == 1 && this->getActualType(c.fType) == this->getActualType(c.fArguments[0]->fType)) { return this->writeExpression(*c.fArguments[0], out); } if (c.fType == *fContext.fFloat_Type || c.fType == *fContext.fHalf_Type) { return this->writeFloatConstructor(c, out); } else if (c.fType == *fContext.fInt_Type || c.fType == *fContext.fShort_Type || c.fType == *fContext.fByte_Type) { return this->writeIntConstructor(c, out); } else if (c.fType == *fContext.fUInt_Type || c.fType == *fContext.fUShort_Type || c.fType == *fContext.fUByte_Type) { return this->writeUIntConstructor(c, out); } switch (c.fType.kind()) { case Type::kVector_Kind: return this->writeVectorConstructor(c, out); case Type::kMatrix_Kind: return this->writeMatrixConstructor(c, out); case Type::kArray_Kind: return this->writeArrayConstructor(c, out); default: ABORT("unsupported constructor: %s", c.description().c_str()); } } SpvStorageClass_ get_storage_class(const Modifiers& modifiers) { if (modifiers.fFlags & Modifiers::kIn_Flag) { SkASSERT(!(modifiers.fLayout.fFlags & Layout::kPushConstant_Flag)); return SpvStorageClassInput; } else if (modifiers.fFlags & Modifiers::kOut_Flag) { SkASSERT(!(modifiers.fLayout.fFlags & Layout::kPushConstant_Flag)); return SpvStorageClassOutput; } else if (modifiers.fFlags & Modifiers::kUniform_Flag) { if (modifiers.fLayout.fFlags & Layout::kPushConstant_Flag) { return SpvStorageClassPushConstant; } return SpvStorageClassUniform; } else { return SpvStorageClassFunction; } } SpvStorageClass_ get_storage_class(const Expression& expr) { switch (expr.fKind) { case Expression::kVariableReference_Kind: { const Variable& var = ((VariableReference&) expr).fVariable; if (var.fStorage != Variable::kGlobal_Storage) { return SpvStorageClassFunction; } SpvStorageClass_ result = get_storage_class(var.fModifiers); if (result == SpvStorageClassFunction) { result = SpvStorageClassPrivate; } return result; } case Expression::kFieldAccess_Kind: return get_storage_class(*((FieldAccess&) expr).fBase); case Expression::kIndex_Kind: return get_storage_class(*((IndexExpression&) expr).fBase); default: return SpvStorageClassFunction; } } std::vector SPIRVCodeGenerator::getAccessChain(const Expression& expr, OutputStream& out) { std::vector chain; switch (expr.fKind) { case Expression::kIndex_Kind: { IndexExpression& indexExpr = (IndexExpression&) expr; chain = this->getAccessChain(*indexExpr.fBase, out); chain.push_back(this->writeExpression(*indexExpr.fIndex, out)); break; } case Expression::kFieldAccess_Kind: { FieldAccess& fieldExpr = (FieldAccess&) expr; chain = this->getAccessChain(*fieldExpr.fBase, out); IntLiteral index(fContext, -1, fieldExpr.fFieldIndex); chain.push_back(this->writeIntLiteral(index)); break; } default: { SpvId id = this->getLValue(expr, out)->getPointer(); SkASSERT(id != 0); chain.push_back(id); } } return chain; } class PointerLValue : public SPIRVCodeGenerator::LValue { public: PointerLValue(SPIRVCodeGenerator& gen, SpvId pointer, SpvId type, SPIRVCodeGenerator::Precision precision) : fGen(gen) , fPointer(pointer) , fType(type) , fPrecision(precision) {} virtual SpvId getPointer() override { return fPointer; } virtual SpvId load(OutputStream& out) override { SpvId result = fGen.nextId(); fGen.writeInstruction(SpvOpLoad, fType, result, fPointer, out); fGen.writePrecisionModifier(fPrecision, result); return result; } virtual void store(SpvId value, OutputStream& out) override { fGen.writeInstruction(SpvOpStore, fPointer, value, out); } private: SPIRVCodeGenerator& fGen; const SpvId fPointer; const SpvId fType; const SPIRVCodeGenerator::Precision fPrecision; }; class SwizzleLValue : public SPIRVCodeGenerator::LValue { public: SwizzleLValue(SPIRVCodeGenerator& gen, SpvId vecPointer, const std::vector& components, const Type& baseType, const Type& swizzleType, SPIRVCodeGenerator::Precision precision) : fGen(gen) , fVecPointer(vecPointer) , fComponents(components) , fBaseType(baseType) , fSwizzleType(swizzleType) , fPrecision(precision) {} virtual SpvId getPointer() override { return 0; } virtual SpvId load(OutputStream& out) override { SpvId base = fGen.nextId(); fGen.writeInstruction(SpvOpLoad, fGen.getType(fBaseType), base, fVecPointer, out); fGen.writePrecisionModifier(fPrecision, base); SpvId result = fGen.nextId(); fGen.writeOpCode(SpvOpVectorShuffle, 5 + (int32_t) fComponents.size(), out); fGen.writeWord(fGen.getType(fSwizzleType), out); fGen.writeWord(result, out); fGen.writeWord(base, out); fGen.writeWord(base, out); for (int component : fComponents) { fGen.writeWord(component, out); } fGen.writePrecisionModifier(fPrecision, result); return result; } virtual void store(SpvId value, OutputStream& out) override { // use OpVectorShuffle to mix and match the vector components. We effectively create // a virtual vector out of the concatenation of the left and right vectors, and then // select components from this virtual vector to make the result vector. For // instance, given: // float3L = ...; // float3R = ...; // L.xz = R.xy; // we end up with the virtual vector (L.x, L.y, L.z, R.x, R.y, R.z). Then we want // our result vector to look like (R.x, L.y, R.y), so we need to select indices // (3, 1, 4). SpvId base = fGen.nextId(); fGen.writeInstruction(SpvOpLoad, fGen.getType(fBaseType), base, fVecPointer, out); SpvId shuffle = fGen.nextId(); fGen.writeOpCode(SpvOpVectorShuffle, 5 + fBaseType.columns(), out); fGen.writeWord(fGen.getType(fBaseType), out); fGen.writeWord(shuffle, out); fGen.writeWord(base, out); fGen.writeWord(value, out); for (int i = 0; i < fBaseType.columns(); i++) { // current offset into the virtual vector, defaults to pulling the unmodified // value from the left side int offset = i; // check to see if we are writing this component for (size_t j = 0; j < fComponents.size(); j++) { if (fComponents[j] == i) { // we're writing to this component, so adjust the offset to pull from // the correct component of the right side instead of preserving the // value from the left offset = (int) (j + fBaseType.columns()); break; } } fGen.writeWord(offset, out); } fGen.writePrecisionModifier(fPrecision, shuffle); fGen.writeInstruction(SpvOpStore, fVecPointer, shuffle, out); } private: SPIRVCodeGenerator& fGen; const SpvId fVecPointer; const std::vector& fComponents; const Type& fBaseType; const Type& fSwizzleType; const SPIRVCodeGenerator::Precision fPrecision; }; std::unique_ptr SPIRVCodeGenerator::getLValue(const Expression& expr, OutputStream& out) { Precision precision = expr.fType.highPrecision() ? Precision::kHigh : Precision::kLow; switch (expr.fKind) { case Expression::kVariableReference_Kind: { SpvId type; const Variable& var = ((VariableReference&) expr).fVariable; if (var.fModifiers.fLayout.fBuiltin == SK_IN_BUILTIN) { type = this->getType(Type("sk_in", Type::kArray_Kind, var.fType.componentType(), fSkInCount)); } else { type = this->getType(expr.fType); } auto entry = fVariableMap.find(&var); SkASSERT(entry != fVariableMap.end()); return std::unique_ptr(new PointerLValue(*this, entry->second, type, precision)); } case Expression::kIndex_Kind: // fall through case Expression::kFieldAccess_Kind: { std::vector chain = this->getAccessChain(expr, out); SpvId member = this->nextId(); this->writeOpCode(SpvOpAccessChain, (SpvId) (3 + chain.size()), out); this->writeWord(this->getPointerType(expr.fType, get_storage_class(expr)), out); this->writeWord(member, out); for (SpvId idx : chain) { this->writeWord(idx, out); } return std::unique_ptr(new PointerLValue( *this, member, this->getType(expr.fType), precision)); } case Expression::kSwizzle_Kind: { Swizzle& swizzle = (Swizzle&) expr; size_t count = swizzle.fComponents.size(); SpvId base = this->getLValue(*swizzle.fBase, out)->getPointer(); SkASSERT(base); if (count == 1) { IntLiteral index(fContext, -1, swizzle.fComponents[0]); SpvId member = this->nextId(); this->writeInstruction(SpvOpAccessChain, this->getPointerType(swizzle.fType, get_storage_class(*swizzle.fBase)), member, base, this->writeIntLiteral(index), out); return std::unique_ptr(new PointerLValue( *this, member, this->getType(expr.fType), precision)); } else { return std::unique_ptr(new SwizzleLValue( *this, base, swizzle.fComponents, swizzle.fBase->fType, expr.fType, precision)); } } case Expression::kTernary_Kind: { TernaryExpression& t = (TernaryExpression&) expr; SpvId test = this->writeExpression(*t.fTest, out); SpvId end = this->nextId(); SpvId ifTrueLabel = this->nextId(); SpvId ifFalseLabel = this->nextId(); this->writeInstruction(SpvOpSelectionMerge, end, SpvSelectionControlMaskNone, out); this->writeInstruction(SpvOpBranchConditional, test, ifTrueLabel, ifFalseLabel, out); this->writeLabel(ifTrueLabel, out); SpvId ifTrue = this->getLValue(*t.fIfTrue, out)->getPointer(); SkASSERT(ifTrue); this->writeInstruction(SpvOpBranch, end, out); ifTrueLabel = fCurrentBlock; SpvId ifFalse = this->getLValue(*t.fIfFalse, out)->getPointer(); SkASSERT(ifFalse); ifFalseLabel = fCurrentBlock; this->writeInstruction(SpvOpBranch, end, out); SpvId result = this->nextId(); this->writeInstruction(SpvOpPhi, this->getType(*fContext.fBool_Type), result, ifTrue, ifTrueLabel, ifFalse, ifFalseLabel, out); return std::unique_ptr(new PointerLValue( *this, result, this->getType(expr.fType), precision)); } default: // expr isn't actually an lvalue, create a dummy variable for it. This case happens due // to the need to store values in temporary variables during function calls (see // comments in getFunctionType); erroneous uses of rvalues as lvalues should have been // caught by IRGenerator SpvId result = this->nextId(); SpvId type = this->getPointerType(expr.fType, SpvStorageClassFunction); this->writeInstruction(SpvOpVariable, type, result, SpvStorageClassFunction, fVariableBuffer); this->writeInstruction(SpvOpStore, result, this->writeExpression(expr, out), out); return std::unique_ptr(new PointerLValue( *this, result, this->getType(expr.fType), precision)); } } SpvId SPIRVCodeGenerator::writeVariableReference(const VariableReference& ref, OutputStream& out) { SpvId result = this->nextId(); auto entry = fVariableMap.find(&ref.fVariable); SkASSERT(entry != fVariableMap.end()); SpvId var = entry->second; this->writeInstruction(SpvOpLoad, this->getType(ref.fVariable.fType), result, var, out); this->writePrecisionModifier(ref.fVariable.fType, result); if (ref.fVariable.fModifiers.fLayout.fBuiltin == SK_FRAGCOORD_BUILTIN && fProgram.fSettings.fFlipY) { // need to remap to a top-left coordinate system if (fRTHeightStructId == (SpvId) -1) { // height variable hasn't been written yet std::shared_ptr st(new SymbolTable(&fErrors)); SkASSERT(fRTHeightFieldIndex == (SpvId) -1); std::vector fields; fields.emplace_back(Modifiers(), SKSL_RTHEIGHT_NAME, fContext.fFloat_Type.get()); StringFragment name("sksl_synthetic_uniforms"); Type intfStruct(-1, name, fields); Layout layout(0, -1, -1, 1, -1, -1, -1, -1, Layout::Format::kUnspecified, Layout::kUnspecified_Primitive, -1, -1, "", Layout::kNo_Key, Layout::CType::kDefault); Variable* intfVar = (Variable*) fSynthetics.takeOwnership(std::unique_ptr( new Variable(-1, Modifiers(layout, Modifiers::kUniform_Flag), name, intfStruct, Variable::kGlobal_Storage))); InterfaceBlock intf(-1, intfVar, name, String(""), std::vector>(), st); fRTHeightStructId = this->writeInterfaceBlock(intf); fRTHeightFieldIndex = 0; } SkASSERT(fRTHeightFieldIndex != (SpvId) -1); // write float4(gl_FragCoord.x, u_skRTHeight - gl_FragCoord.y, 0.0, gl_FragCoord.w) SpvId xId = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, this->getType(*fContext.fFloat_Type), xId, result, 0, out); IntLiteral fieldIndex(fContext, -1, fRTHeightFieldIndex); SpvId fieldIndexId = this->writeIntLiteral(fieldIndex); SpvId heightPtr = this->nextId(); this->writeOpCode(SpvOpAccessChain, 5, out); this->writeWord(this->getPointerType(*fContext.fFloat_Type, SpvStorageClassUniform), out); this->writeWord(heightPtr, out); this->writeWord(fRTHeightStructId, out); this->writeWord(fieldIndexId, out); SpvId heightRead = this->nextId(); this->writeInstruction(SpvOpLoad, this->getType(*fContext.fFloat_Type), heightRead, heightPtr, out); SpvId rawYId = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, this->getType(*fContext.fFloat_Type), rawYId, result, 1, out); SpvId flippedYId = this->nextId(); this->writeInstruction(SpvOpFSub, this->getType(*fContext.fFloat_Type), flippedYId, heightRead, rawYId, out); FloatLiteral zero(fContext, -1, 0.0); SpvId zeroId = writeFloatLiteral(zero); FloatLiteral one(fContext, -1, 1.0); SpvId wId = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, this->getType(*fContext.fFloat_Type), wId, result, 3, out); SpvId flipped = this->nextId(); this->writeOpCode(SpvOpCompositeConstruct, 7, out); this->writeWord(this->getType(*fContext.fFloat4_Type), out); this->writeWord(flipped, out); this->writeWord(xId, out); this->writeWord(flippedYId, out); this->writeWord(zeroId, out); this->writeWord(wId, out); return flipped; } if (ref.fVariable.fModifiers.fLayout.fBuiltin == SK_CLOCKWISE_BUILTIN && !fProgram.fSettings.fFlipY) { // FrontFacing in Vulkan is defined in terms of a top-down render target. In skia, we use // the default convention of "counter-clockwise face is front". SpvId inverse = this->nextId(); this->writeInstruction(SpvOpLogicalNot, this->getType(*fContext.fBool_Type), inverse, result, out); return inverse; } return result; } SpvId SPIRVCodeGenerator::writeIndexExpression(const IndexExpression& expr, OutputStream& out) { if (expr.fBase->fType.kind() == Type::Kind::kVector_Kind) { SpvId base = this->writeExpression(*expr.fBase, out); SpvId index = this->writeExpression(*expr.fIndex, out); SpvId result = this->nextId(); this->writeInstruction(SpvOpVectorExtractDynamic, this->getType(expr.fType), result, base, index, out); return result; } return getLValue(expr, out)->load(out); } SpvId SPIRVCodeGenerator::writeFieldAccess(const FieldAccess& f, OutputStream& out) { return getLValue(f, out)->load(out); } SpvId SPIRVCodeGenerator::writeSwizzle(const Swizzle& swizzle, OutputStream& out) { SpvId base = this->writeExpression(*swizzle.fBase, out); SpvId result = this->nextId(); size_t count = swizzle.fComponents.size(); if (count == 1) { this->writeInstruction(SpvOpCompositeExtract, this->getType(swizzle.fType), result, base, swizzle.fComponents[0], out); } else { this->writeOpCode(SpvOpVectorShuffle, 5 + (int32_t) count, out); this->writeWord(this->getType(swizzle.fType), out); this->writeWord(result, out); this->writeWord(base, out); SpvId other; int last = swizzle.fComponents.back(); if (last < 0) { if (!fConstantZeroOneVector) { FloatLiteral zero(fContext, -1, 0); SpvId zeroId = this->writeFloatLiteral(zero); FloatLiteral one(fContext, -1, 1); SpvId oneId = this->writeFloatLiteral(one); SpvId type = this->getType(*fContext.fFloat2_Type); fConstantZeroOneVector = this->nextId(); this->writeOpCode(SpvOpConstantComposite, 5, fConstantBuffer); this->writeWord(type, fConstantBuffer); this->writeWord(fConstantZeroOneVector, fConstantBuffer); this->writeWord(zeroId, fConstantBuffer); this->writeWord(oneId, fConstantBuffer); } other = fConstantZeroOneVector; } else { other = base; } this->writeWord(other, out); for (int component : swizzle.fComponents) { if (component == SKSL_SWIZZLE_0) { this->writeWord(swizzle.fBase->fType.columns(), out); } else if (component == SKSL_SWIZZLE_1) { this->writeWord(swizzle.fBase->fType.columns() + 1, out); } else { this->writeWord(component, out); } } } return result; } SpvId SPIRVCodeGenerator::writeBinaryOperation(const Type& resultType, const Type& operandType, SpvId lhs, SpvId rhs, SpvOp_ ifFloat, SpvOp_ ifInt, SpvOp_ ifUInt, SpvOp_ ifBool, OutputStream& out) { SpvId result = this->nextId(); if (is_float(fContext, operandType)) { this->writeInstruction(ifFloat, this->getType(resultType), result, lhs, rhs, out); } else if (is_signed(fContext, operandType)) { this->writeInstruction(ifInt, this->getType(resultType), result, lhs, rhs, out); } else if (is_unsigned(fContext, operandType)) { this->writeInstruction(ifUInt, this->getType(resultType), result, lhs, rhs, out); } else if (operandType == *fContext.fBool_Type) { this->writeInstruction(ifBool, this->getType(resultType), result, lhs, rhs, out); return result; // skip RelaxedPrecision check } else { ABORT("invalid operandType: %s", operandType.description().c_str()); } if (getActualType(resultType) == operandType && !resultType.highPrecision()) { this->writeInstruction(SpvOpDecorate, result, SpvDecorationRelaxedPrecision, fDecorationBuffer); } return result; } SpvId SPIRVCodeGenerator::foldToBool(SpvId id, const Type& operandType, SpvOp op, OutputStream& out) { if (operandType.kind() == Type::kVector_Kind) { SpvId result = this->nextId(); this->writeInstruction(op, this->getType(*fContext.fBool_Type), result, id, out); return result; } return id; } SpvId SPIRVCodeGenerator::writeMatrixComparison(const Type& operandType, SpvId lhs, SpvId rhs, SpvOp_ floatOperator, SpvOp_ intOperator, SpvOp_ vectorMergeOperator, SpvOp_ mergeOperator, OutputStream& out) { SpvOp_ compareOp = is_float(fContext, operandType) ? floatOperator : intOperator; SkASSERT(operandType.kind() == Type::kMatrix_Kind); SpvId columnType = this->getType(operandType.componentType().toCompound(fContext, operandType.rows(), 1)); SpvId bvecType = this->getType(fContext.fBool_Type->toCompound(fContext, operandType.rows(), 1)); SpvId boolType = this->getType(*fContext.fBool_Type); SpvId result = 0; for (int i = 0; i < operandType.columns(); i++) { SpvId columnL = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, columnType, columnL, lhs, i, out); SpvId columnR = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, columnType, columnR, rhs, i, out); SpvId compare = this->nextId(); this->writeInstruction(compareOp, bvecType, compare, columnL, columnR, out); SpvId merge = this->nextId(); this->writeInstruction(vectorMergeOperator, boolType, merge, compare, out); if (result != 0) { SpvId next = this->nextId(); this->writeInstruction(mergeOperator, boolType, next, result, merge, out); result = next; } else { result = merge; } } return result; } SpvId SPIRVCodeGenerator::writeComponentwiseMatrixBinary(const Type& operandType, SpvId lhs, SpvId rhs, SpvOp_ floatOperator, SpvOp_ intOperator, OutputStream& out) { SpvOp_ op = is_float(fContext, operandType) ? floatOperator : intOperator; SkASSERT(operandType.kind() == Type::kMatrix_Kind); SpvId columnType = this->getType(operandType.componentType().toCompound(fContext, operandType.rows(), 1)); SpvId columns[4]; for (int i = 0; i < operandType.columns(); i++) { SpvId columnL = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, columnType, columnL, lhs, i, out); SpvId columnR = this->nextId(); this->writeInstruction(SpvOpCompositeExtract, columnType, columnR, rhs, i, out); columns[i] = this->nextId(); this->writeInstruction(op, columnType, columns[i], columnL, columnR, out); } SpvId result = this->nextId(); this->writeOpCode(SpvOpCompositeConstruct, 3 + operandType.columns(), out); this->writeWord(this->getType(operandType), out); this->writeWord(result, out); for (int i = 0; i < operandType.columns(); i++) { this->writeWord(columns[i], out); } return result; } std::unique_ptr create_literal_1(const Context& context, const Type& type) { if (type.isInteger()) { return std::unique_ptr(new IntLiteral(-1, 1, &type)); } else if (type.isFloat()) { return std::unique_ptr(new FloatLiteral(-1, 1.0, &type)); } else { ABORT("math is unsupported on type '%s'", type.name().c_str()); } } SpvId SPIRVCodeGenerator::writeBinaryExpression(const Type& leftType, SpvId lhs, Token::Kind op, const Type& rightType, SpvId rhs, const Type& resultType, OutputStream& out) { Type tmp(""); // overall type we are operating on: float2, int, uint4... const Type* operandType; // IR allows mismatched types in expressions (e.g. float2 * float), but they need special // handling in SPIR-V if (this->getActualType(leftType) != this->getActualType(rightType)) { if (leftType.kind() == Type::kVector_Kind && rightType.isNumber()) { if (op == Token::SLASH) { SpvId one = this->writeExpression(*create_literal_1(fContext, rightType), out); SpvId inverse = this->nextId(); this->writeInstruction(SpvOpFDiv, this->getType(rightType), inverse, one, rhs, out); rhs = inverse; op = Token::STAR; } if (op == Token::STAR) { SpvId result = this->nextId(); this->writeInstruction(SpvOpVectorTimesScalar, this->getType(resultType), result, lhs, rhs, out); return result; } // promote number to vector SpvId vec = this->nextId(); const Type& vecType = leftType; this->writeOpCode(SpvOpCompositeConstruct, 3 + vecType.columns(), out); this->writeWord(this->getType(vecType), out); this->writeWord(vec, out); for (int i = 0; i < vecType.columns(); i++) { this->writeWord(rhs, out); } rhs = vec; operandType = &leftType; } else if (rightType.kind() == Type::kVector_Kind && leftType.isNumber()) { if (op == Token::STAR) { SpvId result = this->nextId(); this->writeInstruction(SpvOpVectorTimesScalar, this->getType(resultType), result, rhs, lhs, out); return result; } // promote number to vector SpvId vec = this->nextId(); const Type& vecType = rightType; this->writeOpCode(SpvOpCompositeConstruct, 3 + vecType.columns(), out); this->writeWord(this->getType(vecType), out); this->writeWord(vec, out); for (int i = 0; i < vecType.columns(); i++) { this->writeWord(lhs, out); } lhs = vec; operandType = &rightType; } else if (leftType.kind() == Type::kMatrix_Kind) { SpvOp_ spvop; if (rightType.kind() == Type::kMatrix_Kind) { spvop = SpvOpMatrixTimesMatrix; } else if (rightType.kind() == Type::kVector_Kind) { spvop = SpvOpMatrixTimesVector; } else { SkASSERT(rightType.kind() == Type::kScalar_Kind); spvop = SpvOpMatrixTimesScalar; } SpvId result = this->nextId(); this->writeInstruction(spvop, this->getType(resultType), result, lhs, rhs, out); return result; } else if (rightType.kind() == Type::kMatrix_Kind) { SpvId result = this->nextId(); if (leftType.kind() == Type::kVector_Kind) { this->writeInstruction(SpvOpVectorTimesMatrix, this->getType(resultType), result, lhs, rhs, out); } else { SkASSERT(leftType.kind() == Type::kScalar_Kind); this->writeInstruction(SpvOpMatrixTimesScalar, this->getType(resultType), result, rhs, lhs, out); } return result; } else { SkASSERT(false); return -1; } } else { tmp = this->getActualType(leftType); operandType = &tmp; SkASSERT(*operandType == this->getActualType(rightType)); } switch (op) { case Token::EQEQ: { if (operandType->kind() == Type::kMatrix_Kind) { return this->writeMatrixComparison(*operandType, lhs, rhs, SpvOpFOrdEqual, SpvOpIEqual, SpvOpAll, SpvOpLogicalAnd, out); } SkASSERT(resultType == *fContext.fBool_Type); const Type* tmpType; if (operandType->kind() == Type::kVector_Kind) { tmpType = &fContext.fBool_Type->toCompound(fContext, operandType->columns(), operandType->rows()); } else { tmpType = &resultType; } return this->foldToBool(this->writeBinaryOperation(*tmpType, *operandType, lhs, rhs, SpvOpFOrdEqual, SpvOpIEqual, SpvOpIEqual, SpvOpLogicalEqual, out), *operandType, SpvOpAll, out); } case Token::NEQ: if (operandType->kind() == Type::kMatrix_Kind) { return this->writeMatrixComparison(*operandType, lhs, rhs, SpvOpFOrdNotEqual, SpvOpINotEqual, SpvOpAny, SpvOpLogicalOr, out); } SkASSERT(resultType == *fContext.fBool_Type); const Type* tmpType; if (operandType->kind() == Type::kVector_Kind) { tmpType = &fContext.fBool_Type->toCompound(fContext, operandType->columns(), operandType->rows()); } else { tmpType = &resultType; } return this->foldToBool(this->writeBinaryOperation(*tmpType, *operandType, lhs, rhs, SpvOpFOrdNotEqual, SpvOpINotEqual, SpvOpINotEqual, SpvOpLogicalNotEqual, out), *operandType, SpvOpAny, out); case Token::GT: SkASSERT(resultType == *fContext.fBool_Type); return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFOrdGreaterThan, SpvOpSGreaterThan, SpvOpUGreaterThan, SpvOpUndef, out); case Token::LT: SkASSERT(resultType == *fContext.fBool_Type); return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFOrdLessThan, SpvOpSLessThan, SpvOpULessThan, SpvOpUndef, out); case Token::GTEQ: SkASSERT(resultType == *fContext.fBool_Type); return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFOrdGreaterThanEqual, SpvOpSGreaterThanEqual, SpvOpUGreaterThanEqual, SpvOpUndef, out); case Token::LTEQ: SkASSERT(resultType == *fContext.fBool_Type); return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFOrdLessThanEqual, SpvOpSLessThanEqual, SpvOpULessThanEqual, SpvOpUndef, out); case Token::PLUS: if (leftType.kind() == Type::kMatrix_Kind && rightType.kind() == Type::kMatrix_Kind) { SkASSERT(leftType == rightType); return this->writeComponentwiseMatrixBinary(leftType, lhs, rhs, SpvOpFAdd, SpvOpIAdd, out); } return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFAdd, SpvOpIAdd, SpvOpIAdd, SpvOpUndef, out); case Token::MINUS: if (leftType.kind() == Type::kMatrix_Kind && rightType.kind() == Type::kMatrix_Kind) { SkASSERT(leftType == rightType); return this->writeComponentwiseMatrixBinary(leftType, lhs, rhs, SpvOpFSub, SpvOpISub, out); } return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFSub, SpvOpISub, SpvOpISub, SpvOpUndef, out); case Token::STAR: if (leftType.kind() == Type::kMatrix_Kind && rightType.kind() == Type::kMatrix_Kind) { // matrix multiply SpvId result = this->nextId(); this->writeInstruction(SpvOpMatrixTimesMatrix, this->getType(resultType), result, lhs, rhs, out); return result; } return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFMul, SpvOpIMul, SpvOpIMul, SpvOpUndef, out); case Token::SLASH: return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFDiv, SpvOpSDiv, SpvOpUDiv, SpvOpUndef, out); case Token::PERCENT: return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpFMod, SpvOpSMod, SpvOpUMod, SpvOpUndef, out); case Token::SHL: return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpUndef, SpvOpShiftLeftLogical, SpvOpShiftLeftLogical, SpvOpUndef, out); case Token::SHR: return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpUndef, SpvOpShiftRightArithmetic, SpvOpShiftRightLogical, SpvOpUndef, out); case Token::BITWISEAND: return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpUndef, SpvOpBitwiseAnd, SpvOpBitwiseAnd, SpvOpUndef, out); case Token::BITWISEOR: return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpUndef, SpvOpBitwiseOr, SpvOpBitwiseOr, SpvOpUndef, out); case Token::BITWISEXOR: return this->writeBinaryOperation(resultType, *operandType, lhs, rhs, SpvOpUndef, SpvOpBitwiseXor, SpvOpBitwiseXor, SpvOpUndef, out); case Token::COMMA: return rhs; default: SkASSERT(false); return -1; } } SpvId SPIRVCodeGenerator::writeBinaryExpression(const BinaryExpression& b, OutputStream& out) { // handle cases where we don't necessarily evaluate both LHS and RHS switch (b.fOperator) { case Token::EQ: { SpvId rhs = this->writeExpression(*b.fRight, out); this->getLValue(*b.fLeft, out)->store(rhs, out); return rhs; } case Token::LOGICALAND: return this->writeLogicalAnd(b, out); case Token::LOGICALOR: return this->writeLogicalOr(b, out); default: break; } std::unique_ptr lvalue; SpvId lhs; if (is_assignment(b.fOperator)) { lvalue = this->getLValue(*b.fLeft, out); lhs = lvalue->load(out); } else { lvalue = nullptr; lhs = this->writeExpression(*b.fLeft, out); } SpvId rhs = this->writeExpression(*b.fRight, out); SpvId result = this->writeBinaryExpression(b.fLeft->fType, lhs, remove_assignment(b.fOperator), b.fRight->fType, rhs, b.fType, out); if (lvalue) { lvalue->store(result, out); } return result; } SpvId SPIRVCodeGenerator::writeLogicalAnd(const BinaryExpression& a, OutputStream& out) { SkASSERT(a.fOperator == Token::LOGICALAND); BoolLiteral falseLiteral(fContext, -1, false); SpvId falseConstant = this->writeBoolLiteral(falseLiteral); SpvId lhs = this->writeExpression(*a.fLeft, out); SpvId rhsLabel = this->nextId(); SpvId end = this->nextId(); SpvId lhsBlock = fCurrentBlock; this->writeInstruction(SpvOpSelectionMerge, end, SpvSelectionControlMaskNone, out); this->writeInstruction(SpvOpBranchConditional, lhs, rhsLabel, end, out); this->writeLabel(rhsLabel, out); SpvId rhs = this->writeExpression(*a.fRight, out); SpvId rhsBlock = fCurrentBlock; this->writeInstruction(SpvOpBranch, end, out); this->writeLabel(end, out); SpvId result = this->nextId(); this->writeInstruction(SpvOpPhi, this->getType(*fContext.fBool_Type), result, falseConstant, lhsBlock, rhs, rhsBlock, out); return result; } SpvId SPIRVCodeGenerator::writeLogicalOr(const BinaryExpression& o, OutputStream& out) { SkASSERT(o.fOperator == Token::LOGICALOR); BoolLiteral trueLiteral(fContext, -1, true); SpvId trueConstant = this->writeBoolLiteral(trueLiteral); SpvId lhs = this->writeExpression(*o.fLeft, out); SpvId rhsLabel = this->nextId(); SpvId end = this->nextId(); SpvId lhsBlock = fCurrentBlock; this->writeInstruction(SpvOpSelectionMerge, end, SpvSelectionControlMaskNone, out); this->writeInstruction(SpvOpBranchConditional, lhs, end, rhsLabel, out); this->writeLabel(rhsLabel, out); SpvId rhs = this->writeExpression(*o.fRight, out); SpvId rhsBlock = fCurrentBlock; this->writeInstruction(SpvOpBranch, end, out); this->writeLabel(end, out); SpvId result = this->nextId(); this->writeInstruction(SpvOpPhi, this->getType(*fContext.fBool_Type), result, trueConstant, lhsBlock, rhs, rhsBlock, out); return result; } SpvId SPIRVCodeGenerator::writeTernaryExpression(const TernaryExpression& t, OutputStream& out) { SpvId test = this->writeExpression(*t.fTest, out); if (t.fIfTrue->fType.columns() == 1 && t.fIfTrue->isConstant() && t.fIfFalse->isConstant()) { // both true and false are constants, can just use OpSelect SpvId result = this->nextId(); SpvId trueId = this->writeExpression(*t.fIfTrue, out); SpvId falseId = this->writeExpression(*t.fIfFalse, out); this->writeInstruction(SpvOpSelect, this->getType(t.fType), result, test, trueId, falseId, out); return result; } // was originally using OpPhi to choose the result, but for some reason that is crashing on // Adreno. Switched to storing the result in a temp variable as glslang does. SpvId var = this->nextId(); this->writeInstruction(SpvOpVariable, this->getPointerType(t.fType, SpvStorageClassFunction), var, SpvStorageClassFunction, fVariableBuffer); SpvId trueLabel = this->nextId(); SpvId falseLabel = this->nextId(); SpvId end = this->nextId(); this->writeInstruction(SpvOpSelectionMerge, end, SpvSelectionControlMaskNone, out); this->writeInstruction(SpvOpBranchConditional, test, trueLabel, falseLabel, out); this->writeLabel(trueLabel, out); this->writeInstruction(SpvOpStore, var, this->writeExpression(*t.fIfTrue, out), out); this->writeInstruction(SpvOpBranch, end, out); this->writeLabel(falseLabel, out); this->writeInstruction(SpvOpStore, var, this->writeExpression(*t.fIfFalse, out), out); this->writeInstruction(SpvOpBranch, end, out); this->writeLabel(end, out); SpvId result = this->nextId(); this->writeInstruction(SpvOpLoad, this->getType(t.fType), result, var, out); this->writePrecisionModifier(t.fType, result); return result; } SpvId SPIRVCodeGenerator::writePrefixExpression(const PrefixExpression& p, OutputStream& out) { if (p.fOperator == Token::MINUS) { SpvId result = this->nextId(); SpvId typeId = this->getType(p.fType); SpvId expr = this->writeExpression(*p.fOperand, out); if (is_float(fContext, p.fType)) { this->writeInstruction(SpvOpFNegate, typeId, result, expr, out); } else if (is_signed(fContext, p.fType)) { this->writeInstruction(SpvOpSNegate, typeId, result, expr, out); } else { ABORT("unsupported prefix expression %s", p.description().c_str()); } this->writePrecisionModifier(p.fType, result); return result; } switch (p.fOperator) { case Token::PLUS: return this->writeExpression(*p.fOperand, out); case Token::PLUSPLUS: { std::unique_ptr lv = this->getLValue(*p.fOperand, out); SpvId one = this->writeExpression(*create_literal_1(fContext, p.fType), out); SpvId result = this->writeBinaryOperation(p.fType, p.fType, lv->load(out), one, SpvOpFAdd, SpvOpIAdd, SpvOpIAdd, SpvOpUndef, out); lv->store(result, out); return result; } case Token::MINUSMINUS: { std::unique_ptr lv = this->getLValue(*p.fOperand, out); SpvId one = this->writeExpression(*create_literal_1(fContext, p.fType), out); SpvId result = this->writeBinaryOperation(p.fType, p.fType, lv->load(out), one, SpvOpFSub, SpvOpISub, SpvOpISub, SpvOpUndef, out); lv->store(result, out); return result; } case Token::LOGICALNOT: { SkASSERT(p.fOperand->fType == *fContext.fBool_Type); SpvId result = this->nextId(); this->writeInstruction(SpvOpLogicalNot, this->getType(p.fOperand->fType), result, this->writeExpression(*p.fOperand, out), out); return result; } case Token::BITWISENOT: { SpvId result = this->nextId(); this->writeInstruction(SpvOpNot, this->getType(p.fOperand->fType), result, this->writeExpression(*p.fOperand, out), out); return result; } default: ABORT("unsupported prefix expression: %s", p.description().c_str()); } } SpvId SPIRVCodeGenerator::writePostfixExpression(const PostfixExpression& p, OutputStream& out) { std::unique_ptr lv = this->getLValue(*p.fOperand, out); SpvId result = lv->load(out); SpvId one = this->writeExpression(*create_literal_1(fContext, p.fType), out); switch (p.fOperator) { case Token::PLUSPLUS: { SpvId temp = this->writeBinaryOperation(p.fType, p.fType, result, one, SpvOpFAdd, SpvOpIAdd, SpvOpIAdd, SpvOpUndef, out); lv->store(temp, out); return result; } case Token::MINUSMINUS: { SpvId temp = this->writeBinaryOperation(p.fType, p.fType, result, one, SpvOpFSub, SpvOpISub, SpvOpISub, SpvOpUndef, out); lv->store(temp, out); return result; } default: ABORT("unsupported postfix expression %s", p.description().c_str()); } } SpvId SPIRVCodeGenerator::writeBoolLiteral(const BoolLiteral& b) { if (b.fValue) { if (fBoolTrue == 0) { fBoolTrue = this->nextId(); this->writeInstruction(SpvOpConstantTrue, this->getType(b.fType), fBoolTrue, fConstantBuffer); } return fBoolTrue; } else { if (fBoolFalse == 0) { fBoolFalse = this->nextId(); this->writeInstruction(SpvOpConstantFalse, this->getType(b.fType), fBoolFalse, fConstantBuffer); } return fBoolFalse; } } SpvId SPIRVCodeGenerator::writeIntLiteral(const IntLiteral& i) { ConstantType type; if (i.fType == *fContext.fInt_Type) { type = ConstantType::kInt; } else if (i.fType == *fContext.fUInt_Type) { type = ConstantType::kUInt; } else if (i.fType == *fContext.fShort_Type) { type = ConstantType::kShort; } else if (i.fType == *fContext.fUShort_Type) { type = ConstantType::kUShort; } std::pair key(i.fValue, type); auto entry = fNumberConstants.find(key); if (entry == fNumberConstants.end()) { SpvId result = this->nextId(); this->writeInstruction(SpvOpConstant, this->getType(i.fType), result, (SpvId) i.fValue, fConstantBuffer); fNumberConstants[key] = result; return result; } return entry->second; } SpvId SPIRVCodeGenerator::writeFloatLiteral(const FloatLiteral& f) { if (f.fType != *fContext.fDouble_Type) { ConstantType type; if (f.fType == *fContext.fHalf_Type) { type = ConstantType::kHalf; } else { type = ConstantType::kFloat; } float value = (float) f.fValue; std::pair key(f.fValue, type); auto entry = fNumberConstants.find(key); if (entry == fNumberConstants.end()) { SpvId result = this->nextId(); uint32_t bits; SkASSERT(sizeof(bits) == sizeof(value)); memcpy(&bits, &value, sizeof(bits)); this->writeInstruction(SpvOpConstant, this->getType(f.fType), result, bits, fConstantBuffer); fNumberConstants[key] = result; return result; } return entry->second; } else { std::pair key(f.fValue, ConstantType::kDouble); auto entry = fNumberConstants.find(key); if (entry == fNumberConstants.end()) { SpvId result = this->nextId(); uint64_t bits; SkASSERT(sizeof(bits) == sizeof(f.fValue)); memcpy(&bits, &f.fValue, sizeof(bits)); this->writeInstruction(SpvOpConstant, this->getType(f.fType), result, bits & 0xffffffff, bits >> 32, fConstantBuffer); fNumberConstants[key] = result; return result; } return entry->second; } } SpvId SPIRVCodeGenerator::writeFunctionStart(const FunctionDeclaration& f, OutputStream& out) { SpvId result = fFunctionMap[&f]; this->writeInstruction(SpvOpFunction, this->getType(f.fReturnType), result, SpvFunctionControlMaskNone, this->getFunctionType(f), out); this->writeInstruction(SpvOpName, result, f.fName, fNameBuffer); for (size_t i = 0; i < f.fParameters.size(); i++) { SpvId id = this->nextId(); fVariableMap[f.fParameters[i]] = id; SpvId type; type = this->getPointerType(f.fParameters[i]->fType, SpvStorageClassFunction); this->writeInstruction(SpvOpFunctionParameter, type, id, out); } return result; } SpvId SPIRVCodeGenerator::writeFunction(const FunctionDefinition& f, OutputStream& out) { fVariableBuffer.reset(); SpvId result = this->writeFunctionStart(f.fDeclaration, out); this->writeLabel(this->nextId(), out); StringStream bodyBuffer; this->writeBlock((Block&) *f.fBody, bodyBuffer); write_stringstream(fVariableBuffer, out); if (f.fDeclaration.fName == "main") { write_stringstream(fGlobalInitializersBuffer, out); } write_stringstream(bodyBuffer, out); if (fCurrentBlock) { if (f.fDeclaration.fReturnType == *fContext.fVoid_Type) { this->writeInstruction(SpvOpReturn, out); } else { this->writeInstruction(SpvOpUnreachable, out); } } this->writeInstruction(SpvOpFunctionEnd, out); return result; } void SPIRVCodeGenerator::writeLayout(const Layout& layout, SpvId target) { if (layout.fLocation >= 0) { this->writeInstruction(SpvOpDecorate, target, SpvDecorationLocation, layout.fLocation, fDecorationBuffer); } if (layout.fBinding >= 0) { this->writeInstruction(SpvOpDecorate, target, SpvDecorationBinding, layout.fBinding, fDecorationBuffer); } if (layout.fIndex >= 0) { this->writeInstruction(SpvOpDecorate, target, SpvDecorationIndex, layout.fIndex, fDecorationBuffer); } if (layout.fSet >= 0) { this->writeInstruction(SpvOpDecorate, target, SpvDecorationDescriptorSet, layout.fSet, fDecorationBuffer); } if (layout.fInputAttachmentIndex >= 0) { this->writeInstruction(SpvOpDecorate, target, SpvDecorationInputAttachmentIndex, layout.fInputAttachmentIndex, fDecorationBuffer); fCapabilities |= (((uint64_t) 1) << SpvCapabilityInputAttachment); } if (layout.fBuiltin >= 0 && layout.fBuiltin != SK_FRAGCOLOR_BUILTIN && layout.fBuiltin != SK_IN_BUILTIN && layout.fBuiltin != SK_OUT_BUILTIN) { this->writeInstruction(SpvOpDecorate, target, SpvDecorationBuiltIn, layout.fBuiltin, fDecorationBuffer); } } void SPIRVCodeGenerator::writeLayout(const Layout& layout, SpvId target, int member) { if (layout.fLocation >= 0) { this->writeInstruction(SpvOpMemberDecorate, target, member, SpvDecorationLocation, layout.fLocation, fDecorationBuffer); } if (layout.fBinding >= 0) { this->writeInstruction(SpvOpMemberDecorate, target, member, SpvDecorationBinding, layout.fBinding, fDecorationBuffer); } if (layout.fIndex >= 0) { this->writeInstruction(SpvOpMemberDecorate, target, member, SpvDecorationIndex, layout.fIndex, fDecorationBuffer); } if (layout.fSet >= 0) { this->writeInstruction(SpvOpMemberDecorate, target, member, SpvDecorationDescriptorSet, layout.fSet, fDecorationBuffer); } if (layout.fInputAttachmentIndex >= 0) { this->writeInstruction(SpvOpDecorate, target, member, SpvDecorationInputAttachmentIndex, layout.fInputAttachmentIndex, fDecorationBuffer); } if (layout.fBuiltin >= 0) { this->writeInstruction(SpvOpMemberDecorate, target, member, SpvDecorationBuiltIn, layout.fBuiltin, fDecorationBuffer); } } static void update_sk_in_count(const Modifiers& m, int* outSkInCount) { switch (m.fLayout.fPrimitive) { case Layout::kPoints_Primitive: *outSkInCount = 1; break; case Layout::kLines_Primitive: *outSkInCount = 2; break; case Layout::kLinesAdjacency_Primitive: *outSkInCount = 4; break; case Layout::kTriangles_Primitive: *outSkInCount = 3; break; case Layout::kTrianglesAdjacency_Primitive: *outSkInCount = 6; break; default: return; } } SpvId SPIRVCodeGenerator::writeInterfaceBlock(const InterfaceBlock& intf) { bool isBuffer = (0 != (intf.fVariable.fModifiers.fFlags & Modifiers::kBuffer_Flag)); bool pushConstant = (0 != (intf.fVariable.fModifiers.fLayout.fFlags & Layout::kPushConstant_Flag)); MemoryLayout memoryLayout = (pushConstant || isBuffer) ? MemoryLayout(MemoryLayout::k430_Standard) : fDefaultLayout; SpvId result = this->nextId(); const Type* type = &intf.fVariable.fType; if (fProgram.fInputs.fRTHeight) { SkASSERT(fRTHeightStructId == (SpvId) -1); SkASSERT(fRTHeightFieldIndex == (SpvId) -1); std::vector fields = type->fields(); fRTHeightStructId = result; fRTHeightFieldIndex = fields.size(); fields.emplace_back(Modifiers(), StringFragment(SKSL_RTHEIGHT_NAME), fContext.fFloat_Type.get()); type = new Type(type->fOffset, type->name(), fields); } SpvId typeId; if (intf.fVariable.fModifiers.fLayout.fBuiltin == SK_IN_BUILTIN) { for (const auto& e : fProgram) { if (e.fKind == ProgramElement::kModifiers_Kind) { const Modifiers& m = ((ModifiersDeclaration&) e).fModifiers; update_sk_in_count(m, &fSkInCount); } } typeId = this->getType(Type("sk_in", Type::kArray_Kind, intf.fVariable.fType.componentType(), fSkInCount), memoryLayout); } else { typeId = this->getType(*type, memoryLayout); } if (intf.fVariable.fModifiers.fFlags & Modifiers::kBuffer_Flag) { this->writeInstruction(SpvOpDecorate, typeId, SpvDecorationBufferBlock, fDecorationBuffer); } else if (intf.fVariable.fModifiers.fLayout.fBuiltin == -1) { this->writeInstruction(SpvOpDecorate, typeId, SpvDecorationBlock, fDecorationBuffer); } SpvStorageClass_ storageClass = get_storage_class(intf.fVariable.fModifiers); SpvId ptrType = this->nextId(); this->writeInstruction(SpvOpTypePointer, ptrType, storageClass, typeId, fConstantBuffer); this->writeInstruction(SpvOpVariable, ptrType, result, storageClass, fConstantBuffer); Layout layout = intf.fVariable.fModifiers.fLayout; if (intf.fVariable.fModifiers.fFlags & Modifiers::kUniform_Flag && layout.fSet == -1) { layout.fSet = 0; } this->writeLayout(layout, result); fVariableMap[&intf.fVariable] = result; if (fProgram.fInputs.fRTHeight) { delete type; } return result; } void SPIRVCodeGenerator::writePrecisionModifier(const Type& type, SpvId id) { this->writePrecisionModifier(type.highPrecision() ? Precision::kHigh : Precision::kLow, id); } void SPIRVCodeGenerator::writePrecisionModifier(Precision precision, SpvId id) { if (precision == Precision::kLow) { this->writeInstruction(SpvOpDecorate, id, SpvDecorationRelaxedPrecision, fDecorationBuffer); } } #define BUILTIN_IGNORE 9999 void SPIRVCodeGenerator::writeGlobalVars(Program::Kind kind, const VarDeclarations& decl, OutputStream& out) { for (size_t i = 0; i < decl.fVars.size(); i++) { if (decl.fVars[i]->fKind == Statement::kNop_Kind) { continue; } const VarDeclaration& varDecl = (VarDeclaration&) *decl.fVars[i]; const Variable* var = varDecl.fVar; // These haven't been implemented in our SPIR-V generator yet and we only currently use them // in the OpenGL backend. SkASSERT(!(var->fModifiers.fFlags & (Modifiers::kReadOnly_Flag | Modifiers::kWriteOnly_Flag | Modifiers::kCoherent_Flag | Modifiers::kVolatile_Flag | Modifiers::kRestrict_Flag))); if (var->fModifiers.fLayout.fBuiltin == BUILTIN_IGNORE) { continue; } if (var->fModifiers.fLayout.fBuiltin == SK_FRAGCOLOR_BUILTIN && kind != Program::kFragment_Kind) { SkASSERT(!fProgram.fSettings.fFragColorIsInOut); continue; } if (!var->fReadCount && !var->fWriteCount && !(var->fModifiers.fFlags & (Modifiers::kIn_Flag | Modifiers::kOut_Flag | Modifiers::kUniform_Flag | Modifiers::kBuffer_Flag))) { // variable is dead and not an input / output var (the Vulkan debug layers complain if // we elide an interface var, even if it's dead) continue; } SpvStorageClass_ storageClass; if (var->fModifiers.fFlags & Modifiers::kIn_Flag) { storageClass = SpvStorageClassInput; } else if (var->fModifiers.fFlags & Modifiers::kOut_Flag) { storageClass = SpvStorageClassOutput; } else if (var->fModifiers.fFlags & Modifiers::kUniform_Flag) { if (var->fType.kind() == Type::kSampler_Kind) { storageClass = SpvStorageClassUniformConstant; } else { storageClass = SpvStorageClassUniform; } } else { storageClass = SpvStorageClassPrivate; } SpvId id = this->nextId(); fVariableMap[var] = id; SpvId type; if (var->fModifiers.fLayout.fBuiltin == SK_IN_BUILTIN) { type = this->getPointerType(Type("sk_in", Type::kArray_Kind, var->fType.componentType(), fSkInCount), storageClass); } else { type = this->getPointerType(var->fType, storageClass); } this->writeInstruction(SpvOpVariable, type, id, storageClass, fConstantBuffer); this->writeInstruction(SpvOpName, id, var->fName, fNameBuffer); this->writePrecisionModifier(var->fType, id); if (varDecl.fValue) { SkASSERT(!fCurrentBlock); fCurrentBlock = -1; SpvId value = this->writeExpression(*varDecl.fValue, fGlobalInitializersBuffer); this->writeInstruction(SpvOpStore, id, value, fGlobalInitializersBuffer); fCurrentBlock = 0; } this->writeLayout(var->fModifiers.fLayout, id); if (var->fModifiers.fFlags & Modifiers::kFlat_Flag) { this->writeInstruction(SpvOpDecorate, id, SpvDecorationFlat, fDecorationBuffer); } if (var->fModifiers.fFlags & Modifiers::kNoPerspective_Flag) { this->writeInstruction(SpvOpDecorate, id, SpvDecorationNoPerspective, fDecorationBuffer); } } } void SPIRVCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, OutputStream& out) { for (const auto& stmt : decl.fVars) { SkASSERT(stmt->fKind == Statement::kVarDeclaration_Kind); VarDeclaration& varDecl = (VarDeclaration&) *stmt; const Variable* var = varDecl.fVar; // These haven't been implemented in our SPIR-V generator yet and we only currently use them // in the OpenGL backend. SkASSERT(!(var->fModifiers.fFlags & (Modifiers::kReadOnly_Flag | Modifiers::kWriteOnly_Flag | Modifiers::kCoherent_Flag | Modifiers::kVolatile_Flag | Modifiers::kRestrict_Flag))); SpvId id = this->nextId(); fVariableMap[var] = id; SpvId type = this->getPointerType(var->fType, SpvStorageClassFunction); this->writeInstruction(SpvOpVariable, type, id, SpvStorageClassFunction, fVariableBuffer); this->writeInstruction(SpvOpName, id, var->fName, fNameBuffer); if (varDecl.fValue) { SpvId value = this->writeExpression(*varDecl.fValue, out); this->writeInstruction(SpvOpStore, id, value, out); } } } void SPIRVCodeGenerator::writeStatement(const Statement& s, OutputStream& out) { switch (s.fKind) { case Statement::kNop_Kind: break; case Statement::kBlock_Kind: this->writeBlock((Block&) s, out); break; case Statement::kExpression_Kind: this->writeExpression(*((ExpressionStatement&) s).fExpression, out); break; case Statement::kReturn_Kind: this->writeReturnStatement((ReturnStatement&) s, out); break; case Statement::kVarDeclarations_Kind: this->writeVarDeclarations(*((VarDeclarationsStatement&) s).fDeclaration, out); break; case Statement::kIf_Kind: this->writeIfStatement((IfStatement&) s, out); break; case Statement::kFor_Kind: this->writeForStatement((ForStatement&) s, out); break; case Statement::kWhile_Kind: this->writeWhileStatement((WhileStatement&) s, out); break; case Statement::kDo_Kind: this->writeDoStatement((DoStatement&) s, out); break; case Statement::kSwitch_Kind: this->writeSwitchStatement((SwitchStatement&) s, out); break; case Statement::kBreak_Kind: this->writeInstruction(SpvOpBranch, fBreakTarget.top(), out); break; case Statement::kContinue_Kind: this->writeInstruction(SpvOpBranch, fContinueTarget.top(), out); break; case Statement::kDiscard_Kind: this->writeInstruction(SpvOpKill, out); break; default: ABORT("unsupported statement: %s", s.description().c_str()); } } void SPIRVCodeGenerator::writeBlock(const Block& b, OutputStream& out) { for (size_t i = 0; i < b.fStatements.size(); i++) { this->writeStatement(*b.fStatements[i], out); } } void SPIRVCodeGenerator::writeIfStatement(const IfStatement& stmt, OutputStream& out) { SpvId test = this->writeExpression(*stmt.fTest, out); SpvId ifTrue = this->nextId(); SpvId ifFalse = this->nextId(); if (stmt.fIfFalse) { SpvId end = this->nextId(); this->writeInstruction(SpvOpSelectionMerge, end, SpvSelectionControlMaskNone, out); this->writeInstruction(SpvOpBranchConditional, test, ifTrue, ifFalse, out); this->writeLabel(ifTrue, out); this->writeStatement(*stmt.fIfTrue, out); if (fCurrentBlock) { this->writeInstruction(SpvOpBranch, end, out); } this->writeLabel(ifFalse, out); this->writeStatement(*stmt.fIfFalse, out); if (fCurrentBlock) { this->writeInstruction(SpvOpBranch, end, out); } this->writeLabel(end, out); } else { this->writeInstruction(SpvOpSelectionMerge, ifFalse, SpvSelectionControlMaskNone, out); this->writeInstruction(SpvOpBranchConditional, test, ifTrue, ifFalse, out); this->writeLabel(ifTrue, out); this->writeStatement(*stmt.fIfTrue, out); if (fCurrentBlock) { this->writeInstruction(SpvOpBranch, ifFalse, out); } this->writeLabel(ifFalse, out); } } void SPIRVCodeGenerator::writeForStatement(const ForStatement& f, OutputStream& out) { if (f.fInitializer) { this->writeStatement(*f.fInitializer, out); } SpvId header = this->nextId(); SpvId start = this->nextId(); SpvId body = this->nextId(); SpvId next = this->nextId(); fContinueTarget.push(next); SpvId end = this->nextId(); fBreakTarget.push(end); this->writeInstruction(SpvOpBranch, header, out); this->writeLabel(header, out); this->writeInstruction(SpvOpLoopMerge, end, next, SpvLoopControlMaskNone, out); this->writeInstruction(SpvOpBranch, start, out); this->writeLabel(start, out); if (f.fTest) { SpvId test = this->writeExpression(*f.fTest, out); this->writeInstruction(SpvOpBranchConditional, test, body, end, out); } this->writeLabel(body, out); this->writeStatement(*f.fStatement, out); if (fCurrentBlock) { this->writeInstruction(SpvOpBranch, next, out); } this->writeLabel(next, out); if (f.fNext) { this->writeExpression(*f.fNext, out); } this->writeInstruction(SpvOpBranch, header, out); this->writeLabel(end, out); fBreakTarget.pop(); fContinueTarget.pop(); } void SPIRVCodeGenerator::writeWhileStatement(const WhileStatement& w, OutputStream& out) { SpvId header = this->nextId(); SpvId start = this->nextId(); SpvId body = this->nextId(); SpvId continueTarget = this->nextId(); fContinueTarget.push(continueTarget); SpvId end = this->nextId(); fBreakTarget.push(end); this->writeInstruction(SpvOpBranch, header, out); this->writeLabel(header, out); this->writeInstruction(SpvOpLoopMerge, end, continueTarget, SpvLoopControlMaskNone, out); this->writeInstruction(SpvOpBranch, start, out); this->writeLabel(start, out); SpvId test = this->writeExpression(*w.fTest, out); this->writeInstruction(SpvOpBranchConditional, test, body, end, out); this->writeLabel(body, out); this->writeStatement(*w.fStatement, out); if (fCurrentBlock) { this->writeInstruction(SpvOpBranch, continueTarget, out); } this->writeLabel(continueTarget, out); this->writeInstruction(SpvOpBranch, header, out); this->writeLabel(end, out); fBreakTarget.pop(); fContinueTarget.pop(); } void SPIRVCodeGenerator::writeDoStatement(const DoStatement& d, OutputStream& out) { // We believe the do loop code below will work, but Skia doesn't actually use them and // adequately testing this code in the absence of Skia exercising it isn't straightforward. For // the time being, we just fail with an error due to the lack of testing. If you encounter this // message, simply remove the error call below to see whether our do loop support actually // works. fErrors.error(d.fOffset, "internal error: do loop support has been disabled in SPIR-V, see " "SkSLSPIRVCodeGenerator.cpp for details"); SpvId header = this->nextId(); SpvId start = this->nextId(); SpvId next = this->nextId(); SpvId continueTarget = this->nextId(); fContinueTarget.push(continueTarget); SpvId end = this->nextId(); fBreakTarget.push(end); this->writeInstruction(SpvOpBranch, header, out); this->writeLabel(header, out); this->writeInstruction(SpvOpLoopMerge, end, continueTarget, SpvLoopControlMaskNone, out); this->writeInstruction(SpvOpBranch, start, out); this->writeLabel(start, out); this->writeStatement(*d.fStatement, out); if (fCurrentBlock) { this->writeInstruction(SpvOpBranch, next, out); } this->writeLabel(next, out); SpvId test = this->writeExpression(*d.fTest, out); this->writeInstruction(SpvOpBranchConditional, test, continueTarget, end, out); this->writeLabel(continueTarget, out); this->writeInstruction(SpvOpBranch, header, out); this->writeLabel(end, out); fBreakTarget.pop(); fContinueTarget.pop(); } void SPIRVCodeGenerator::writeSwitchStatement(const SwitchStatement& s, OutputStream& out) { SpvId value = this->writeExpression(*s.fValue, out); std::vector labels; SpvId end = this->nextId(); SpvId defaultLabel = end; fBreakTarget.push(end); int size = 3; for (const auto& c : s.fCases) { SpvId label = this->nextId(); labels.push_back(label); if (c->fValue) { size += 2; } else { defaultLabel = label; } } labels.push_back(end); this->writeInstruction(SpvOpSelectionMerge, end, SpvSelectionControlMaskNone, out); this->writeOpCode(SpvOpSwitch, size, out); this->writeWord(value, out); this->writeWord(defaultLabel, out); for (size_t i = 0; i < s.fCases.size(); ++i) { if (!s.fCases[i]->fValue) { continue; } SkASSERT(s.fCases[i]->fValue->fKind == Expression::kIntLiteral_Kind); this->writeWord(((IntLiteral&) *s.fCases[i]->fValue).fValue, out); this->writeWord(labels[i], out); } for (size_t i = 0; i < s.fCases.size(); ++i) { this->writeLabel(labels[i], out); for (const auto& stmt : s.fCases[i]->fStatements) { this->writeStatement(*stmt, out); } if (fCurrentBlock) { this->writeInstruction(SpvOpBranch, labels[i + 1], out); } } this->writeLabel(end, out); fBreakTarget.pop(); } void SPIRVCodeGenerator::writeReturnStatement(const ReturnStatement& r, OutputStream& out) { if (r.fExpression) { this->writeInstruction(SpvOpReturnValue, this->writeExpression(*r.fExpression, out), out); } else { this->writeInstruction(SpvOpReturn, out); } } void SPIRVCodeGenerator::writeGeometryShaderExecutionMode(SpvId entryPoint, OutputStream& out) { SkASSERT(fProgram.fKind == Program::kGeometry_Kind); int invocations = 1; for (const auto& e : fProgram) { if (e.fKind == ProgramElement::kModifiers_Kind) { const Modifiers& m = ((ModifiersDeclaration&) e).fModifiers; if (m.fFlags & Modifiers::kIn_Flag) { if (m.fLayout.fInvocations != -1) { invocations = m.fLayout.fInvocations; } SpvId input; switch (m.fLayout.fPrimitive) { case Layout::kPoints_Primitive: input = SpvExecutionModeInputPoints; break; case Layout::kLines_Primitive: input = SpvExecutionModeInputLines; break; case Layout::kLinesAdjacency_Primitive: input = SpvExecutionModeInputLinesAdjacency; break; case Layout::kTriangles_Primitive: input = SpvExecutionModeTriangles; break; case Layout::kTrianglesAdjacency_Primitive: input = SpvExecutionModeInputTrianglesAdjacency; break; default: input = 0; break; } update_sk_in_count(m, &fSkInCount); if (input) { this->writeInstruction(SpvOpExecutionMode, entryPoint, input, out); } } else if (m.fFlags & Modifiers::kOut_Flag) { SpvId output; switch (m.fLayout.fPrimitive) { case Layout::kPoints_Primitive: output = SpvExecutionModeOutputPoints; break; case Layout::kLineStrip_Primitive: output = SpvExecutionModeOutputLineStrip; break; case Layout::kTriangleStrip_Primitive: output = SpvExecutionModeOutputTriangleStrip; break; default: output = 0; break; } if (output) { this->writeInstruction(SpvOpExecutionMode, entryPoint, output, out); } if (m.fLayout.fMaxVertices != -1) { this->writeInstruction(SpvOpExecutionMode, entryPoint, SpvExecutionModeOutputVertices, m.fLayout.fMaxVertices, out); } } } } this->writeInstruction(SpvOpExecutionMode, entryPoint, SpvExecutionModeInvocations, invocations, out); } void SPIRVCodeGenerator::writeInstructions(const Program& program, OutputStream& out) { fGLSLExtendedInstructions = this->nextId(); StringStream body; std::set interfaceVars; // assign IDs to functions, determine sk_in size int skInSize = -1; for (const auto& e : program) { switch (e.fKind) { case ProgramElement::kFunction_Kind: { FunctionDefinition& f = (FunctionDefinition&) e; fFunctionMap[&f.fDeclaration] = this->nextId(); break; } case ProgramElement::kModifiers_Kind: { Modifiers& m = ((ModifiersDeclaration&) e).fModifiers; if (m.fFlags & Modifiers::kIn_Flag) { switch (m.fLayout.fPrimitive) { case Layout::kPoints_Primitive: // break case Layout::kLines_Primitive: skInSize = 1; break; case Layout::kLinesAdjacency_Primitive: // break skInSize = 2; break; case Layout::kTriangles_Primitive: // break case Layout::kTrianglesAdjacency_Primitive: skInSize = 3; break; default: break; } } break; } default: break; } } for (const auto& e : program) { if (e.fKind == ProgramElement::kInterfaceBlock_Kind) { InterfaceBlock& intf = (InterfaceBlock&) e; if (SK_IN_BUILTIN == intf.fVariable.fModifiers.fLayout.fBuiltin) { SkASSERT(skInSize != -1); intf.fSizes.emplace_back(new IntLiteral(fContext, -1, skInSize)); } SpvId id = this->writeInterfaceBlock(intf); if (((intf.fVariable.fModifiers.fFlags & Modifiers::kIn_Flag) || (intf.fVariable.fModifiers.fFlags & Modifiers::kOut_Flag)) && intf.fVariable.fModifiers.fLayout.fBuiltin == -1) { interfaceVars.insert(id); } } } for (const auto& e : program) { if (e.fKind == ProgramElement::kVar_Kind) { this->writeGlobalVars(program.fKind, ((VarDeclarations&) e), body); } } for (const auto& e : program) { if (e.fKind == ProgramElement::kFunction_Kind) { this->writeFunction(((FunctionDefinition&) e), body); } } const FunctionDeclaration* main = nullptr; for (auto entry : fFunctionMap) { if (entry.first->fName == "main") { main = entry.first; } } if (!main) { fErrors.error(0, "program does not contain a main() function"); return; } for (auto entry : fVariableMap) { const Variable* var = entry.first; if (var->fStorage == Variable::kGlobal_Storage && ((var->fModifiers.fFlags & Modifiers::kIn_Flag) || (var->fModifiers.fFlags & Modifiers::kOut_Flag))) { interfaceVars.insert(entry.second); } } this->writeCapabilities(out); this->writeInstruction(SpvOpExtInstImport, fGLSLExtendedInstructions, "GLSL.std.450", out); this->writeInstruction(SpvOpMemoryModel, SpvAddressingModelLogical, SpvMemoryModelGLSL450, out); this->writeOpCode(SpvOpEntryPoint, (SpvId) (3 + (main->fName.fLength + 4) / 4) + (int32_t) interfaceVars.size(), out); switch (program.fKind) { case Program::kVertex_Kind: this->writeWord(SpvExecutionModelVertex, out); break; case Program::kFragment_Kind: this->writeWord(SpvExecutionModelFragment, out); break; case Program::kGeometry_Kind: this->writeWord(SpvExecutionModelGeometry, out); break; default: ABORT("cannot write this kind of program to SPIR-V\n"); } SpvId entryPoint = fFunctionMap[main]; this->writeWord(entryPoint, out); this->writeString(main->fName.fChars, main->fName.fLength, out); for (int var : interfaceVars) { this->writeWord(var, out); } if (program.fKind == Program::kGeometry_Kind) { this->writeGeometryShaderExecutionMode(entryPoint, out); } if (program.fKind == Program::kFragment_Kind) { this->writeInstruction(SpvOpExecutionMode, fFunctionMap[main], SpvExecutionModeOriginUpperLeft, out); } for (const auto& e : program) { if (e.fKind == ProgramElement::kExtension_Kind) { this->writeInstruction(SpvOpSourceExtension, ((Extension&) e).fName.c_str(), out); } } write_stringstream(fExtraGlobalsBuffer, out); write_stringstream(fNameBuffer, out); write_stringstream(fDecorationBuffer, out); write_stringstream(fConstantBuffer, out); write_stringstream(fExternalFunctionsBuffer, out); write_stringstream(body, out); } bool SPIRVCodeGenerator::generateCode() { SkASSERT(!fErrors.errorCount()); this->writeWord(SpvMagicNumber, *fOut); this->writeWord(SpvVersion, *fOut); this->writeWord(SKSL_MAGIC, *fOut); StringStream buffer; this->writeInstructions(fProgram, buffer); this->writeWord(fIdCount, *fOut); this->writeWord(0, *fOut); // reserved, always zero write_stringstream(buffer, *fOut); return 0 == fErrors.errorCount(); } }