| /* |
| * 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/SkSLCompiler.h" |
| |
| #include <memory> |
| #include <unordered_set> |
| |
| #include "src/core/SkScopeExit.h" |
| #include "src/core/SkTraceEvent.h" |
| #include "src/sksl/SkSLAnalysis.h" |
| #include "src/sksl/SkSLCFGGenerator.h" |
| #include "src/sksl/SkSLCPPCodeGenerator.h" |
| #include "src/sksl/SkSLGLSLCodeGenerator.h" |
| #include "src/sksl/SkSLHCodeGenerator.h" |
| #include "src/sksl/SkSLIRGenerator.h" |
| #include "src/sksl/SkSLMetalCodeGenerator.h" |
| #include "src/sksl/SkSLOperators.h" |
| #include "src/sksl/SkSLProgramSettings.h" |
| #include "src/sksl/SkSLRehydrator.h" |
| #include "src/sksl/SkSLSPIRVCodeGenerator.h" |
| #include "src/sksl/SkSLSPIRVtoHLSL.h" |
| #include "src/sksl/ir/SkSLEnum.h" |
| #include "src/sksl/ir/SkSLExpression.h" |
| #include "src/sksl/ir/SkSLExpressionStatement.h" |
| #include "src/sksl/ir/SkSLFunctionCall.h" |
| #include "src/sksl/ir/SkSLIntLiteral.h" |
| #include "src/sksl/ir/SkSLModifiersDeclaration.h" |
| #include "src/sksl/ir/SkSLNop.h" |
| #include "src/sksl/ir/SkSLSymbolTable.h" |
| #include "src/sksl/ir/SkSLTernaryExpression.h" |
| #include "src/sksl/ir/SkSLUnresolvedFunction.h" |
| #include "src/sksl/ir/SkSLVarDeclarations.h" |
| #include "src/utils/SkBitSet.h" |
| |
| #include <fstream> |
| |
| #if !defined(SKSL_STANDALONE) & SK_SUPPORT_GPU |
| #include "include/gpu/GrContextOptions.h" |
| #include "src/gpu/GrShaderCaps.h" |
| #endif |
| |
| #ifdef SK_ENABLE_SPIRV_VALIDATION |
| #include "spirv-tools/libspirv.hpp" |
| #endif |
| |
| #if defined(SKSL_STANDALONE) |
| |
| // In standalone mode, we load the textual sksl source files. GN generates or copies these files |
| // to the skslc executable directory. The "data" in this mode is just the filename. |
| #define MODULE_DATA(name) MakeModulePath("sksl_" #name ".sksl") |
| |
| #else |
| |
| // At runtime, we load the dehydrated sksl data files. The data is a (pointer, size) pair. |
| #include "src/sksl/generated/sksl_fp.dehydrated.sksl" |
| #include "src/sksl/generated/sksl_frag.dehydrated.sksl" |
| #include "src/sksl/generated/sksl_geom.dehydrated.sksl" |
| #include "src/sksl/generated/sksl_gpu.dehydrated.sksl" |
| #include "src/sksl/generated/sksl_public.dehydrated.sksl" |
| #include "src/sksl/generated/sksl_runtime.dehydrated.sksl" |
| #include "src/sksl/generated/sksl_vert.dehydrated.sksl" |
| |
| #define MODULE_DATA(name) MakeModuleData(SKSL_INCLUDE_sksl_##name,\ |
| SKSL_INCLUDE_sksl_##name##_LENGTH) |
| |
| #endif |
| |
| namespace SkSL { |
| |
| // Set these flags to `false` to disable optimization passes unilaterally. |
| // These flags allow tools like Viewer or Nanobench to override the compiler's ProgramSettings. |
| bool gSkSLOptimizer = true; |
| bool gSkSLInliner = true; |
| bool gSkSLControlFlowAnalysis = false; |
| |
| using RefKind = VariableReference::RefKind; |
| |
| class AutoSource { |
| public: |
| AutoSource(Compiler* compiler, const String* source) |
| : fCompiler(compiler), fOldSource(fCompiler->fSource) { |
| fCompiler->fSource = source; |
| } |
| |
| ~AutoSource() { fCompiler->fSource = fOldSource; } |
| |
| Compiler* fCompiler; |
| const String* fOldSource; |
| }; |
| |
| class AutoProgramConfig { |
| public: |
| AutoProgramConfig(std::shared_ptr<Context>& context, ProgramConfig* config) |
| : fContext(context.get()) { |
| SkASSERT(!fContext->fConfig); |
| fContext->fConfig = config; |
| } |
| |
| ~AutoProgramConfig() { |
| fContext->fConfig = nullptr; |
| } |
| |
| Context* fContext; |
| }; |
| |
| Compiler::Compiler(const ShaderCapsClass* caps) |
| : fContext(std::make_shared<Context>(/*errors=*/*this, *caps)) |
| , fInliner(fContext.get()) |
| , fErrorCount(0) { |
| SkASSERT(caps); |
| fRootSymbolTable = std::make_shared<SymbolTable>(this, /*builtin=*/true); |
| fPrivateSymbolTable = std::make_shared<SymbolTable>(fRootSymbolTable, /*builtin=*/true); |
| fIRGenerator = std::make_unique<IRGenerator>(fContext.get()); |
| |
| #define TYPE(t) fContext->fTypes.f ## t .get() |
| |
| const SkSL::Symbol* rootTypes[] = { |
| TYPE(Void), |
| |
| TYPE( Float), TYPE( Float2), TYPE( Float3), TYPE( Float4), |
| TYPE( Half), TYPE( Half2), TYPE( Half3), TYPE( Half4), |
| TYPE( Int), TYPE( Int2), TYPE( Int3), TYPE( Int4), |
| TYPE( Bool), TYPE( Bool2), TYPE( Bool3), TYPE( Bool4), |
| |
| TYPE(Float2x2), TYPE(Float3x3), TYPE(Float4x4), |
| TYPE( Half2x2), TYPE( Half3x3), TYPE(Half4x4), |
| |
| TYPE(SquareMat), TYPE(SquareHMat), |
| |
| TYPE(GenType), TYPE(GenHType), TYPE(GenIType), TYPE(GenBType), |
| TYPE(Vec), TYPE(HVec), TYPE(IVec), TYPE(BVec), |
| |
| TYPE(FragmentProcessor), |
| }; |
| |
| const SkSL::Symbol* privateTypes[] = { |
| TYPE( UInt), TYPE( UInt2), TYPE( UInt3), TYPE( UInt4), |
| TYPE( Short), TYPE( Short2), TYPE( Short3), TYPE( Short4), |
| TYPE(UShort), TYPE(UShort2), TYPE(UShort3), TYPE(UShort4), |
| TYPE( Byte), TYPE( Byte2), TYPE( Byte3), TYPE( Byte4), |
| TYPE( UByte), TYPE( UByte2), TYPE( UByte3), TYPE( UByte4), |
| |
| TYPE(GenUType), TYPE(UVec), |
| TYPE(SVec), TYPE(USVec), TYPE(ByteVec), TYPE(UByteVec), |
| |
| TYPE(Float2x3), TYPE(Float2x4), |
| TYPE(Float3x2), TYPE(Float3x4), |
| TYPE(Float4x2), TYPE(Float4x3), |
| |
| TYPE(Half2x3), TYPE(Half2x4), |
| TYPE(Half3x2), TYPE(Half3x4), |
| TYPE(Half4x2), TYPE(Half4x3), |
| |
| TYPE(Mat), TYPE(HMat), |
| |
| TYPE(Sampler1D), TYPE(Sampler2D), TYPE(Sampler3D), |
| TYPE(SamplerExternalOES), |
| TYPE(Sampler2DRect), |
| |
| TYPE(ISampler2D), |
| TYPE(SubpassInput), TYPE(SubpassInputMS), |
| |
| TYPE(Sampler), |
| TYPE(Texture2D), |
| }; |
| |
| for (const SkSL::Symbol* type : rootTypes) { |
| fRootSymbolTable->addWithoutOwnership(type); |
| } |
| for (const SkSL::Symbol* type : privateTypes) { |
| fPrivateSymbolTable->addWithoutOwnership(type); |
| } |
| |
| #undef TYPE |
| |
| // sk_Caps is "builtin", but all references to it are resolved to Settings, so we don't need to |
| // treat it as builtin (ie, no need to clone it into the Program). |
| fPrivateSymbolTable->add( |
| std::make_unique<Variable>(/*offset=*/-1, |
| fIRGenerator->fModifiers->addToPool(Modifiers()), |
| "sk_Caps", |
| fContext->fTypes.fSkCaps.get(), |
| /*builtin=*/false, |
| Variable::Storage::kGlobal)); |
| |
| fRootModule = {fRootSymbolTable, /*fIntrinsics=*/nullptr}; |
| fPrivateModule = {fPrivateSymbolTable, /*fIntrinsics=*/nullptr}; |
| } |
| |
| Compiler::~Compiler() {} |
| |
| const ParsedModule& Compiler::loadGPUModule() { |
| if (!fGPUModule.fSymbols) { |
| fGPUModule = this->parseModule(ProgramKind::kFragment, MODULE_DATA(gpu), fPrivateModule); |
| } |
| return fGPUModule; |
| } |
| |
| const ParsedModule& Compiler::loadFragmentModule() { |
| if (!fFragmentModule.fSymbols) { |
| fFragmentModule = this->parseModule(ProgramKind::kFragment, MODULE_DATA(frag), |
| this->loadGPUModule()); |
| } |
| return fFragmentModule; |
| } |
| |
| const ParsedModule& Compiler::loadVertexModule() { |
| if (!fVertexModule.fSymbols) { |
| fVertexModule = this->parseModule(ProgramKind::kVertex, MODULE_DATA(vert), |
| this->loadGPUModule()); |
| } |
| return fVertexModule; |
| } |
| |
| const ParsedModule& Compiler::loadGeometryModule() { |
| if (!fGeometryModule.fSymbols) { |
| fGeometryModule = this->parseModule(ProgramKind::kGeometry, MODULE_DATA(geom), |
| this->loadGPUModule()); |
| } |
| return fGeometryModule; |
| } |
| |
| const ParsedModule& Compiler::loadFPModule() { |
| if (!fFPModule.fSymbols) { |
| fFPModule = this->parseModule(ProgramKind::kFragmentProcessor, MODULE_DATA(fp), |
| this->loadGPUModule()); |
| } |
| return fFPModule; |
| } |
| |
| const ParsedModule& Compiler::loadPublicModule() { |
| if (!fPublicModule.fSymbols) { |
| fPublicModule = this->parseModule(ProgramKind::kGeneric, MODULE_DATA(public), fRootModule); |
| } |
| return fPublicModule; |
| } |
| |
| const ParsedModule& Compiler::loadRuntimeEffectModule() { |
| if (!fRuntimeEffectModule.fSymbols) { |
| fRuntimeEffectModule = this->parseModule(ProgramKind::kRuntimeEffect, MODULE_DATA(runtime), |
| this->loadPublicModule()); |
| |
| // Add some aliases to the runtime effect module so that it's friendlier, and more like GLSL |
| fRuntimeEffectModule.fSymbols->addAlias("shader", fContext->fTypes.fFragmentProcessor.get()); |
| |
| fRuntimeEffectModule.fSymbols->addAlias("vec2", fContext->fTypes.fFloat2.get()); |
| fRuntimeEffectModule.fSymbols->addAlias("vec3", fContext->fTypes.fFloat3.get()); |
| fRuntimeEffectModule.fSymbols->addAlias("vec4", fContext->fTypes.fFloat4.get()); |
| |
| fRuntimeEffectModule.fSymbols->addAlias("bvec2", fContext->fTypes.fBool2.get()); |
| fRuntimeEffectModule.fSymbols->addAlias("bvec3", fContext->fTypes.fBool3.get()); |
| fRuntimeEffectModule.fSymbols->addAlias("bvec4", fContext->fTypes.fBool4.get()); |
| |
| fRuntimeEffectModule.fSymbols->addAlias("mat2", fContext->fTypes.fFloat2x2.get()); |
| fRuntimeEffectModule.fSymbols->addAlias("mat3", fContext->fTypes.fFloat3x3.get()); |
| fRuntimeEffectModule.fSymbols->addAlias("mat4", fContext->fTypes.fFloat4x4.get()); |
| } |
| return fRuntimeEffectModule; |
| } |
| |
| const ParsedModule& Compiler::moduleForProgramKind(ProgramKind kind) { |
| switch (kind) { |
| case ProgramKind::kVertex: return this->loadVertexModule(); break; |
| case ProgramKind::kFragment: return this->loadFragmentModule(); break; |
| case ProgramKind::kGeometry: return this->loadGeometryModule(); break; |
| case ProgramKind::kFragmentProcessor: return this->loadFPModule(); break; |
| case ProgramKind::kRuntimeEffect: return this->loadRuntimeEffectModule(); break; |
| case ProgramKind::kGeneric: return this->loadPublicModule(); break; |
| } |
| SkUNREACHABLE; |
| } |
| |
| LoadedModule Compiler::loadModule(ProgramKind kind, |
| ModuleData data, |
| std::shared_ptr<SymbolTable> base, |
| bool dehydrate) { |
| if (dehydrate) { |
| // NOTE: This is a workaround. When dehydrating includes, skslc doesn't know which module |
| // it's preparing, nor what the correct base module is. We can't use 'Root', because many |
| // GPU intrinsics reference private types, like samplers or textures. Today, 'Private' does |
| // contain the union of all known types, so this is safe. If we ever have types that only |
| // exist in 'Public' (for example), this logic needs to be smarter (by choosing the correct |
| // base for the module we're compiling). |
| base = fPrivateSymbolTable; |
| } |
| SkASSERT(base); |
| |
| // Built-in modules always use default program settings. |
| ProgramConfig config; |
| config.fKind = kind; |
| config.fSettings.fReplaceSettings = !dehydrate; |
| AutoProgramConfig autoConfig(fContext, &config); |
| |
| #if defined(SKSL_STANDALONE) |
| SkASSERT(data.fPath); |
| std::ifstream in(data.fPath); |
| std::unique_ptr<String> text = std::make_unique<String>(std::istreambuf_iterator<char>(in), |
| std::istreambuf_iterator<char>()); |
| if (in.rdstate()) { |
| printf("error reading %s\n", data.fPath); |
| abort(); |
| } |
| const String* source = fRootSymbolTable->takeOwnershipOfString(std::move(text)); |
| AutoSource as(this, source); |
| |
| SkASSERT(fIRGenerator->fCanInline); |
| fIRGenerator->fCanInline = false; |
| |
| ParsedModule baseModule = {base, /*fIntrinsics=*/nullptr}; |
| IRGenerator::IRBundle ir = fIRGenerator->convertProgram(baseModule, /*isBuiltinCode=*/true, |
| source->c_str(), source->length(), |
| /*externalFunctions=*/nullptr); |
| SkASSERT(ir.fSharedElements.empty()); |
| LoadedModule module = { kind, std::move(ir.fSymbolTable), std::move(ir.fElements) }; |
| fIRGenerator->fCanInline = true; |
| if (this->fErrorCount) { |
| printf("Unexpected errors: %s\n", this->fErrorText.c_str()); |
| SkDEBUGFAILF("%s %s\n", data.fPath, this->fErrorText.c_str()); |
| } |
| fModifiers.push_back(std::move(ir.fModifiers)); |
| #else |
| SkASSERT(data.fData && (data.fSize != 0)); |
| Rehydrator rehydrator(fContext.get(), fIRGenerator->fModifiers.get(), base, this, |
| data.fData, data.fSize); |
| LoadedModule module = { kind, rehydrator.symbolTable(), rehydrator.elements() }; |
| fModifiers.push_back(fIRGenerator->releaseModifiers()); |
| #endif |
| |
| return module; |
| } |
| |
| ParsedModule Compiler::parseModule(ProgramKind kind, ModuleData data, const ParsedModule& base) { |
| LoadedModule module = this->loadModule(kind, data, base.fSymbols, /*dehydrate=*/false); |
| this->optimize(module); |
| |
| // For modules that just declare (but don't define) intrinsic functions, there will be no new |
| // program elements. In that case, we can share our parent's intrinsic map: |
| if (module.fElements.empty()) { |
| return {module.fSymbols, base.fIntrinsics}; |
| } |
| |
| auto intrinsics = std::make_shared<IRIntrinsicMap>(base.fIntrinsics.get()); |
| |
| // Now, transfer all of the program elements to an intrinsic map. This maps certain types of |
| // global objects to the declaring ProgramElement. |
| for (std::unique_ptr<ProgramElement>& element : module.fElements) { |
| switch (element->kind()) { |
| case ProgramElement::Kind::kFunction: { |
| const FunctionDefinition& f = element->as<FunctionDefinition>(); |
| SkASSERT(f.declaration().isBuiltin()); |
| intrinsics->insertOrDie(f.declaration().description(), std::move(element)); |
| break; |
| } |
| case ProgramElement::Kind::kFunctionPrototype: { |
| // These are already in the symbol table. |
| break; |
| } |
| case ProgramElement::Kind::kEnum: { |
| const Enum& e = element->as<Enum>(); |
| SkASSERT(e.isBuiltin()); |
| intrinsics->insertOrDie(e.typeName(), std::move(element)); |
| break; |
| } |
| case ProgramElement::Kind::kGlobalVar: { |
| const GlobalVarDeclaration& global = element->as<GlobalVarDeclaration>(); |
| const Variable& var = global.declaration()->as<VarDeclaration>().var(); |
| SkASSERT(var.isBuiltin()); |
| intrinsics->insertOrDie(var.name(), std::move(element)); |
| break; |
| } |
| case ProgramElement::Kind::kInterfaceBlock: { |
| const Variable& var = element->as<InterfaceBlock>().variable(); |
| SkASSERT(var.isBuiltin()); |
| intrinsics->insertOrDie(var.name(), std::move(element)); |
| break; |
| } |
| default: |
| printf("Unsupported element: %s\n", element->description().c_str()); |
| SkASSERT(false); |
| break; |
| } |
| } |
| |
| return {module.fSymbols, std::move(intrinsics)}; |
| } |
| |
| void Compiler::scanCFG(CFG* cfg, BlockId blockId, SkBitSet* processedSet) { |
| BasicBlock& block = cfg->fBlocks[blockId]; |
| |
| // compute definitions after this block |
| DefinitionMap after = block.fBefore; |
| for (const BasicBlock::Node& n : block.fNodes) { |
| after.addDefinitions(*fContext, n); |
| } |
| |
| // propagate definitions to exits |
| for (BlockId exitId : block.fExits) { |
| if (exitId == blockId) { |
| continue; |
| } |
| BasicBlock& exit = cfg->fBlocks[exitId]; |
| for (const auto& [var, e1] : after) { |
| std::unique_ptr<Expression>** exitDef = exit.fBefore.find(var); |
| if (!exitDef) { |
| // exit has no definition for it, just copy it and reprocess exit block |
| processedSet->reset(exitId); |
| exit.fBefore.set(var, e1); |
| } else { |
| // exit has a (possibly different) value already defined |
| std::unique_ptr<Expression>* e2 = *exitDef; |
| if (e1 != e2) { |
| // definition has changed, merge and reprocess the exit block |
| processedSet->reset(exitId); |
| if (e1 && e2) { |
| *exitDef = (std::unique_ptr<Expression>*)&fContext->fDefined_Expression; |
| } else { |
| *exitDef = nullptr; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns true if assigning to this lvalue has no effect. |
| */ |
| static bool is_dead(const Expression& lvalue, ProgramUsage* usage) { |
| switch (lvalue.kind()) { |
| case Expression::Kind::kVariableReference: |
| return usage->isDead(*lvalue.as<VariableReference>().variable()); |
| case Expression::Kind::kSwizzle: |
| return is_dead(*lvalue.as<Swizzle>().base(), usage); |
| case Expression::Kind::kFieldAccess: |
| return is_dead(*lvalue.as<FieldAccess>().base(), usage); |
| case Expression::Kind::kIndex: { |
| const IndexExpression& idx = lvalue.as<IndexExpression>(); |
| return is_dead(*idx.base(), usage) && |
| !idx.index()->hasProperty(Expression::Property::kSideEffects); |
| } |
| case Expression::Kind::kTernary: { |
| const TernaryExpression& t = lvalue.as<TernaryExpression>(); |
| return !t.test()->hasSideEffects() && |
| is_dead(*t.ifTrue(), usage) && |
| is_dead(*t.ifFalse(), usage); |
| } |
| default: |
| SkDEBUGFAILF("invalid lvalue: %s\n", lvalue.description().c_str()); |
| return false; |
| } |
| } |
| |
| /** |
| * Returns true if this is an assignment which can be collapsed down to just the right hand side due |
| * to a dead target and lack of side effects on the left hand side. |
| */ |
| static bool dead_assignment(const BinaryExpression& b, ProgramUsage* usage) { |
| if (!b.getOperator().isAssignment()) { |
| return false; |
| } |
| return is_dead(*b.left(), usage); |
| } |
| |
| static bool self_assignment(const BinaryExpression& b) { |
| return b.getOperator().kind() == Token::Kind::TK_EQ && |
| Analysis::IsSelfAssignment(*b.left(), *b.right()); |
| } |
| |
| void Compiler::computeDataFlow(CFG* cfg) { |
| cfg->fBlocks[cfg->fStart].fBefore.computeStartState(*cfg); |
| |
| // We set bits in the "processed" set after a block has been scanned. |
| SkBitSet processedSet(cfg->fBlocks.size()); |
| while (SkBitSet::OptionalIndex blockId = processedSet.findFirstUnset()) { |
| processedSet.set(*blockId); |
| this->scanCFG(cfg, *blockId, &processedSet); |
| } |
| } |
| |
| /** |
| * Attempts to replace the expression pointed to by iter with a new one (in both the CFG and the |
| * IR). If the expression can be cleanly removed, returns true and updates the iterator to point to |
| * the newly-inserted element. Otherwise updates only the IR and returns false (and the CFG will |
| * need to be regenerated). |
| */ |
| static bool try_replace_expression(BasicBlock* b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| std::unique_ptr<Expression>* newExpression) { |
| std::unique_ptr<Expression>* target = (*iter)->expression(); |
| if (!b->tryRemoveExpression(iter)) { |
| *target = std::move(*newExpression); |
| return false; |
| } |
| *target = std::move(*newExpression); |
| return b->tryInsertExpression(iter, target); |
| } |
| |
| /** |
| * Returns true if the expression is a constant numeric literal with the specified value, or a |
| * constant vector with all elements equal to the specified value. |
| */ |
| template <typename T = SKSL_FLOAT> |
| static bool is_constant(const Expression& expr, T value) { |
| switch (expr.kind()) { |
| case Expression::Kind::kIntLiteral: |
| return expr.as<IntLiteral>().value() == value; |
| |
| case Expression::Kind::kFloatLiteral: |
| return expr.as<FloatLiteral>().value() == value; |
| |
| case Expression::Kind::kConstructor: { |
| const Constructor& constructor = expr.as<Constructor>(); |
| if (constructor.isCompileTimeConstant()) { |
| const Type& constructorType = constructor.type(); |
| switch (constructorType.typeKind()) { |
| case Type::TypeKind::kVector: |
| if (constructor.componentType().isFloat()) { |
| for (int i = 0; i < constructorType.columns(); ++i) { |
| if (constructor.getFVecComponent(i) != value) { |
| return false; |
| } |
| } |
| return true; |
| } else if (constructor.componentType().isInteger()) { |
| for (int i = 0; i < constructorType.columns(); ++i) { |
| if (constructor.getIVecComponent(i) != value) { |
| return false; |
| } |
| } |
| return true; |
| } |
| // Other types (e.g. boolean) might occur, but aren't supported here. |
| return false; |
| |
| case Type::TypeKind::kScalar: |
| SkASSERT(constructor.arguments().size() == 1); |
| return is_constant<T>(*constructor.arguments()[0], value); |
| |
| default: |
| return false; |
| } |
| } |
| return false; |
| } |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Collapses the binary expression pointed to by iter down to just the right side (in both the IR |
| * and CFG structures). |
| */ |
| static void delete_left(BasicBlock* b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| Compiler::OptimizationContext* optimizationContext) { |
| optimizationContext->fUpdated = true; |
| std::unique_ptr<Expression>* target = (*iter)->expression(); |
| BinaryExpression& bin = (*target)->as<BinaryExpression>(); |
| Expression& left = *bin.left(); |
| std::unique_ptr<Expression>& rightPointer = bin.right(); |
| SkASSERT(!left.hasSideEffects()); |
| bool result; |
| if (bin.getOperator().kind() == Token::Kind::TK_EQ) { |
| result = b->tryRemoveLValueBefore(iter, &left); |
| } else { |
| result = b->tryRemoveExpressionBefore(iter, &left); |
| } |
| // Remove references within LHS. |
| optimizationContext->fUsage->remove(&left); |
| *target = std::move(rightPointer); |
| if (!result) { |
| optimizationContext->fNeedsRescan = true; |
| return; |
| } |
| if (*iter == b->fNodes.begin()) { |
| optimizationContext->fNeedsRescan = true; |
| return; |
| } |
| --(*iter); |
| if (!(*iter)->isExpression() || (*iter)->expression() != &rightPointer) { |
| optimizationContext->fNeedsRescan = true; |
| return; |
| } |
| *iter = b->fNodes.erase(*iter); |
| SkASSERT((*iter)->expression() == target); |
| } |
| |
| /** |
| * Collapses the binary expression pointed to by iter down to just the left side (in both the IR and |
| * CFG structures). |
| */ |
| static void delete_right(BasicBlock* b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| Compiler::OptimizationContext* optimizationContext) { |
| optimizationContext->fUpdated = true; |
| std::unique_ptr<Expression>* target = (*iter)->expression(); |
| BinaryExpression& bin = (*target)->as<BinaryExpression>(); |
| std::unique_ptr<Expression>& leftPointer = bin.left(); |
| Expression& right = *bin.right(); |
| SkASSERT(!right.hasSideEffects()); |
| // Remove references within RHS. |
| optimizationContext->fUsage->remove(&right); |
| if (!b->tryRemoveExpressionBefore(iter, &right)) { |
| *target = std::move(leftPointer); |
| optimizationContext->fNeedsRescan = true; |
| return; |
| } |
| *target = std::move(leftPointer); |
| if (*iter == b->fNodes.begin()) { |
| optimizationContext->fNeedsRescan = true; |
| return; |
| } |
| --(*iter); |
| if ((!(*iter)->isExpression() || (*iter)->expression() != &leftPointer)) { |
| optimizationContext->fNeedsRescan = true; |
| return; |
| } |
| *iter = b->fNodes.erase(*iter); |
| SkASSERT((*iter)->expression() == target); |
| } |
| |
| /** |
| * Constructs the specified type using a single argument. |
| */ |
| static std::unique_ptr<Expression> construct(const Type* type, std::unique_ptr<Expression> v) { |
| ExpressionArray args; |
| args.push_back(std::move(v)); |
| return std::make_unique<Constructor>(/*offset=*/-1, *type, std::move(args)); |
| } |
| |
| /** |
| * Used in the implementations of vectorize_left and vectorize_right. Given a vector type and an |
| * expression x, deletes the expression pointed to by iter and replaces it with <type>(x). |
| */ |
| static void vectorize(BasicBlock* b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| const Type& type, |
| std::unique_ptr<Expression>* otherExpression, |
| Compiler::OptimizationContext* optimizationContext) { |
| SkASSERT((*(*iter)->expression())->kind() == Expression::Kind::kBinary); |
| SkASSERT(type.isVector()); |
| SkASSERT((*otherExpression)->type().isScalar()); |
| optimizationContext->fUpdated = true; |
| std::unique_ptr<Expression>* target = (*iter)->expression(); |
| if (!b->tryRemoveExpression(iter)) { |
| *target = construct(&type, std::move(*otherExpression)); |
| optimizationContext->fNeedsRescan = true; |
| } else { |
| *target = construct(&type, std::move(*otherExpression)); |
| if (!b->tryInsertExpression(iter, target)) { |
| optimizationContext->fNeedsRescan = true; |
| } |
| } |
| } |
| |
| /** |
| * Given a binary expression of the form x <op> vec<n>(y), deletes the right side and vectorizes the |
| * left to yield vec<n>(x). |
| */ |
| static void vectorize_left(BasicBlock* b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| Compiler::OptimizationContext* optimizationContext) { |
| BinaryExpression& bin = (*(*iter)->expression())->as<BinaryExpression>(); |
| // Remove references within RHS. Vectorization of LHS doesn't change reference counts. |
| optimizationContext->fUsage->remove(bin.right().get()); |
| vectorize(b, iter, bin.right()->type(), &bin.left(), optimizationContext); |
| } |
| |
| /** |
| * Given a binary expression of the form vec<n>(x) <op> y, deletes the left side and vectorizes the |
| * right to yield vec<n>(y). |
| */ |
| static void vectorize_right(BasicBlock* b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| Compiler::OptimizationContext* optimizationContext) { |
| BinaryExpression& bin = (*(*iter)->expression())->as<BinaryExpression>(); |
| // Remove references within LHS. Vectorization of RHS doesn't change reference counts. |
| optimizationContext->fUsage->remove(bin.left().get()); |
| vectorize(b, iter, bin.left()->type(), &bin.right(), optimizationContext); |
| } |
| |
| void Compiler::simplifyExpression(DefinitionMap& definitions, |
| BasicBlock& b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| OptimizationContext* optimizationContext) { |
| Expression* expr = (*iter)->expression()->get(); |
| SkASSERT(expr); |
| |
| if ((*iter)->fConstantPropagation) { |
| std::unique_ptr<Expression> optimized = expr->constantPropagate(*fIRGenerator, |
| definitions); |
| if (optimized) { |
| optimizationContext->fUpdated = true; |
| optimized = fIRGenerator->coerce(std::move(optimized), expr->type()); |
| SkASSERT(optimized); |
| // Remove references within 'expr', add references within 'optimized' |
| optimizationContext->fUsage->replace(expr, optimized.get()); |
| if (!try_replace_expression(&b, iter, &optimized)) { |
| optimizationContext->fNeedsRescan = true; |
| return; |
| } |
| SkASSERT((*iter)->isExpression()); |
| expr = (*iter)->expression()->get(); |
| } |
| } |
| switch (expr->kind()) { |
| case Expression::Kind::kVariableReference: { |
| const VariableReference& ref = expr->as<VariableReference>(); |
| const Variable* var = ref.variable(); |
| if (fContext->fConfig->fSettings.fDeadCodeElimination && |
| ref.refKind() != VariableReference::RefKind::kWrite && |
| ref.refKind() != VariableReference::RefKind::kPointer && |
| var->storage() == Variable::Storage::kLocal && !definitions.get(var) && |
| optimizationContext->fSilences.find(var) == optimizationContext->fSilences.end()) { |
| optimizationContext->fSilences.insert(var); |
| this->error(expr->fOffset, |
| "'" + var->name() + "' has not been assigned"); |
| } |
| break; |
| } |
| case Expression::Kind::kTernary: { |
| // TODO(skia:11319): this optimization logic is redundant with the optimization code |
| // found in SkSLTernaryExpression.cpp. |
| |
| TernaryExpression* t = &expr->as<TernaryExpression>(); |
| if (t->test()->is<BoolLiteral>()) { |
| // ternary has a constant test, replace it with either the true or |
| // false branch |
| if (t->test()->as<BoolLiteral>().value()) { |
| (*iter)->setExpression(std::move(t->ifTrue()), optimizationContext->fUsage); |
| } else { |
| (*iter)->setExpression(std::move(t->ifFalse()), optimizationContext->fUsage); |
| } |
| optimizationContext->fUpdated = true; |
| optimizationContext->fNeedsRescan = true; |
| } |
| break; |
| } |
| case Expression::Kind::kBinary: { |
| BinaryExpression* bin = &expr->as<BinaryExpression>(); |
| if (dead_assignment(*bin, optimizationContext->fUsage) || self_assignment(*bin)) { |
| delete_left(&b, iter, optimizationContext); |
| break; |
| } |
| |
| // TODO(skia:11319): this optimization logic is redundant with the optimization code |
| // found in ConstantFolder.cpp. |
| Expression& left = *bin->left(); |
| Expression& right = *bin->right(); |
| const Type& leftType = left.type(); |
| const Type& rightType = right.type(); |
| // collapse useless expressions like x * 1 or x + 0 |
| if ((!leftType.isScalar() && !leftType.isVector()) || |
| (!rightType.isScalar() && !rightType.isVector())) { |
| break; |
| } |
| switch (bin->getOperator().kind()) { |
| case Token::Kind::TK_STAR: |
| if (is_constant(left, 1)) { |
| if (leftType.isVector() && rightType.isScalar()) { |
| // float4(1) * x -> float4(x) |
| vectorize_right(&b, iter, optimizationContext); |
| } else { |
| // 1 * x -> x |
| // 1 * float4(x) -> float4(x) |
| // float4(1) * float4(x) -> float4(x) |
| delete_left(&b, iter, optimizationContext); |
| } |
| } |
| else if (is_constant(left, 0)) { |
| if (leftType.isScalar() && rightType.isVector() && |
| !right.hasSideEffects()) { |
| // 0 * float4(x) -> float4(0) |
| vectorize_left(&b, iter, optimizationContext); |
| } else { |
| // 0 * x -> 0 |
| // float4(0) * x -> float4(0) |
| // float4(0) * float4(x) -> float4(0) |
| if (!right.hasSideEffects()) { |
| delete_right(&b, iter, optimizationContext); |
| } |
| } |
| } |
| else if (is_constant(right, 1)) { |
| if (leftType.isScalar() && rightType.isVector()) { |
| // x * float4(1) -> float4(x) |
| vectorize_left(&b, iter, optimizationContext); |
| } else { |
| // x * 1 -> x |
| // float4(x) * 1 -> float4(x) |
| // float4(x) * float4(1) -> float4(x) |
| delete_right(&b, iter, optimizationContext); |
| } |
| } |
| else if (is_constant(right, 0)) { |
| if (leftType.isVector() && rightType.isScalar() && !left.hasSideEffects()) { |
| // float4(x) * 0 -> float4(0) |
| vectorize_right(&b, iter, optimizationContext); |
| } else { |
| // x * 0 -> 0 |
| // x * float4(0) -> float4(0) |
| // float4(x) * float4(0) -> float4(0) |
| if (!left.hasSideEffects()) { |
| delete_left(&b, iter, optimizationContext); |
| } |
| } |
| } |
| break; |
| case Token::Kind::TK_PLUS: |
| if (is_constant(left, 0)) { |
| if (leftType.isVector() && rightType.isScalar()) { |
| // float4(0) + x -> float4(x) |
| vectorize_right(&b, iter, optimizationContext); |
| } else { |
| // 0 + x -> x |
| // 0 + float4(x) -> float4(x) |
| // float4(0) + float4(x) -> float4(x) |
| delete_left(&b, iter, optimizationContext); |
| } |
| } else if (is_constant(right, 0)) { |
| if (leftType.isScalar() && rightType.isVector()) { |
| // x + float4(0) -> float4(x) |
| vectorize_left(&b, iter, optimizationContext); |
| } else { |
| // x + 0 -> x |
| // float4(x) + 0 -> float4(x) |
| // float4(x) + float4(0) -> float4(x) |
| delete_right(&b, iter, optimizationContext); |
| } |
| } |
| break; |
| case Token::Kind::TK_MINUS: |
| if (is_constant(right, 0)) { |
| if (leftType.isScalar() && rightType.isVector()) { |
| // x - float4(0) -> float4(x) |
| vectorize_left(&b, iter, optimizationContext); |
| } else { |
| // x - 0 -> x |
| // float4(x) - 0 -> float4(x) |
| // float4(x) - float4(0) -> float4(x) |
| delete_right(&b, iter, optimizationContext); |
| } |
| } |
| break; |
| case Token::Kind::TK_SLASH: |
| if (is_constant(right, 1)) { |
| if (leftType.isScalar() && rightType.isVector()) { |
| // x / float4(1) -> float4(x) |
| vectorize_left(&b, iter, optimizationContext); |
| } else { |
| // x / 1 -> x |
| // float4(x) / 1 -> float4(x) |
| // float4(x) / float4(1) -> float4(x) |
| delete_right(&b, iter, optimizationContext); |
| } |
| } else if (is_constant(left, 0)) { |
| if (leftType.isScalar() && rightType.isVector() && |
| !right.hasSideEffects()) { |
| // 0 / float4(x) -> float4(0) |
| vectorize_left(&b, iter, optimizationContext); |
| } else { |
| // 0 / x -> 0 |
| // float4(0) / x -> float4(0) |
| // float4(0) / float4(x) -> float4(0) |
| if (!right.hasSideEffects()) { |
| delete_right(&b, iter, optimizationContext); |
| } |
| } |
| } |
| break; |
| case Token::Kind::TK_PLUSEQ: |
| if (is_constant(right, 0)) { |
| Analysis::UpdateRefKind(&left, RefKind::kRead); |
| delete_right(&b, iter, optimizationContext); |
| } |
| break; |
| case Token::Kind::TK_MINUSEQ: |
| if (is_constant(right, 0)) { |
| Analysis::UpdateRefKind(&left, RefKind::kRead); |
| delete_right(&b, iter, optimizationContext); |
| } |
| break; |
| case Token::Kind::TK_STAREQ: |
| if (is_constant(right, 1)) { |
| Analysis::UpdateRefKind(&left, RefKind::kRead); |
| delete_right(&b, iter, optimizationContext); |
| } |
| break; |
| case Token::Kind::TK_SLASHEQ: |
| if (is_constant(right, 1)) { |
| Analysis::UpdateRefKind(&left, RefKind::kRead); |
| delete_right(&b, iter, optimizationContext); |
| } |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| case Expression::Kind::kConstructor: { |
| // TODO(skia:11319): this optimization logic is redundant with the optimization code |
| // found in SkSLConstructor.cpp. |
| |
| // Find constructors embedded inside constructors and flatten them out where possible. |
| // - float4(float2(1, 2), 3, 4) --> float4(1, 2, 3, 4) |
| // - float4(w, float3(sin(x), cos(y), tan(z))) --> float4(w, sin(x), cos(y), tan(z)) |
| // Leave single-argument constructors alone, though. These might be casts or splats. |
| Constructor& c = expr->as<Constructor>(); |
| if (c.type().columns() > 1) { |
| // Inspect each constructor argument to see if it's a candidate for flattening. |
| // Remember matched arguments in a bitfield, "argsToOptimize". |
| int argsToOptimize = 0; |
| int currBit = 1; |
| for (const std::unique_ptr<Expression>& arg : c.arguments()) { |
| if (arg->is<Constructor>()) { |
| Constructor& inner = arg->as<Constructor>(); |
| if (inner.arguments().size() > 1 && |
| inner.type().componentType() == c.type().componentType()) { |
| argsToOptimize |= currBit; |
| } |
| } |
| currBit <<= 1; |
| } |
| if (argsToOptimize) { |
| // We found at least one argument that could be flattened out. Re-walk the |
| // constructor args and flatten the candidates we found during our initial pass. |
| ExpressionArray flattened; |
| flattened.reserve_back(c.type().columns()); |
| currBit = 1; |
| for (const std::unique_ptr<Expression>& arg : c.arguments()) { |
| if (argsToOptimize & currBit) { |
| Constructor& inner = arg->as<Constructor>(); |
| for (const std::unique_ptr<Expression>& innerArg : inner.arguments()) { |
| flattened.push_back(innerArg->clone()); |
| } |
| } else { |
| flattened.push_back(arg->clone()); |
| } |
| currBit <<= 1; |
| } |
| std::unique_ptr<Expression> replacement = std::make_unique<Constructor>( |
| c.fOffset, c.type(), std::move(flattened)); |
| // We're replacing an expression with a cloned version; we'll need a rescan. |
| // No fUsage change: `float2(float(x), y)` and `float2(x, y)` have equivalent |
| // reference counts. |
| try_replace_expression(&b, iter, &replacement); |
| optimizationContext->fUpdated = true; |
| optimizationContext->fNeedsRescan = true; |
| break; |
| } |
| } |
| break; |
| } |
| case Expression::Kind::kSwizzle: { |
| // TODO(skia:11319): this optimization logic is redundant with the optimization code |
| // found in SkSLSwizzle.cpp. |
| |
| Swizzle& s = expr->as<Swizzle>(); |
| // Detect identity swizzles like `foo.rgba`. |
| if ((int) s.components().size() == s.base()->type().columns()) { |
| bool identity = true; |
| for (int i = 0; i < (int) s.components().size(); ++i) { |
| if (s.components()[i] != i) { |
| identity = false; |
| break; |
| } |
| } |
| if (identity) { |
| optimizationContext->fUpdated = true; |
| // No fUsage change: foo.rgba and foo have equivalent reference counts |
| if (!try_replace_expression(&b, iter, &s.base())) { |
| optimizationContext->fNeedsRescan = true; |
| return; |
| } |
| SkASSERT((*iter)->isExpression()); |
| break; |
| } |
| } |
| // Detect swizzles of swizzles, e.g. replace `foo.argb.r000` with `foo.a000`. |
| if (s.base()->is<Swizzle>()) { |
| Swizzle& base = s.base()->as<Swizzle>(); |
| ComponentArray final; |
| for (int c : s.components()) { |
| final.push_back(base.components()[c]); |
| } |
| std::unique_ptr<Expression> replacement(new Swizzle(*fContext, base.base()->clone(), |
| final)); |
| // We're replacing an expression with a cloned version; we'll need a rescan. |
| // No fUsage change: `foo.gbr.gbr` and `foo.brg` have equivalent reference counts |
| try_replace_expression(&b, iter, &replacement); |
| optimizationContext->fUpdated = true; |
| optimizationContext->fNeedsRescan = true; |
| break; |
| } |
| // Optimize swizzles of constructors. |
| if (s.base()->is<Constructor>()) { |
| Constructor& base = s.base()->as<Constructor>(); |
| std::unique_ptr<Expression> replacement; |
| const Type& componentType = base.type().componentType(); |
| int swizzleSize = s.components().size(); |
| |
| // The IR generator has already converted any zero/one swizzle components into |
| // constructors containing zero/one args. Confirm that this is true by checking that |
| // our swizzle components are all `xyzw` (values 0 through 3). |
| SkASSERT(std::all_of(s.components().begin(), s.components().end(), |
| [](int8_t c) { return c >= 0 && c <= 3; })); |
| |
| if (base.arguments().size() == 1 && base.arguments().front()->type().isScalar()) { |
| // `half4(scalar).zyy` can be optimized to `half3(scalar)`. The swizzle |
| // components don't actually matter since all fields are the same. |
| const Expression& argument = *base.arguments().front(); |
| const Type& constructorType = componentType.toCompound(*fContext, swizzleSize, |
| /*rows=*/1); |
| replacement = Constructor::SimplifyConversion(constructorType, argument); |
| if (!replacement) { |
| ExpressionArray newArgs; |
| newArgs.push_back(argument.clone()); |
| replacement = std::make_unique<Constructor>(base.fOffset, constructorType, |
| std::move(newArgs)); |
| } |
| |
| // We're replacing an expression with a cloned version; we'll need a rescan. |
| // There's no fUsage change: `half4(foo).xy` and `half2(foo)` have equivalent |
| // reference counts. |
| try_replace_expression(&b, iter, &replacement); |
| optimizationContext->fUpdated = true; |
| optimizationContext->fNeedsRescan = true; |
| break; |
| } |
| |
| // Swizzles can duplicate some elements and discard others, e.g. |
| // `half4(1, 2, 3, 4).xxz` --> `half3(1, 1, 3)`. However, there are constraints: |
| // - Expressions with side effects need to occur exactly once, even if they |
| // would otherwise be swizzle-eliminated |
| // - Non-trivial expressions should not be repeated, but elimination is OK. |
| // |
| // Look up the argument for the constructor at each index. This is typically simple |
| // but for weird cases like `half4(bar.yz, half2(foo))`, it can be harder than it |
| // seems. This example would result in: |
| // argMap[0] = {.fArgIndex = 0, .fComponent = 0} (bar.yz .x) |
| // argMap[1] = {.fArgIndex = 0, .fComponent = 1} (bar.yz .y) |
| // argMap[2] = {.fArgIndex = 1, .fComponent = 0} (half2(foo) .x) |
| // argMap[3] = {.fArgIndex = 1, .fComponent = 1} (half2(foo) .y) |
| struct ConstructorArgMap { |
| int8_t fArgIndex; |
| int8_t fComponent; |
| }; |
| |
| int numConstructorArgs = base.type().columns(); |
| ConstructorArgMap argMap[4] = {}; |
| int writeIdx = 0; |
| for (int argIdx = 0; argIdx < (int) base.arguments().size(); ++argIdx) { |
| const Expression& expr = *base.arguments()[argIdx]; |
| int argWidth = expr.type().columns(); |
| for (int componentIdx = 0; componentIdx < argWidth; ++componentIdx) { |
| argMap[writeIdx].fArgIndex = argIdx; |
| argMap[writeIdx].fComponent = componentIdx; |
| ++writeIdx; |
| } |
| } |
| SkASSERT(writeIdx == numConstructorArgs); |
| |
| // Count up the number of times each constructor argument is used by the |
| // swizzle. |
| // `half4(bar.yz, half2(foo)).xwxy` -> { 3, 1 } |
| // - bar.yz is referenced 3 times, by `.x_xy` |
| // - half(foo) is referenced 1 time, by `._w__` |
| int8_t exprUsed[4] = {}; |
| for (int c : s.components()) { |
| exprUsed[argMap[c].fArgIndex]++; |
| } |
| |
| bool safeToOptimize = true; |
| for (int index = 0; index < numConstructorArgs; ++index) { |
| int8_t constructorArgIndex = argMap[index].fArgIndex; |
| const Expression& baseArg = *base.arguments()[constructorArgIndex]; |
| |
| // Check that non-trivial expressions are not swizzled in more than once. |
| if (exprUsed[constructorArgIndex] > 1 && |
| !Analysis::IsTrivialExpression(baseArg)) { |
| safeToOptimize = false; |
| break; |
| } |
| // Check that side-effect-bearing expressions are swizzled in exactly once. |
| if (exprUsed[constructorArgIndex] != 1 && baseArg.hasSideEffects()) { |
| safeToOptimize = false; |
| break; |
| } |
| } |
| |
| if (safeToOptimize) { |
| struct ReorderedArgument { |
| int8_t fArgIndex; |
| ComponentArray fComponents; |
| }; |
| SkSTArray<4, ReorderedArgument> reorderedArgs; |
| for (int c : s.components()) { |
| const ConstructorArgMap& argument = argMap[c]; |
| const Expression& baseArg = *base.arguments()[argument.fArgIndex]; |
| |
| if (baseArg.type().isScalar()) { |
| // This argument is a scalar; add it to the list as-is. |
| SkASSERT(argument.fComponent == 0); |
| reorderedArgs.push_back({argument.fArgIndex, |
| ComponentArray{}}); |
| } else { |
| // This argument is a component from a vector. |
| SkASSERT(argument.fComponent < baseArg.type().columns()); |
| if (reorderedArgs.empty() || |
| reorderedArgs.back().fArgIndex != argument.fArgIndex) { |
| // This can't be combined with the previous argument. Add a new one. |
| reorderedArgs.push_back({argument.fArgIndex, |
| ComponentArray{argument.fComponent}}); |
| } else { |
| // Since we know this argument uses components, it should already |
| // have at least one component set. |
| SkASSERT(!reorderedArgs.back().fComponents.empty()); |
| // Build up the current argument with one more component. |
| reorderedArgs.back().fComponents.push_back(argument.fComponent); |
| } |
| } |
| } |
| |
| // Convert our reordered argument list to an actual array of expressions, with |
| // the new order and any new inner swizzles that need to be applied. Note that |
| // we expect followup passes to clean up the inner swizzles. |
| ExpressionArray newArgs; |
| newArgs.reserve_back(swizzleSize); |
| for (const ReorderedArgument& reorderedArg : reorderedArgs) { |
| const Expression& baseArg = *base.arguments()[reorderedArg.fArgIndex]; |
| if (reorderedArg.fComponents.empty()) { |
| newArgs.push_back(baseArg.clone()); |
| } else { |
| newArgs.push_back(std::make_unique<Swizzle>(*fContext, baseArg.clone(), |
| reorderedArg.fComponents)); |
| } |
| } |
| |
| // Create a new constructor. |
| replacement = std::make_unique<Constructor>( |
| base.fOffset, |
| componentType.toCompound(*fContext, swizzleSize, /*rows=*/1), |
| std::move(newArgs)); |
| |
| // Remove references within 'expr', add references within 'replacement.' |
| optimizationContext->fUsage->replace(expr, replacement.get()); |
| |
| // We're replacing an expression with a cloned version; we'll need a rescan. |
| try_replace_expression(&b, iter, &replacement); |
| optimizationContext->fUpdated = true; |
| optimizationContext->fNeedsRescan = true; |
| } |
| break; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| |
| void Compiler::simplifyStatement(DefinitionMap& definitions, |
| BasicBlock& b, |
| std::vector<BasicBlock::Node>::iterator* iter, |
| OptimizationContext* optimizationContext) { |
| ProgramUsage* usage = optimizationContext->fUsage; |
| Statement* stmt = (*iter)->statement()->get(); |
| switch (stmt->kind()) { |
| case Statement::Kind::kVarDeclaration: { |
| const auto& varDecl = stmt->as<VarDeclaration>(); |
| if (usage->isDead(varDecl.var()) && |
| (!varDecl.value() || |
| !varDecl.value()->hasSideEffects())) { |
| if (varDecl.value()) { |
| SkASSERT((*iter)->statement()->get() == stmt); |
| if (!b.tryRemoveExpressionBefore(iter, varDecl.value().get())) { |
| optimizationContext->fNeedsRescan = true; |
| } |
| } |
| // There can still be (soon to be removed) references to the variable at this point. |
| // Allowing the VarDeclaration to be destroyed here will break those variable's |
| // initialValue()s, so we hang on to them until optimization is finished. |
| std::unique_ptr<Statement> old = (*iter)->setStatement(std::make_unique<Nop>(), |
| usage); |
| optimizationContext->fOwnedStatements.push_back(std::move(old)); |
| optimizationContext->fUpdated = true; |
| } |
| break; |
| } |
| case Statement::Kind::kIf: { |
| // TODO(skia:11319): this optimization logic is redundant with the optimization code |
| // found in IfStatement.cpp. |
| IfStatement& i = stmt->as<IfStatement>(); |
| if (i.test()->kind() == Expression::Kind::kBoolLiteral) { |
| // constant if, collapse down to a single branch |
| if (i.test()->as<BoolLiteral>().value()) { |
| SkASSERT(i.ifTrue()); |
| (*iter)->setStatement(std::move(i.ifTrue()), usage); |
| } else { |
| if (i.ifFalse()) { |
| (*iter)->setStatement(std::move(i.ifFalse()), usage); |
| } else { |
| (*iter)->setStatement(std::make_unique<Nop>(), usage); |
| } |
| } |
| optimizationContext->fUpdated = true; |
| optimizationContext->fNeedsRescan = true; |
| break; |
| } |
| if (i.ifFalse() && i.ifFalse()->isEmpty()) { |
| // else block doesn't do anything, remove it |
| i.ifFalse().reset(); |
| optimizationContext->fUpdated = true; |
| optimizationContext->fNeedsRescan = true; |
| } |
| if (!i.ifFalse() && i.ifTrue()->isEmpty()) { |
| // if block doesn't do anything, no else block |
| if (i.test()->hasSideEffects()) { |
| // test has side effects, keep it |
| (*iter)->setStatement( |
| std::make_unique<ExpressionStatement>(std::move(i.test())), usage); |
| } else { |
| // no if, no else, no test side effects, kill the whole if |
| // statement |
| (*iter)->setStatement(std::make_unique<Nop>(), usage); |
| } |
| optimizationContext->fUpdated = true; |
| optimizationContext->fNeedsRescan = true; |
| } |
| break; |
| } |
| case Statement::Kind::kSwitch: { |
| // TODO(skia:11319): this optimization logic is redundant with the static-switch |
| // optimization code found in SwitchStatement.cpp. |
| SwitchStatement& s = stmt->as<SwitchStatement>(); |
| int64_t switchValue; |
| if (ConstantFolder::GetConstantInt(*s.value(), &switchValue)) { |
| // switch is constant, replace it with the case that matches |
| bool found = false; |
| SwitchCase* defaultCase = nullptr; |
| for (const std::unique_ptr<SwitchCase>& c : s.cases()) { |
| if (!c->value()) { |
| defaultCase = c.get(); |
| continue; |
| } |
| int64_t caseValue; |
| SkAssertResult(ConstantFolder::GetConstantInt(*c->value(), &caseValue)); |
| if (caseValue == switchValue) { |
| std::unique_ptr<Statement> newBlock = |
| SwitchStatement::BlockForCase(&s.cases(), c.get(), s.symbols()); |
| if (newBlock) { |
| (*iter)->setStatement(std::move(newBlock), usage); |
| found = true; |
| break; |
| } else { |
| if (s.isStatic() && |
| !fContext->fConfig->fSettings.fPermitInvalidStaticTests) { |
| auto [iter, didInsert] = optimizationContext->fSilences.insert(&s); |
| if (didInsert) { |
| this->error(s.fOffset, "static switch contains non-static " |
| "conditional exit"); |
| } |
| } |
| return; // can't simplify |
| } |
| } |
| } |
| if (!found) { |
| // no matching case. use default if it exists, or kill the whole thing |
| if (defaultCase) { |
| std::unique_ptr<Statement> newBlock = |
| SwitchStatement::BlockForCase(&s.cases(), defaultCase, s.symbols()); |
| if (newBlock) { |
| (*iter)->setStatement(std::move(newBlock), usage); |
| } else { |
| if (s.isStatic() && |
| !fContext->fConfig->fSettings.fPermitInvalidStaticTests) { |
| auto [iter, didInsert] = optimizationContext->fSilences.insert(&s); |
| if (didInsert) { |
| this->error(s.fOffset, "static switch contains non-static " |
| "conditional exit"); |
| } |
| } |
| return; // can't simplify |
| } |
| } else { |
| (*iter)->setStatement(std::make_unique<Nop>(), usage); |
| } |
| } |
| optimizationContext->fUpdated = true; |
| optimizationContext->fNeedsRescan = true; |
| } |
| break; |
| } |
| case Statement::Kind::kExpression: { |
| ExpressionStatement& e = stmt->as<ExpressionStatement>(); |
| SkASSERT((*iter)->statement()->get() == &e); |
| if (!e.expression()->hasSideEffects()) { |
| // Expression statement with no side effects, kill it |
| if (!b.tryRemoveExpressionBefore(iter, e.expression().get())) { |
| optimizationContext->fNeedsRescan = true; |
| } |
| SkASSERT((*iter)->statement()->get() == stmt); |
| (*iter)->setStatement(std::make_unique<Nop>(), usage); |
| optimizationContext->fUpdated = true; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| |
| bool Compiler::scanCFG(FunctionDefinition& f, ProgramUsage* usage) { |
| bool madeChanges = false; |
| |
| CFG cfg = CFGGenerator().getCFG(f); |
| this->computeDataFlow(&cfg); |
| |
| if (fContext->fConfig->fSettings.fDeadCodeElimination) { |
| // Check for unreachable code. |
| for (size_t i = 0; i < cfg.fBlocks.size(); i++) { |
| const BasicBlock& block = cfg.fBlocks[i]; |
| if (!block.fIsReachable && !block.fAllowUnreachable && block.fNodes.size()) { |
| const BasicBlock::Node& node = block.fNodes[0]; |
| int offset = node.isStatement() ? (*node.statement())->fOffset |
| : (*node.expression())->fOffset; |
| this->error(offset, String("unreachable")); |
| } |
| } |
| } |
| if (fErrorCount) { |
| return madeChanges; |
| } |
| |
| // check for dead code & undefined variables, perform constant propagation |
| OptimizationContext optimizationContext; |
| optimizationContext.fUsage = usage; |
| SkBitSet eliminatedBlockIds(cfg.fBlocks.size()); |
| do { |
| if (optimizationContext.fNeedsRescan) { |
| cfg = CFGGenerator().getCFG(f); |
| this->computeDataFlow(&cfg); |
| optimizationContext.fNeedsRescan = false; |
| } |
| |
| eliminatedBlockIds.reset(); |
| optimizationContext.fUpdated = false; |
| |
| for (BlockId blockId = 0; blockId < cfg.fBlocks.size(); ++blockId) { |
| if (eliminatedBlockIds.test(blockId)) { |
| // We reached a block ID that might have been eliminated. Be cautious and rescan. |
| optimizationContext.fUpdated = true; |
| optimizationContext.fNeedsRescan = true; |
| break; |
| } |
| |
| BasicBlock& b = cfg.fBlocks[blockId]; |
| if (fContext->fConfig->fSettings.fDeadCodeElimination) { |
| if (blockId > 0 && !b.fIsReachable) { |
| // Block was reachable before optimization, but has since become unreachable. In |
| // addition to being dead code, it's broken - since control flow can't reach it, |
| // no prior variable definitions can reach it, and therefore variables might |
| // look to have not been properly assigned. Kill it by replacing all statements |
| // with Nops. |
| for (BasicBlock::Node& node : b.fNodes) { |
| if (node.isStatement() && !(*node.statement())->is<Nop>()) { |
| // Eliminating a node runs the risk of eliminating that node's exits as |
| // well. Keep track of this and do a rescan if we are about to access |
| // one of these. |
| for (BlockId id : b.fExits) { |
| eliminatedBlockIds.set(id); |
| } |
| node.setStatement(std::make_unique<Nop>(), usage); |
| madeChanges = true; |
| } |
| } |
| continue; |
| } |
| } |
| DefinitionMap definitions = b.fBefore; |
| |
| for (auto iter = b.fNodes.begin(); iter != b.fNodes.end() && |
| !optimizationContext.fNeedsRescan; ++iter) { |
| if (iter->isExpression()) { |
| this->simplifyExpression(definitions, b, &iter, &optimizationContext); |
| } else { |
| this->simplifyStatement(definitions, b, &iter, &optimizationContext); |
| } |
| if (optimizationContext.fNeedsRescan) { |
| break; |
| } |
| definitions.addDefinitions(*fContext, *iter); |
| } |
| |
| if (optimizationContext.fNeedsRescan) { |
| break; |
| } |
| } |
| madeChanges |= optimizationContext.fUpdated; |
| } while (optimizationContext.fUpdated); |
| SkASSERT(!optimizationContext.fNeedsRescan); |
| |
| return madeChanges; |
| } |
| |
| std::unique_ptr<Program> Compiler::convertProgram( |
| ProgramKind kind, |
| String text, |
| const Program::Settings& settings, |
| const std::vector<std::unique_ptr<ExternalFunction>>* externalFunctions) { |
| TRACE_EVENT0("skia.gpu", "SkSL::Compiler::convertProgram"); |
| |
| SkASSERT(!externalFunctions || (kind == ProgramKind::kGeneric)); |
| |
| // Loading and optimizing our base module might reset the inliner, so do that first, |
| // *then* configure the inliner with the settings for this program. |
| const ParsedModule& baseModule = this->moduleForProgramKind(kind); |
| |
| // Update our context to point to the program configuration for the duration of compilation. |
| auto config = std::make_unique<ProgramConfig>(ProgramConfig{kind, settings}); |
| AutoProgramConfig autoConfig(fContext, config.get()); |
| |
| // Honor our global optimization-disable flags. |
| config->fSettings.fOptimize &= gSkSLOptimizer; |
| config->fSettings.fControlFlowAnalysis &= gSkSLControlFlowAnalysis; |
| config->fSettings.fInlineThreshold *= (int)gSkSLInliner; |
| |
| // Disable optimization settings that depend on a parent setting which has been disabled. |
| config->fSettings.fControlFlowAnalysis &= config->fSettings.fOptimize; |
| config->fSettings.fInlineThreshold *= (int)config->fSettings.fOptimize; |
| config->fSettings.fDeadCodeElimination &= config->fSettings.fControlFlowAnalysis; |
| |
| fErrorText = ""; |
| fErrorCount = 0; |
| fInliner.reset(fIRGenerator->fModifiers.get()); |
| |
| // Not using AutoSource, because caller is likely to call errorText() if we fail to compile |
| std::unique_ptr<String> textPtr(new String(std::move(text))); |
| fSource = textPtr.get(); |
| |
| // Enable node pooling while converting and optimizing the program for a performance boost. |
| // The Program will take ownership of the pool. |
| std::unique_ptr<Pool> pool; |
| if (fContext->fCaps.useNodePools()) { |
| pool = Pool::Create(); |
| pool->attachToThread(); |
| } |
| IRGenerator::IRBundle ir = fIRGenerator->convertProgram(baseModule, /*isBuiltinCode=*/false, |
| textPtr->c_str(), textPtr->size(), |
| externalFunctions); |
| auto program = std::make_unique<Program>(std::move(textPtr), |
| std::move(config), |
| fContext, |
| std::move(ir.fElements), |
| std::move(ir.fSharedElements), |
| std::move(ir.fModifiers), |
| std::move(ir.fSymbolTable), |
| std::move(pool), |
| ir.fInputs); |
| bool success = false; |
| if (fErrorCount) { |
| // Do not return programs that failed to compile. |
| } else if (!this->optimize(*program)) { |
| // Do not return programs that failed to optimize. |
| } else { |
| // We have a successful program! |
| success = true; |
| } |
| |
| if (program->fPool) { |
| program->fPool->detachFromThread(); |
| } |
| return success ? std::move(program) : nullptr; |
| } |
| |
| void Compiler::verifyStaticTests(const Program& program) { |
| class StaticTestVerifier : public ProgramVisitor { |
| public: |
| StaticTestVerifier(ErrorReporter* r) : fReporter(r) {} |
| |
| using ProgramVisitor::visitProgramElement; |
| |
| bool visitStatement(const Statement& stmt) override { |
| switch (stmt.kind()) { |
| case Statement::Kind::kIf: |
| if (stmt.as<IfStatement>().isStatic()) { |
| fReporter->error(stmt.fOffset, "static if has non-static test"); |
| } |
| break; |
| |
| case Statement::Kind::kSwitch: |
| if (stmt.as<SwitchStatement>().isStatic()) { |
| fReporter->error(stmt.fOffset, "static switch has non-static test"); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| return INHERITED::visitStatement(stmt); |
| } |
| |
| bool visitExpression(const Expression&) override { |
| // We aren't looking for anything inside an Expression, so skip them entirely. |
| return false; |
| } |
| |
| private: |
| using INHERITED = ProgramVisitor; |
| ErrorReporter* fReporter; |
| }; |
| |
| // If invalid static tests are permitted, we don't need to check anything. |
| if (fContext->fConfig->fSettings.fPermitInvalidStaticTests) { |
| return; |
| } |
| |
| // Check all of the program's owned elements. (Built-in elements are assumed to be valid.) |
| StaticTestVerifier visitor{this}; |
| for (const std::unique_ptr<ProgramElement>& element : program.ownedElements()) { |
| if (element->is<FunctionDefinition>()) { |
| visitor.visitProgramElement(*element); |
| } |
| } |
| } |
| |
| bool Compiler::optimize(LoadedModule& module) { |
| SkASSERT(!fErrorCount); |
| |
| // Create a temporary program configuration with default settings. |
| ProgramConfig config; |
| config.fKind = module.fKind; |
| AutoProgramConfig autoConfig(fContext, &config); |
| |
| // Reset the Inliner. |
| fInliner.reset(fModifiers.back().get()); |
| |
| std::unique_ptr<ProgramUsage> usage = Analysis::GetUsage(module); |
| |
| while (fErrorCount == 0) { |
| bool madeChanges = false; |
| |
| // Scan and optimize based on the control-flow graph for each function. |
| if (config.fSettings.fControlFlowAnalysis) { |
| for (const auto& element : module.fElements) { |
| if (element->is<FunctionDefinition>()) { |
| madeChanges |= this->scanCFG(element->as<FunctionDefinition>(), usage.get()); |
| } |
| } |
| } |
| |
| // Perform inline-candidate analysis and inline any functions deemed suitable. |
| madeChanges |= fInliner.analyze(module.fElements, module.fSymbols, usage.get()); |
| |
| if (!madeChanges) { |
| break; |
| } |
| } |
| return fErrorCount == 0; |
| } |
| |
| bool Compiler::optimize(Program& program) { |
| // The optimizer only needs to run when it is enabled. |
| if (!program.fConfig->fSettings.fOptimize) { |
| return true; |
| } |
| |
| SkASSERT(!fErrorCount); |
| ProgramUsage* usage = program.fUsage.get(); |
| |
| while (fErrorCount == 0) { |
| bool madeChanges = false; |
| |
| // Scan and optimize based on the control-flow graph for each function. |
| if (program.fConfig->fSettings.fControlFlowAnalysis) { |
| for (const auto& element : program.ownedElements()) { |
| if (element->is<FunctionDefinition>()) { |
| madeChanges |= this->scanCFG(element->as<FunctionDefinition>(), usage); |
| } |
| } |
| } |
| |
| // Perform inline-candidate analysis and inline any functions deemed suitable. |
| madeChanges |= fInliner.analyze(program.ownedElements(), program.fSymbols, usage); |
| |
| // Remove dead functions. We wait until after analysis so that we still report errors, |
| // even in unused code. |
| if (program.fConfig->fSettings.fRemoveDeadFunctions) { |
| auto isDeadFunction = [&](const ProgramElement* element) { |
| if (!element->is<FunctionDefinition>()) { |
| return false; |
| } |
| const FunctionDefinition& fn = element->as<FunctionDefinition>(); |
| if (fn.declaration().name() != "main" && usage->get(fn.declaration()) == 0) { |
| usage->remove(*element); |
| madeChanges = true; |
| return true; |
| } |
| return false; |
| }; |
| program.fElements.erase( |
| std::remove_if(program.fElements.begin(), program.fElements.end(), |
| [&](const std::unique_ptr<ProgramElement>& element) { |
| return isDeadFunction(element.get()); |
| }), |
| program.fElements.end()); |
| program.fSharedElements.erase( |
| std::remove_if(program.fSharedElements.begin(), program.fSharedElements.end(), |
| isDeadFunction), |
| program.fSharedElements.end()); |
| } |
| |
| if (program.fConfig->fKind != ProgramKind::kFragmentProcessor) { |
| // Remove declarations of dead global variables |
| auto isDeadVariable = [&](const ProgramElement* element) { |
| if (!element->is<GlobalVarDeclaration>()) { |
| return false; |
| } |
| const GlobalVarDeclaration& global = element->as<GlobalVarDeclaration>(); |
| const VarDeclaration& varDecl = global.declaration()->as<VarDeclaration>(); |
| if (usage->isDead(varDecl.var())) { |
| madeChanges = true; |
| return true; |
| } |
| return false; |
| }; |
| program.fElements.erase( |
| std::remove_if(program.fElements.begin(), program.fElements.end(), |
| [&](const std::unique_ptr<ProgramElement>& element) { |
| return isDeadVariable(element.get()); |
| }), |
| program.fElements.end()); |
| program.fSharedElements.erase( |
| std::remove_if(program.fSharedElements.begin(), program.fSharedElements.end(), |
| isDeadVariable), |
| program.fSharedElements.end()); |
| } |
| |
| if (!madeChanges) { |
| break; |
| } |
| } |
| |
| if (fErrorCount == 0) { |
| this->verifyStaticTests(program); |
| } |
| |
| return fErrorCount == 0; |
| } |
| |
| #if defined(SKSL_STANDALONE) || SK_SUPPORT_GPU |
| |
| bool Compiler::toSPIRV(Program& program, OutputStream& out) { |
| #ifdef SK_ENABLE_SPIRV_VALIDATION |
| StringStream buffer; |
| AutoSource as(this, program.fSource.get()); |
| SPIRVCodeGenerator cg(fContext.get(), &program, this, &buffer); |
| bool result = cg.generateCode(); |
| if (result && program.fConfig->fSettings.fValidateSPIRV) { |
| spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_0); |
| const String& data = buffer.str(); |
| SkASSERT(0 == data.size() % 4); |
| String errors; |
| auto dumpmsg = [&errors](spv_message_level_t, const char*, const spv_position_t&, |
| const char* m) { |
| errors.appendf("SPIR-V validation error: %s\n", m); |
| }; |
| tools.SetMessageConsumer(dumpmsg); |
| |
| // Verify that the SPIR-V we produced is valid. At runtime, we will abort() with a message |
| // explaining the error. In standalone mode (skslc), we will send the message, plus the |
| // entire disassembled SPIR-V (for easier context & debugging) as *our* error message. |
| result = tools.Validate((const uint32_t*) data.c_str(), data.size() / 4); |
| |
| if (!result) { |
| #if defined(SKSL_STANDALONE) |
| // Convert the string-stream to a SPIR-V disassembly. |
| std::string disassembly; |
| if (tools.Disassemble((const uint32_t*)data.data(), data.size() / 4, &disassembly)) { |
| errors.append(disassembly); |
| } |
| this->error(-1, errors); |
| #else |
| SkDEBUGFAILF("%s", errors.c_str()); |
| #endif |
| } |
| out.write(data.c_str(), data.size()); |
| } |
| #else |
| AutoSource as(this, program.fSource.get()); |
| SPIRVCodeGenerator cg(fContext.get(), &program, this, &out); |
| bool result = cg.generateCode(); |
| #endif |
| return result; |
| } |
| |
| bool Compiler::toSPIRV(Program& program, String* out) { |
| StringStream buffer; |
| bool result = this->toSPIRV(program, buffer); |
| if (result) { |
| *out = buffer.str(); |
| } |
| return result; |
| } |
| |
| bool Compiler::toGLSL(Program& program, OutputStream& out) { |
| TRACE_EVENT0("skia.gpu", "SkSL::Compiler::toGLSL"); |
| AutoSource as(this, program.fSource.get()); |
| GLSLCodeGenerator cg(fContext.get(), &program, this, &out); |
| bool result = cg.generateCode(); |
| return result; |
| } |
| |
| bool Compiler::toGLSL(Program& program, String* out) { |
| StringStream buffer; |
| bool result = this->toGLSL(program, buffer); |
| if (result) { |
| *out = buffer.str(); |
| } |
| return result; |
| } |
| |
| bool Compiler::toHLSL(Program& program, String* out) { |
| String spirv; |
| if (!this->toSPIRV(program, &spirv)) { |
| return false; |
| } |
| |
| return SPIRVtoHLSL(spirv, out); |
| } |
| |
| bool Compiler::toMetal(Program& program, OutputStream& out) { |
| MetalCodeGenerator cg(fContext.get(), &program, this, &out); |
| bool result = cg.generateCode(); |
| return result; |
| } |
| |
| bool Compiler::toMetal(Program& program, String* out) { |
| StringStream buffer; |
| bool result = this->toMetal(program, buffer); |
| if (result) { |
| *out = buffer.str(); |
| } |
| return result; |
| } |
| |
| #if defined(SKSL_STANDALONE) || GR_TEST_UTILS |
| bool Compiler::toCPP(Program& program, String name, OutputStream& out) { |
| AutoSource as(this, program.fSource.get()); |
| CPPCodeGenerator cg(fContext.get(), &program, this, name, &out); |
| bool result = cg.generateCode(); |
| return result; |
| } |
| |
| bool Compiler::toH(Program& program, String name, OutputStream& out) { |
| AutoSource as(this, program.fSource.get()); |
| HCodeGenerator cg(fContext.get(), &program, this, name, &out); |
| bool result = cg.generateCode(); |
| return result; |
| } |
| #endif // defined(SKSL_STANDALONE) || GR_TEST_UTILS |
| |
| #endif // defined(SKSL_STANDALONE) || SK_SUPPORT_GPU |
| |
| Position Compiler::position(int offset) { |
| if (fSource && offset >= 0) { |
| int line = 1; |
| int column = 1; |
| for (int i = 0; i < offset; i++) { |
| if ((*fSource)[i] == '\n') { |
| ++line; |
| column = 1; |
| } |
| else { |
| ++column; |
| } |
| } |
| return Position(line, column); |
| } else { |
| return Position(-1, -1); |
| } |
| } |
| |
| void Compiler::error(int offset, String msg) { |
| fErrorCount++; |
| Position pos = this->position(offset); |
| fErrorTextLength.push_back(fErrorText.length()); |
| fErrorText += "error: " + (pos.fLine >= 1 ? to_string(pos.fLine) + ": " : "") + msg + "\n"; |
| } |
| |
| void Compiler::setErrorCount(int c) { |
| if (c < fErrorCount) { |
| fErrorText.resize(fErrorTextLength[c]); |
| fErrorTextLength.resize(c); |
| fErrorCount = c; |
| } |
| } |
| |
| String Compiler::errorText(bool showCount) { |
| if (showCount) { |
| this->writeErrorCount(); |
| } |
| fErrorCount = 0; |
| String result = fErrorText; |
| fErrorText = ""; |
| return result; |
| } |
| |
| void Compiler::writeErrorCount() { |
| if (fErrorCount) { |
| fErrorText += to_string(fErrorCount) + " error"; |
| if (fErrorCount > 1) { |
| fErrorText += "s"; |
| } |
| fErrorText += "\n"; |
| } |
| } |
| |
| } // namespace SkSL |