SkSL::Analysis Namespace Reference

Classes
struct	AssignmentInfo
struct	LoopControlFlowInfo
class	SymbolTableStackBuilder

Enumerations
enum class	ReturnComplexity { kSingleSafeReturn , kScopedReturns , kEarlyReturns }

Functions
LoopControlFlowInfo	GetLoopControlFlowInfo (const Statement &stmt)
SampleUsage	GetSampleUsage (const Program &program, const Variable &child, bool writesToSampleCoords=true, int *elidedSampleCoordCount=nullptr)
bool	ReferencesBuiltin (const Program &program, int builtin)
bool	ReferencesSampleCoords (const Program &program)
bool	ReferencesFragCoords (const Program &program)
bool	CallsSampleOutsideMain (const Program &program)
bool	CallsColorTransformIntrinsics (const Program &program)
bool	ReturnsOpaqueColor (const FunctionDefinition &function)
bool	ReturnsInputAlpha (const FunctionDefinition &function, const ProgramUsage &usage)
bool	CheckProgramStructure (const Program &program, bool enforceSizeLimit)
bool	ContainsRTAdjust (const Expression &expr)
bool	ContainsVariable (const Expression &expr, const Variable &var)
bool	HasSideEffects (const Expression &expr)
bool	IsCompileTimeConstant (const Expression &expr)
bool	IsDynamicallyUniformExpression (const Expression &expr)
bool	DetectVarDeclarationWithoutScope (const Statement &stmt, ErrorReporter *errors=nullptr)
int	NodeCountUpToLimit (const FunctionDefinition &function, int limit)
bool	SwitchCaseContainsUnconditionalExit (const Statement &stmt)
bool	SwitchCaseContainsConditionalExit (const Statement &stmt)
std::unique_ptr< ProgramUsage >	GetUsage (const Program &program)
std::unique_ptr< ProgramUsage >	GetUsage (const Module &module)
bool	StatementWritesToVariable (const Statement &stmt, const Variable &var)
bool	IsAssignable (Expression &expr, AssignmentInfo *info=nullptr, ErrorReporter *errors=nullptr)
bool	UpdateVariableRefKind (Expression *expr, VariableRefKind kind, ErrorReporter *errors=nullptr)
bool	IsTrivialExpression (const Expression &expr)
bool	IsSameExpressionTree (const Expression &left, const Expression &right)
bool	IsConstantExpression (const Expression &expr)
void	ValidateIndexingForES2 (const ProgramElement &pe, ErrorReporter &errors)
void	CheckSymbolTableCorrectness (const Program &program)
std::unique_ptr< LoopUnrollInfo >	GetLoopUnrollInfo (const Context &context, Position pos, const ForLoopPositions &positions, const Statement *loopInitializer, std::unique_ptr< Expression > *loopTestPtr, const Expression *loopNext, const Statement *loopStatement, ErrorReporter *errors)
bool	CanExitWithoutReturningValue (const FunctionDeclaration &funcDecl, const Statement &body)
ReturnComplexity	GetReturnComplexity (const FunctionDefinition &funcDef)
void	DoFinalizationChecks (const Program &program)
skia_private::TArray< const SkSL::Variable * >	GetComputeShaderMainParams (const Context &context, const Program &program)

Detailed Description

Provides utilities for analyzing SkSL statically before it's composed into a full program.

Enumeration Type Documentation

ReturnComplexity

enum class SkSL::Analysis::ReturnComplexity

strong

Determines if a given function has multiple and/or early returns.

Enumerator
kSingleSafeReturn
kScopedReturns
kEarlyReturns

Definition at line 238 of file SkSLAnalysis.h.

                            {
    kSingleSafeReturn,
    kScopedReturns,
    kEarlyReturns,
};

Function Documentation

CallsColorTransformIntrinsics()

bool SkSL::Analysis::CallsColorTransformIntrinsics

(

const Program &

program

)

Definition at line 374 of file SkSLAnalysis.cpp.

                                                                   {
    for (auto [symbol, count] : program.usage()->fCallCounts) {
        const FunctionDeclaration& fn = symbol->as<FunctionDeclaration>();
        if (count != 0 && (fn.intrinsicKind() == k_toLinearSrgb_IntrinsicKind ||
                           fn.intrinsicKind() == k_fromLinearSrgb_IntrinsicKind)) {
            return true;
        }
    }
    return false;
}

CallsSampleOutsideMain()

bool SkSL::Analysis::CallsSampleOutsideMain

(

const Program &

program

)

Definition at line 369 of file SkSLAnalysis.cpp.

                                                            {
    SampleOutsideMainVisitor visitor;
    return visitor.visit(program);
}

CanExitWithoutReturningValue()

bool SkSL::Analysis::CanExitWithoutReturningValue	(	const FunctionDeclaration &	funcDecl,
		const Statement &	body
	)

Detects functions that fail to return a value on at least one path.

Definition at line 166 of file SkSLCanExitWithoutReturningValue.cpp.

                                                                   {
    if (funcDecl.returnType().isVoid()) {
        return false;
    }
    ReturnsOnAllPathsVisitor visitor;
    visitor.visitStatement(body);
    return !visitor.fFoundReturn;
}

CheckProgramStructure()

bool SkSL::Analysis::CheckProgramStructure	(	const Program &	program,
		bool	enforceSizeLimit
	)

Checks for recursion or overly-deep function-call chains, and rejects programs which have them. Also, computes the size of the program in a completely flattened state–loops fully unrolled, function calls inlined–and rejects programs that exceed an arbitrary upper bound.

Definition at line 36 of file SkSLCheckProgramStructure.cpp.

                                                                                  {
    // We check the size of strict-ES2 programs; this behavior is a holdover from SkVM, which would
    // completely unroll all loops. (SkRP supports loops properly, but does inline function calls.)
    // For non-ES2 code, we compute an approximate lower bound by assuming all non-unrollable loops
    // will execute one time only.
    const Context& context = *program.fContext;
 
    // If we decide that expressions are cheaper than statements, or that certain statements are
    // more expensive than others, etc., we can always tweak these ratios as needed. A very rough
    // ballpark estimate is currently good enough for our purposes.
    static constexpr size_t kExpressionCost = 1;
    static constexpr size_t kStatementCost = 1;
    static constexpr size_t kUnknownCost = -1;
    static constexpr size_t kProgramSizeLimit = 100000;
    static constexpr size_t kProgramStackDepthLimit = 50;
 
    class ProgramSizeVisitor : public ProgramVisitor {
    public:
        ProgramSizeVisitor(const Context& c) : fContext(c) {}
 
        using ProgramVisitor::visitProgramElement;
 
        size_t functionSize() const {
            return fFunctionSize;
        }
 
        bool visitProgramElement(const ProgramElement& pe) override {
            if (pe.is<FunctionDefinition>()) {
                // Check the function-size cache map first. We don't need to visit this function if
                // we already processed it before.
                const FunctionDeclaration* decl = &pe.as<FunctionDefinition>().declaration();
                if (size_t *cachedCost = fFunctionCostMap.find(decl)) {
                    // We already have this function in our map. We don't need to check it again.
                    if (*cachedCost == kUnknownCost) {
                        // If the function is present in the map with an unknown cost, we're
                        // recursively processing it--in other words, we found a cycle in the code.
                        // Unwind our stack into a string.
                        std::string msg = "\n\t" + decl->description();
                        for (auto unwind = fStack.rbegin(); unwind != fStack.rend(); ++unwind) {
                            msg = "\n\t" + (*unwind)->description() + msg;
                            if (*unwind == decl) {
                                break;
                            }
                        }
                        msg = "potential recursion (function call cycle) not allowed:" + msg;
                        fContext.fErrors->error(pe.fPosition, std::move(msg));
                        fFunctionSize = 0;
                        *cachedCost = 0;
                        return true;
                    }
                    // Set the size to its known value.
                    fFunctionSize = *cachedCost;
                    return false;
                }
 
                // If the function-call stack has gotten too deep, stop the analysis.
                if (fStack.size() >= kProgramStackDepthLimit) {
                    std::string msg = "exceeded max function call depth:";
                    for (auto unwind = fStack.begin(); unwind != fStack.end(); ++unwind) {
                        msg += "\n\t" + (*unwind)->description();
                    }
                    msg += "\n\t" + decl->description();
                    fContext.fErrors->error(pe.fPosition, std::move(msg));
                    fFunctionSize = 0;
                    fFunctionCostMap.set(decl, 0);
                    return true;
                }
 
                // Calculate the function cost and store it in our cache.
                fFunctionCostMap.set(decl, kUnknownCost);
                fStack.push_back(decl);
                fFunctionSize = 0;
                bool result = INHERITED::visitProgramElement(pe);
                fFunctionCostMap.set(decl, fFunctionSize);
                fStack.pop_back();
 
                return result;
            }
 
            return INHERITED::visitProgramElement(pe);
        }
 
        bool visitStatement(const Statement& stmt) override {
            switch (stmt.kind()) {
                case Statement::Kind::kFor: {
                    // We count a for-loop's unrolled size here. We expect that the init statement
                    // will be emitted once, and the test-expr, next-expr and statement will be
                    // repeated in the output for every iteration of the loop.
                    bool earlyExit = false;
                    const ForStatement& forStmt = stmt.as<ForStatement>();
                    if (forStmt.initializer() && this->visitStatement(*forStmt.initializer())) {
                        earlyExit = true;
                    }
 
                    size_t originalFunctionSize = fFunctionSize;
                    fFunctionSize = 0;
 
                    if (forStmt.next() && this->visitExpression(*forStmt.next())) {
                        earlyExit = true;
                    }
                    if (forStmt.test() && this->visitExpression(*forStmt.test())) {
                        earlyExit = true;
                    }
                    if (this->visitStatement(*forStmt.statement())) {
                        earlyExit = true;
                    }
 
                    // ES2 programs always have a known unroll count. Non-ES2 programs don't enforce
                    // a maximum program size, so it's fine to treat the loop as executing once.
                    if (const LoopUnrollInfo* unrollInfo = forStmt.unrollInfo()) {
                        fFunctionSize = SkSafeMath::Mul(fFunctionSize, unrollInfo->fCount);
                    }
                    fFunctionSize = SkSafeMath::Add(fFunctionSize, originalFunctionSize);
                    return earlyExit;
                }
 
                case Statement::Kind::kExpression:
                    // The cost of an expression-statement is counted in visitExpression. It would
                    // be double-dipping to count it here too.
                    break;
 
                case Statement::Kind::kNop:
                case Statement::Kind::kVarDeclaration:
                    // These statements don't directly consume any space in a compiled program.
                    break;
 
                default:
                    // Note that we don't make any attempt to estimate the number of iterations of
                    // do-while loops here. Those aren't an ES2 construct so we aren't enforcing
                    // program size on them.
                    fFunctionSize = SkSafeMath::Add(fFunctionSize, kStatementCost);
                    break;
            }
 
            return INHERITED::visitStatement(stmt);
        }
 
        bool visitExpression(const Expression& expr) override {
            // Other than function calls, all expressions are assumed to have a fixed unit cost.
            bool earlyExit = false;
            size_t expressionCost = kExpressionCost;
 
            if (expr.is<FunctionCall>()) {
                // Visit this function call to calculate its size. If we've already sized it, this
                // will retrieve the size from our cache.
                const FunctionCall& call = expr.as<FunctionCall>();
                const FunctionDeclaration* decl = &call.function();
                if (decl->definition() && !decl->isIntrinsic()) {
                    size_t originalFunctionSize = fFunctionSize;
                    fFunctionSize = 0;
 
                    earlyExit = this->visitProgramElement(*decl->definition());
                    expressionCost = fFunctionSize;
 
                    fFunctionSize = originalFunctionSize;
                }
            }
 
            fFunctionSize = SkSafeMath::Add(fFunctionSize, expressionCost);
            return earlyExit || INHERITED::visitExpression(expr);
        }
 
    private:
        using INHERITED = ProgramVisitor;
 
        const Context& fContext;
        size_t fFunctionSize = 0;
        THashMap<const FunctionDeclaration*, size_t> fFunctionCostMap;
        std::vector<const FunctionDeclaration*> fStack;
    };
 
    // Process every function in our program.
    ProgramSizeVisitor visitor{context};
    for (const std::unique_ptr<ProgramElement>& element : program.fOwnedElements) {
        if (element->is<FunctionDefinition>()) {
            // Visit every function--we want to detect static recursion and report it as an error,
            // even in unreferenced functions.
            visitor.visitProgramElement(*element);
            // Report an error when main()'s flattened size is larger than our program limit.
            if (enforceSizeLimit &&
                visitor.functionSize() > kProgramSizeLimit &&
                element->as<FunctionDefinition>().declaration().isMain()) {
                context.fErrors->error(Position(), "program is too large");
            }
        }
    }
 
    return true;
}

CheckSymbolTableCorrectness()

void SkSL::Analysis::CheckSymbolTableCorrectness

(

const Program &

program

)

Emits an internal error if a VarDeclaration exists without a matching entry in the nearest SymbolTable.

Definition at line 33 of file SkSLCheckSymbolTableCorrectness.cpp.

                                                                 {
    const Context& context = *program.fContext;
 
    class SymbolTableCorrectnessVisitor : public ProgramVisitor {
    public:
        SymbolTableCorrectnessVisitor(const Context& c, SymbolTable* sym)
                : fContext(c)
                , fSymbolTableStack({sym}) {}
 
        using ProgramVisitor::visitProgramElement;
 
        bool visitStatement(const Statement& stmt) override {
            Analysis::SymbolTableStackBuilder symbolTableStackBuilder(&stmt, &fSymbolTableStack);
            if (stmt.is<VarDeclaration>()) {
                // Check the top of the symbol table stack to see if it contains this exact symbol.
                const VarDeclaration& vardecl = stmt.as<VarDeclaration>();
                bool containsSymbol = false;
 
                // We want to do an exact Symbol* comparison in just one symbol table; we don't want
                // to look up by name, and we don't want to walk the symbol table tree. This makes
                // SymbolTable::find() an inappropriate tool for the job. Instead, we can iterate
                // the symbol table's contents directly and check for a pointer match.
                fSymbolTableStack.back()->foreach([&](std::string_view, const Symbol* symbol) {
                    if (symbol == vardecl.var()) {
                        containsSymbol = true;
                    }
                });
                if (!containsSymbol) {
                    fContext.fErrors->error(vardecl.position(), "internal error (variable '" +
                                                                std::string(vardecl.var()->name()) +
                                                                "' is incorrectly scoped)");
                }
            }
            return INHERITED::visitStatement(stmt);
        }
 
        bool visitExpression(const Expression&) override {
            return false;
        }
 
    private:
        using INHERITED = ProgramVisitor;
 
        const Context& fContext;
        std::vector<SymbolTable*> fSymbolTableStack;
    };
 
    SymbolTableCorrectnessVisitor visitor{context, program.fSymbols.get()};
    for (const std::unique_ptr<ProgramElement>& pe : program.fOwnedElements) {
        visitor.visitProgramElement(*pe);
    }
}

ContainsRTAdjust()

bool SkSL::Analysis::ContainsRTAdjust

(

const Expression &

expr

)

Determines if expr contains a reference to the variable sk_RTAdjust.

Definition at line 390 of file SkSLAnalysis.cpp.

                                                      {
    class ContainsRTAdjustVisitor : public ProgramVisitor {
    public:
        bool visitExpression(const Expression& expr) override {
            if (expr.is<VariableReference>() &&
                expr.as<VariableReference>().variable()->name() == Compiler::RTADJUST_NAME) {
                return true;
            }
            return INHERITED::visitExpression(expr);
        }
 
        using INHERITED = ProgramVisitor;
    };
 
    ContainsRTAdjustVisitor visitor;
    return visitor.visitExpression(expr);
}

ContainsVariable()

bool SkSL::Analysis::ContainsVariable	(	const Expression &	expr,
		const Variable &	var
	)

Determines if expr contains a reference to variable var.

Definition at line 408 of file SkSLAnalysis.cpp.

                                                                           {
    class ContainsVariableVisitor : public ProgramVisitor {
    public:
        ContainsVariableVisitor(const Variable* v) : fVariable(v) {}
 
        bool visitExpression(const Expression& expr) override {
            if (expr.is<VariableReference>() &&
                expr.as<VariableReference>().variable() == fVariable) {
                return true;
            }
            return INHERITED::visitExpression(expr);
        }
 
        using INHERITED = ProgramVisitor;
        const Variable* fVariable;
    };
 
    ContainsVariableVisitor visitor{&var};
    return visitor.visitExpression(expr);
}

DetectVarDeclarationWithoutScope()

bool SkSL::Analysis::DetectVarDeclarationWithoutScope	(	const Statement &	stmt,
		ErrorReporter *	errors = nullptr
	)

Detect an orphaned variable declaration outside of a scope, e.g. if (true) int a;. Returns true if an error was reported.

Definition at line 466 of file SkSLAnalysis.cpp.

                                                                                            {
    // A variable declaration can create either a lone VarDeclaration or an unscoped Block
    // containing multiple VarDeclaration statements. We need to detect either case.
    const Variable* var;
    if (stmt.is<VarDeclaration>()) {
        // The single-variable case. No blocks at all.
        var = stmt.as<VarDeclaration>().var();
    } else if (stmt.is<Block>()) {
        // The multiple-variable case: an unscoped, non-empty block...
        const Block& block = stmt.as<Block>();
        if (block.isScope() || block.children().empty()) {
            return false;
        }
        // ... holding a variable declaration.
        const Statement& innerStmt = *block.children().front();
        if (!innerStmt.is<VarDeclaration>()) {
            return false;
        }
        var = innerStmt.as<VarDeclaration>().var();
    } else {
        // This statement wasn't a variable declaration. No problem.
        return false;
    }
 
    // Report an error.
    SkASSERT(var);
    if (errors) {
        errors->error(var->fPosition,
                      "variable '" + std::string(var->name()) + "' must be created in a scope");
    }
    return true;
}

DoFinalizationChecks()

void SkSL::Analysis::DoFinalizationChecks

(

const Program &

program

)

Runs at finalization time to perform any last-minute correctness checks:

• Reports dangling FunctionReference or TypeReference expressions
• Reports function out params which are never written to (structs are currently exempt)

Definition at line 207 of file SkSLFinalizationChecks.cpp.

                                                          {
    // Check all of the program's owned elements. (Built-in elements are assumed to be valid.)
    FinalizationVisitor visitor{*program.fContext, *program.usage()};
    for (const std::unique_ptr<ProgramElement>& element : program.fOwnedElements) {
        visitor.visitProgramElement(*element);
    }
    if (ProgramConfig::IsCompute(program.fConfig->fKind) && !visitor.definesLocalSize()) {
        program.fContext->fErrors->error(Position(),
                                         "compute programs must specify a workgroup size");
    }
}

GetComputeShaderMainParams()

skia_private::TArray< const SkSL::Variable * > SkSL::Analysis::GetComputeShaderMainParams	(	const Context &	context,
		const Program &	program
	)

Error checks compute shader in/outs and returns a vector containing them ordered by location.

GetLoopControlFlowInfo()

LoopControlFlowInfo SkSL::Analysis::GetLoopControlFlowInfo

(

const Statement &

stmt

)

Definition at line 72 of file SkSLGetLoopControlFlowInfo.cpp.

                                                                  {
    LoopControlFlowVisitor visitor;
    visitor.visitStatement(stmt);
    return visitor.fResult;
}

GetLoopUnrollInfo()

std::unique_ptr< LoopUnrollInfo > SkSL::Analysis::GetLoopUnrollInfo	(	const Context &	context,
		Position	pos,
		const ForLoopPositions &	positions,
		const Statement *	loopInitializer,
		std::unique_ptr< Expression > *	loopTestPtr,
		const Expression *	loopNext,
		const Statement *	loopStatement,
		ErrorReporter *	errors
	)

Ensures that a for-loop meets the strict requirements of The OpenGL ES Shading Language 1.00, Appendix A, Section 4. If the requirements are met, information about the loop's structure is returned. If the requirements are not met, the problem is reported via errors (if not nullptr), and null is returned. The loop test-expression may be altered by this check. For example, a loop like this: for (float x = 1.0; x != 0.0; x -= 0.01) {...} appears to be ES2-safe, but due to floating-point rounding error, it may not actually terminate. We rewrite the test condition to x > 0.0 in order to ensure loop termination.

Definition at line 59 of file SkSLGetLoopUnrollInfo.cpp.

                                                                                     {
    NoOpErrorReporter unused;
    ErrorReporter& errors = errorPtr ? *errorPtr : unused;
 
    auto loopInfo = std::make_unique<LoopUnrollInfo>();
 
    //
    // init_declaration has the form: type_specifier identifier = constant_expression
    //
    if (!loopInitializer) {
        Position pos = positions.initPosition.valid() ? positions.initPosition : loopPos;
        errors.error(pos, "missing init declaration");
        return nullptr;
    }
    if (!loopInitializer->is<VarDeclaration>()) {
        errors.error(loopInitializer->fPosition, "invalid init declaration");
        return nullptr;
    }
    const VarDeclaration& initDecl = loopInitializer->as<VarDeclaration>();
    if (!initDecl.baseType().isNumber()) {
        errors.error(loopInitializer->fPosition, "invalid type for loop index");
        return nullptr;
    }
    if (initDecl.arraySize() != 0) {
        errors.error(loopInitializer->fPosition, "invalid type for loop index");
        return nullptr;
    }
    if (!initDecl.value()) {
        errors.error(loopInitializer->fPosition, "missing loop index initializer");
        return nullptr;
    }
    if (!ConstantFolder::GetConstantValue(*initDecl.value(), &loopInfo->fStart)) {
        errors.error(loopInitializer->fPosition,
                     "loop index initializer must be a constant expression");
        return nullptr;
    }
 
    loopInfo->fIndex = initDecl.var();
 
    auto is_loop_index = [&](const std::unique_ptr<Expression>& expr) {
        return expr->is<VariableReference>() &&
               expr->as<VariableReference>().variable() == loopInfo->fIndex;
    };
 
    //
    // condition has the form: loop_index relational_operator constant_expression
    //
    if (!loopTest || !*loopTest) {
        Position pos = positions.conditionPosition.valid() ? positions.conditionPosition : loopPos;
        errors.error(pos, "missing condition");
        return nullptr;
    }
    if (!loopTest->get()->is<BinaryExpression>()) {
        errors.error(loopTest->get()->fPosition, "invalid condition");
        return nullptr;
    }
    const BinaryExpression* cond = &loopTest->get()->as<BinaryExpression>();
    if (!is_loop_index(cond->left())) {
        errors.error(cond->fPosition, "expected loop index on left hand side of condition");
        return nullptr;
    }
    // relational_operator is one of: > >= < <= == or !=
    switch (cond->getOperator().kind()) {
        case Operator::Kind::GT:
        case Operator::Kind::GTEQ:
        case Operator::Kind::LT:
        case Operator::Kind::LTEQ:
        case Operator::Kind::EQEQ:
        case Operator::Kind::NEQ:
            break;
        default:
            errors.error(cond->fPosition, "invalid relational operator");
            return nullptr;
    }
    double loopEnd = 0;
    if (!ConstantFolder::GetConstantValue(*cond->right(), &loopEnd)) {
        errors.error(cond->fPosition, "loop index must be compared with a constant expression");
        return nullptr;
    }
 
    //
    // expression has one of the following forms:
    //   loop_index++
    //   loop_index--
    //   loop_index += constant_expression
    //   loop_index -= constant_expression
    // The spec doesn't mention prefix increment and decrement, but there is some consensus that
    // it's an oversight, so we allow those as well.
    //
    if (!loopNext) {
        Position pos = positions.nextPosition.valid() ? positions.nextPosition : loopPos;
        errors.error(pos, "missing loop expression");
        return nullptr;
    }
    switch (loopNext->kind()) {
        case Expression::Kind::kBinary: {
            const BinaryExpression& next = loopNext->as<BinaryExpression>();
            if (!is_loop_index(next.left())) {
                errors.error(loopNext->fPosition, "expected loop index in loop expression");
                return nullptr;
            }
            if (!ConstantFolder::GetConstantValue(*next.right(), &loopInfo->fDelta)) {
                errors.error(loopNext->fPosition,
                             "loop index must be modified by a constant expression");
                return nullptr;
            }
            switch (next.getOperator().kind()) {
                case Operator::Kind::PLUSEQ:                                        break;
                case Operator::Kind::MINUSEQ: loopInfo->fDelta = -loopInfo->fDelta; break;
                default:
                    errors.error(loopNext->fPosition, "invalid operator in loop expression");
                    return nullptr;
            }
            break;
        }
        case Expression::Kind::kPrefix: {
            const PrefixExpression& next = loopNext->as<PrefixExpression>();
            if (!is_loop_index(next.operand())) {
                errors.error(loopNext->fPosition, "expected loop index in loop expression");
                return nullptr;
            }
            switch (next.getOperator().kind()) {
                case Operator::Kind::PLUSPLUS:   loopInfo->fDelta =  1; break;
                case Operator::Kind::MINUSMINUS: loopInfo->fDelta = -1; break;
                default:
                    errors.error(loopNext->fPosition, "invalid operator in loop expression");
                    return nullptr;
            }
            break;
        }
        case Expression::Kind::kPostfix: {
            const PostfixExpression& next = loopNext->as<PostfixExpression>();
            if (!is_loop_index(next.operand())) {
                errors.error(loopNext->fPosition, "expected loop index in loop expression");
                return nullptr;
            }
            switch (next.getOperator().kind()) {
                case Operator::Kind::PLUSPLUS:   loopInfo->fDelta =  1; break;
                case Operator::Kind::MINUSMINUS: loopInfo->fDelta = -1; break;
                default:
                    errors.error(loopNext->fPosition, "invalid operator in loop expression");
                    return nullptr;
            }
            break;
        }
        default:
            errors.error(loopNext->fPosition, "invalid loop expression");
            return nullptr;
    }
 
    //
    // Within the body of the loop, the loop index is not statically assigned to, nor is it used as
    // argument to a function 'out' or 'inout' parameter.
    //
    if (Analysis::StatementWritesToVariable(*loopStatement, *initDecl.var())) {
        errors.error(loopStatement->fPosition,
                     "loop index must not be modified within body of the loop");
        return nullptr;
    }
 
    // Finally, compute the iteration count, based on the bounds, and the termination operator.
    loopInfo->fCount = 0;
 
    switch (cond->getOperator().kind()) {
        case Operator::Kind::LT:
            loopInfo->fCount = calculate_count(loopInfo->fStart, loopEnd, loopInfo->fDelta,
                                              /*forwards=*/true, /*inclusive=*/false);
            break;
 
        case Operator::Kind::GT:
            loopInfo->fCount = calculate_count(loopInfo->fStart, loopEnd, loopInfo->fDelta,
                                              /*forwards=*/false, /*inclusive=*/false);
            break;
 
        case Operator::Kind::LTEQ:
            loopInfo->fCount = calculate_count(loopInfo->fStart, loopEnd, loopInfo->fDelta,
                                              /*forwards=*/true, /*inclusive=*/true);
            break;
 
        case Operator::Kind::GTEQ:
            loopInfo->fCount = calculate_count(loopInfo->fStart, loopEnd, loopInfo->fDelta,
                                              /*forwards=*/false, /*inclusive=*/true);
            break;
 
        case Operator::Kind::NEQ: {
            float iterations = sk_ieee_double_divide(loopEnd - loopInfo->fStart, loopInfo->fDelta);
            loopInfo->fCount = std::ceil(iterations);
            if (loopInfo->fCount < 0 || loopInfo->fCount != iterations ||
                !std::isfinite(iterations)) {
                // The loop doesn't reach the exact endpoint and so will never terminate.
                loopInfo->fCount = kLoopTerminationLimit;
            }
            if (loopInfo->fIndex->type().componentType().isFloat()) {
                // Rewrite `x != n` tests as `x < n` or `x > n` depending on the loop direction.
                // Less-than and greater-than tests avoid infinite loops caused by rounding error.
                Operator::Kind op = (loopInfo->fDelta > 0) ? Operator::Kind::LT
                                                           : Operator::Kind::GT;
                *loopTest = BinaryExpression::Make(context,
                                                   cond->fPosition,
                                                   cond->left()->clone(),
                                                   op,
                                                   cond->right()->clone());
                cond = &loopTest->get()->as<BinaryExpression>();
            }
            break;
        }
        case Operator::Kind::EQEQ: {
            if (loopInfo->fStart == loopEnd) {
                // Start and end begin in the same place, so we can run one iteration...
                if (loopInfo->fDelta) {
                    // ... and then they diverge, so the loop terminates.
                    loopInfo->fCount = 1;
                } else {
                    // ... but they never diverge, so the loop runs forever.
                    loopInfo->fCount = kLoopTerminationLimit;
                }
            } else {
                // Start never equals end, so the loop will not run a single iteration.
                loopInfo->fCount = 0;
            }
            break;
        }
        default: SkUNREACHABLE;
    }
 
    SkASSERT(loopInfo->fCount >= 0);
    if (loopInfo->fCount >= kLoopTerminationLimit) {
        errors.error(loopPos, "loop must guarantee termination in fewer iterations");
        return nullptr;
    }
 
    return loopInfo;
}

GetReturnComplexity()

Analysis::ReturnComplexity SkSL::Analysis::GetReturnComplexity

(

const FunctionDefinition &

funcDef

)

Definition at line 116 of file SkSLGetReturnComplexity.cpp.

                                                                                        {
    int returnsAtEndOfControlFlow = count_returns_at_end_of_control_flow(funcDef);
    CountReturnsWithLimit counter{funcDef, returnsAtEndOfControlFlow + 1};
    if (counter.fNumReturns > returnsAtEndOfControlFlow) {
        return ReturnComplexity::kEarlyReturns;
    }
    if (counter.fNumReturns > 1) {
        return ReturnComplexity::kScopedReturns;
    }
    if (counter.fVariablesInBlocks && counter.fDeepestReturn > 1) {
        return ReturnComplexity::kScopedReturns;
    }
    return ReturnComplexity::kSingleSafeReturn;
}

GetSampleUsage()

SampleUsage SkSL::Analysis::GetSampleUsage	(	const Program &	program,
		const Variable &	child,
		bool	writesToSampleCoords = true,
		int *	elidedSampleCoordCount = nullptr
	)

Determines how program samples child. By default, assumes that the sample coords might be modified, so child.eval(sampleCoords) is treated as Explicit. If writesToSampleCoords is false, treats that as PassThrough, instead. If elidedSampleCoordCount is provided, the pointed to value will be incremented by the number of sample calls where the above rewrite was performed.

Definition at line 325 of file SkSLAnalysis.cpp.

                                                                  {
    MergeSampleUsageVisitor visitor(*program.fContext, child, writesToSampleCoords);
    SampleUsage result = visitor.visit(program);
    if (elidedSampleCoordCount) {
        *elidedSampleCoordCount += visitor.elidedSampleCoordCount();
    }
    return result;
}

GetUsage() [1/2]

std::unique_ptr< ProgramUsage > SkSL::Analysis::GetUsage

(

const Module &

module

)

Definition at line 152 of file SkSLProgramUsage.cpp.

                                                                   {
    auto usage = std::make_unique<ProgramUsage>();
    ProgramUsageVisitor addRefs(usage.get(), /*delta=*/+1);
 
    for (const Module* m = &module; m != nullptr; m = m->fParent) {
        for (const std::unique_ptr<ProgramElement>& element : m->fElements) {
            addRefs.visitProgramElement(*element);
        }
    }
    return usage;
}

GetUsage() [2/2]

std::unique_ptr< ProgramUsage > SkSL::Analysis::GetUsage

(

const Program &

program

)

Definition at line 145 of file SkSLProgramUsage.cpp.

                                                                     {
    auto usage = std::make_unique<ProgramUsage>();
    ProgramUsageVisitor addRefs(usage.get(), /*delta=*/+1);
    addRefs.visit(program);
    return usage;
}

HasSideEffects()

bool SkSL::Analysis::HasSideEffects

(

const Expression &

expr

)

Determines if expr has any side effects. (Is the expression state-altering or pure?)

Definition at line 22 of file SkSLHasSideEffects.cpp.

                                                    {
    class HasSideEffectsVisitor : public ProgramVisitor {
    public:
        bool visitExpression(const Expression& expr) override {
            switch (expr.kind()) {
                case Expression::Kind::kFunctionCall: {
                    const FunctionCall& call = expr.as<FunctionCall>();
                    if (!call.function().modifierFlags().isPure()) {
                        return true;
                    }
                    break;
                }
                case Expression::Kind::kPrefix: {
                    const PrefixExpression& prefix = expr.as<PrefixExpression>();
                    if (prefix.getOperator().kind() == Operator::Kind::PLUSPLUS ||
                        prefix.getOperator().kind() == Operator::Kind::MINUSMINUS) {
                        return true;
                    }
                    break;
                }
                case Expression::Kind::kBinary: {
                    const BinaryExpression& binary = expr.as<BinaryExpression>();
                    if (binary.getOperator().isAssignment()) {
                        return true;
                    }
                    break;
                }
                case Expression::Kind::kPostfix:
                    return true;
 
                default:
                    break;
            }
            return INHERITED::visitExpression(expr);
        }
 
        using INHERITED = ProgramVisitor;
    };
 
    HasSideEffectsVisitor visitor;
    return visitor.visitExpression(expr);
}

IsAssignable()

bool SkSL::Analysis::IsAssignable	(	Expression &	expr,
		AssignmentInfo *	info = nullptr,
		ErrorReporter *	errors = nullptr
	)

Definition at line 507 of file SkSLAnalysis.cpp.

                                                                                         {
    NoOpErrorReporter unusedErrors;
    return IsAssignableVisitor{errors ? errors : &unusedErrors}.visit(expr, info);
}

IsCompileTimeConstant()

bool SkSL::Analysis::IsCompileTimeConstant

(

const Expression &

expr

)

Determines if expr is a compile-time constant (composed of just constructors and literals).

Definition at line 429 of file SkSLAnalysis.cpp.

                                                           {
    class IsCompileTimeConstantVisitor : public ProgramVisitor {
    public:
        bool visitExpression(const Expression& expr) override {
            switch (expr.kind()) {
                case Expression::Kind::kLiteral:
                    // Literals are compile-time constants.
                    return false;
 
                case Expression::Kind::kConstructorArray:
                case Expression::Kind::kConstructorCompound:
                case Expression::Kind::kConstructorDiagonalMatrix:
                case Expression::Kind::kConstructorMatrixResize:
                case Expression::Kind::kConstructorSplat:
                case Expression::Kind::kConstructorStruct:
                    // Constructors might be compile-time constants, if they are composed entirely
                    // of literals and constructors. (Casting constructors are intentionally omitted
                    // here. If the value inside was a compile-time constant, we would have not have
                    // generated a cast at all.)
                    return INHERITED::visitExpression(expr);
 
                default:
                    // This expression isn't a compile-time constant.
                    fIsConstant = false;
                    return true;
            }
        }
 
        bool fIsConstant = true;
        using INHERITED = ProgramVisitor;
    };
 
    IsCompileTimeConstantVisitor visitor;
    visitor.visitExpression(expr);
    return visitor.fIsConstant;
}

IsConstantExpression()

bool SkSL::Analysis::IsConstantExpression

(

const Expression &

expr

)

Returns true if expr is a constant-expression, as defined by GLSL 1.0, section 5.10. A constant expression is one of:

• A literal value
• A global or local variable qualified as 'const', excluding function parameters
• An expression formed by an operator on operands that are constant expressions, including getting an element of a constant vector or a constant matrix, or a field of a constant structure
• A constructor whose arguments are all constant expressions
• A built-in function call whose arguments are all constant expressions, with the exception of the texture lookup functions

Definition at line 157 of file SkSLIsConstantExpression.cpp.

                                                          {
    return !ConstantExpressionVisitor{/*loopIndices=*/nullptr}.visitExpression(expr);
}

IsDynamicallyUniformExpression()

bool SkSL::Analysis::IsDynamicallyUniformExpression

(

const Expression &

expr

)

Determines if expr is a dynamically-uniform expression; this returns true if the expression could be evaluated at compile time if uniform values were known.

Definition at line 21 of file SkSLIsDynamicallyUniformExpression.cpp.

                                                                    {
    class IsDynamicallyUniformExpressionVisitor : public ProgramVisitor {
    public:
        bool visitExpression(const Expression& expr) override {
            switch (expr.kind()) {
                case Expression::Kind::kBinary:
                case Expression::Kind::kConstructorArray:
                case Expression::Kind::kConstructorArrayCast:
                case Expression::Kind::kConstructorCompound:
                case Expression::Kind::kConstructorCompoundCast:
                case Expression::Kind::kConstructorDiagonalMatrix:
                case Expression::Kind::kConstructorMatrixResize:
                case Expression::Kind::kConstructorScalarCast:
                case Expression::Kind::kConstructorSplat:
                case Expression::Kind::kConstructorStruct:
                case Expression::Kind::kFieldAccess:
                case Expression::Kind::kIndex:
                case Expression::Kind::kPostfix:
                case Expression::Kind::kPrefix:
                case Expression::Kind::kSwizzle:
                case Expression::Kind::kTernary:
                    // These expressions might be dynamically uniform, if they are composed entirely
                    // of constants and uniforms.
                    break;
 
                case Expression::Kind::kVariableReference: {
                    // Verify that variable references are const or uniform.
                    const Variable* var = expr.as<VariableReference>().variable();
                    if (var && (var->modifierFlags().isConst() ||
                                var->modifierFlags().isUniform())) {
                        break;
                    }
                    fIsDynamicallyUniform = false;
                    return true;
                }
                case Expression::Kind::kFunctionCall: {
                    // Verify that function calls are pure.
                    const FunctionDeclaration& decl = expr.as<FunctionCall>().function();
                    if (decl.modifierFlags().isPure()) {
                        break;
                    }
                    fIsDynamicallyUniform = false;
                    return true;
                }
                case Expression::Kind::kLiteral:
                    // Literals are compile-time constants.
                    return false;
 
                default:
                    // This expression isn't dynamically uniform.
                    fIsDynamicallyUniform = false;
                    return true;
            }
            return INHERITED::visitExpression(expr);
        }
 
        bool fIsDynamicallyUniform = true;
        using INHERITED = ProgramVisitor;
    };
 
    IsDynamicallyUniformExpressionVisitor visitor;
    visitor.visitExpression(expr);
    return visitor.fIsDynamicallyUniform;
}

IsSameExpressionTree()

bool SkSL::Analysis::IsSameExpressionTree	(	const Expression &	left,
		const Expression &	right
	)

Returns true if both expression trees are the same. Used by the optimizer to look for self- assignment or self-comparison; won't necessarily catch complex cases. Rejects expressions that may cause side effects.

Definition at line 30 of file SkSLIsSameExpressionTree.cpp.

                                                                                   {
    if (left.kind() != right.kind() || !left.type().matches(right.type())) {
        return false;
    }
 
    // This isn't a fully exhaustive list of expressions by any stretch of the imagination; for
    // instance, `x[y+1] = x[y+1]` isn't detected because we don't look at BinaryExpressions.
    // Since this is intended to be used for optimization purposes, handling the common cases is
    // sufficient.
    switch (left.kind()) {
        case Expression::Kind::kLiteral:
            return left.as<Literal>().value() == right.as<Literal>().value();
 
        case Expression::Kind::kConstructorArray:
        case Expression::Kind::kConstructorArrayCast:
        case Expression::Kind::kConstructorCompound:
        case Expression::Kind::kConstructorCompoundCast:
        case Expression::Kind::kConstructorDiagonalMatrix:
        case Expression::Kind::kConstructorMatrixResize:
        case Expression::Kind::kConstructorScalarCast:
        case Expression::Kind::kConstructorStruct:
        case Expression::Kind::kConstructorSplat: {
            if (left.kind() != right.kind()) {
                return false;
            }
            const AnyConstructor& leftCtor = left.asAnyConstructor();
            const AnyConstructor& rightCtor = right.asAnyConstructor();
            const auto leftSpan = leftCtor.argumentSpan();
            const auto rightSpan = rightCtor.argumentSpan();
            if (leftSpan.size() != rightSpan.size()) {
                return false;
            }
            for (size_t index = 0; index < leftSpan.size(); ++index) {
                if (!IsSameExpressionTree(*leftSpan[index], *rightSpan[index])) {
                    return false;
                }
            }
            return true;
        }
        case Expression::Kind::kFieldAccess:
            return left.as<FieldAccess>().fieldIndex() == right.as<FieldAccess>().fieldIndex() &&
                   IsSameExpressionTree(*left.as<FieldAccess>().base(),
                                        *right.as<FieldAccess>().base());
 
        case Expression::Kind::kIndex:
            return IsSameExpressionTree(*left.as<IndexExpression>().index(),
                                        *right.as<IndexExpression>().index()) &&
                   IsSameExpressionTree(*left.as<IndexExpression>().base(),
                                        *right.as<IndexExpression>().base());
 
        case Expression::Kind::kPrefix:
            return (left.as<PrefixExpression>().getOperator().kind() ==
                    right.as<PrefixExpression>().getOperator().kind()) &&
                   IsSameExpressionTree(*left.as<PrefixExpression>().operand(),
                                        *right.as<PrefixExpression>().operand());
 
        case Expression::Kind::kSwizzle:
            return left.as<Swizzle>().components() == right.as<Swizzle>().components() &&
                   IsSameExpressionTree(*left.as<Swizzle>().base(), *right.as<Swizzle>().base());
 
        case Expression::Kind::kVariableReference:
            return left.as<VariableReference>().variable() ==
                   right.as<VariableReference>().variable();
 
        default:
            return false;
    }
}

IsTrivialExpression()

bool SkSL::Analysis::IsTrivialExpression

(

const Expression &

expr

)

A "trivial" expression is one where we'd feel comfortable cloning it multiple times in the code, without worrying about incurring a performance penalty. Examples:

• true
• 3.14159265
• myIntVariable
• myColor.rgb
• myArray[123]
• myStruct.myField
• half4(0)
• !myBoolean
• +myValue
• -myValue
• ~myInteger

Trivial-ness is stackable. Somewhat large expressions can occasionally make the cut:

• half4(myColor.a)
• myStruct.myArrayField[7].xzy

Definition at line 25 of file SkSLIsTrivialExpression.cpp.

                                                         {
    switch (expr.kind()) {
        case Expression::Kind::kLiteral:
        case Expression::Kind::kVariableReference:
            return true;
 
        case Expression::Kind::kSwizzle:
            // All swizzles are considered to be trivial.
            return IsTrivialExpression(*expr.as<Swizzle>().base());
 
        case Expression::Kind::kPrefix: {
            const PrefixExpression& prefix = expr.as<PrefixExpression>();
            switch (prefix.getOperator().kind()) {
                case OperatorKind::PLUS:
                case OperatorKind::MINUS:
                case OperatorKind::LOGICALNOT:
                case OperatorKind::BITWISENOT:
                    return IsTrivialExpression(*prefix.operand());
 
                default:
                    return false;
            }
        }
        case Expression::Kind::kFieldAccess:
            // Accessing a field is trivial.
            return IsTrivialExpression(*expr.as<FieldAccess>().base());
 
        case Expression::Kind::kIndex: {
            // Accessing a constant array index is trivial.
            const IndexExpression& inner = expr.as<IndexExpression>();
            return inner.index()->isIntLiteral() && IsTrivialExpression(*inner.base());
        }
        case Expression::Kind::kConstructorArray:
        case Expression::Kind::kConstructorStruct:
            // Only consider small arrays/structs of compile-time-constants to be trivial.
            return expr.type().slotCount() <= 4 && IsCompileTimeConstant(expr);
 
        case Expression::Kind::kConstructorArrayCast:
        case Expression::Kind::kConstructorMatrixResize:
            // These operations require function calls in Metal, so they're never trivial.
            return false;
 
        case Expression::Kind::kConstructorCompound:
            // Only compile-time-constant compound constructors are considered to be trivial.
            return IsCompileTimeConstant(expr);
 
        case Expression::Kind::kConstructorCompoundCast:
        case Expression::Kind::kConstructorScalarCast:
        case Expression::Kind::kConstructorSplat:
        case Expression::Kind::kConstructorDiagonalMatrix: {
            // Single-argument constructors are trivial when their inner expression is trivial.
            SkASSERT(expr.asAnyConstructor().argumentSpan().size() == 1);
            const Expression& inner = *expr.asAnyConstructor().argumentSpan().front();
            return IsTrivialExpression(inner);
        }
        default:
            return false;
    }
}

NodeCountUpToLimit()

int SkSL::Analysis::NodeCountUpToLimit	(	const FunctionDefinition &	function,
		int	limit
	)

Definition at line 499 of file SkSLAnalysis.cpp.

                                                                              {
    return NodeCountVisitor{limit}.visit(*function.body());
}

ReferencesBuiltin()

bool SkSL::Analysis::ReferencesBuiltin	(	const Program &	program,
		int	builtin
	)

Definition at line 337 of file SkSLAnalysis.cpp.

                                                                    {
    SkASSERT(program.fUsage);
    for (const auto& [variable, counts] : program.fUsage->fVariableCounts) {
        if (counts.fRead > 0 && variable->layout().fBuiltin == builtin) {
            return true;
        }
    }
    return false;
}

ReferencesFragCoords()

bool SkSL::Analysis::ReferencesFragCoords

(

const Program &

program

)

Definition at line 365 of file SkSLAnalysis.cpp.

                                                          {
    return Analysis::ReferencesBuiltin(program, SK_FRAGCOORD_BUILTIN);
}

ReferencesSampleCoords()

bool SkSL::Analysis::ReferencesSampleCoords

(

const Program &

program

)

Definition at line 347 of file SkSLAnalysis.cpp.

                                                            {
    // Look for main().
    for (const std::unique_ptr<ProgramElement>& pe : program.fOwnedElements) {
        if (pe->is<FunctionDefinition>()) {
            const FunctionDeclaration& func = pe->as<FunctionDefinition>().declaration();
            if (func.isMain()) {
                // See if main() has a coords parameter that is read from anywhere.
                if (const Variable* coords = func.getMainCoordsParameter()) {
                    ProgramUsage::VariableCounts counts = program.fUsage->get(*coords);
                    return counts.fRead > 0;
                }
            }
        }
    }
    // The program is missing a main().
    return false;
}

ReturnsInputAlpha()

bool SkSL::Analysis::ReturnsInputAlpha	(	const FunctionDefinition &	function,
		const ProgramUsage &	usage
	)

Determines if function is a color filter which returns the alpha component of the input color unchanged. This is a very conservative analysis, and only supports returning a swizzle of the input color, or returning a constructor that ends with input.a.

Definition at line 127 of file SkSLReturnsInputAlpha.cpp.

                                                                                              {
    ReturnsInputAlphaVisitor visitor{usage};
    return !visitor.visitProgramElement(function);
}

ReturnsOpaqueColor()

bool SkSL::Analysis::ReturnsOpaqueColor

(

const FunctionDefinition &

function

)

Determines if function always returns an opaque color (a vec4 where the last component is known to be 1). This is conservative, and based on constant expression analysis.

Definition at line 385 of file SkSLAnalysis.cpp.

                                                                    {
    ReturnsNonOpaqueColorVisitor visitor;
    return !visitor.visitProgramElement(function);
}

StatementWritesToVariable()

bool SkSL::Analysis::StatementWritesToVariable	(	const Statement &	stmt,
		const Variable &	var
	)

Returns true if the passed-in statement might alter var.

Definition at line 503 of file SkSLAnalysis.cpp.

                                                                                   {
    return VariableWriteVisitor(&var).visit(stmt);
}

SwitchCaseContainsConditionalExit()

bool SkSL::Analysis::SwitchCaseContainsConditionalExit

(

const Statement &

stmt

)

Finds conditional exits from a switch-case. Returns true if this statement contains a conditional that wraps a potential exit from the switch (via continue, break or return).

Definition at line 94 of file SkSLSwitchCaseContainsExit.cpp.

                                                                      {
    return SwitchCaseContainsExit{/*conditionalExits=*/true}.visitStatement(stmt);
}

SwitchCaseContainsUnconditionalExit()

bool SkSL::Analysis::SwitchCaseContainsUnconditionalExit

(

const Statement &

stmt

)

Finds unconditional exits from a switch-case. Returns true if this statement unconditionally causes an exit from this switch (via continue, break or return).

Definition at line 90 of file SkSLSwitchCaseContainsExit.cpp.

                                                                        {
    return SwitchCaseContainsExit{/*conditionalExits=*/false}.visitStatement(stmt);
}

UpdateVariableRefKind()

bool SkSL::Analysis::UpdateVariableRefKind	(	Expression *	expr,
		VariableRefKind	kind,
		ErrorReporter *	errors = nullptr
	)

Updates the refKind field of the VariableReference at the top level of expr. If expr can be assigned to (IsAssignable), true is returned and no errors are reported. If not, false is returned. and an error is reported if errors is non-null.

Definition at line 512 of file SkSLAnalysis.cpp.

                                                            {
    Analysis::AssignmentInfo info;
    if (!Analysis::IsAssignable(*expr, &info, errors)) {
        return false;
    }
    if (!info.fAssignedVar) {
        if (errors) {
            errors->error(expr->fPosition, "can't assign to expression '" + expr->description() +
                    "'");
        }
        return false;
    }
    info.fAssignedVar->setRefKind(kind);
    return true;
}

ValidateIndexingForES2()

void SkSL::Analysis::ValidateIndexingForES2	(	const ProgramElement &	pe,
		ErrorReporter &	errors
	)

Ensures that any index-expressions inside of for-loops qualify as 'constant-index-expressions' as defined by GLSL 1.0, Appendix A, Section 5. A constant-index-expression is:

• A constant-expression
• Loop indices (as defined in Appendix A, Section 4)
• Expressions composed of both of the above

Definition at line 161 of file SkSLIsConstantExpression.cpp.

                                                                                     {
    ES2IndexingVisitor visitor(errors);
    visitor.visitProgramElement(pe);
}