SkSL::Transform Namespace Reference

Functions
void	FindAndDeclareBuiltinVariables (Program &program)
ModifierFlags	AddConstToVarModifiers (const Variable &var, const Expression *initialValue, const ProgramUsage *usage)
std::unique_ptr< Expression >	RewriteIndexedSwizzle (const Context &context, const IndexExpression &swizzle)
void	FindAndDeclareBuiltinFunctions (Program &program)
void	FindAndDeclareBuiltinStructs (Program &program)
void	EliminateUnreachableCode (Module &module, ProgramUsage *usage)
void	EliminateUnreachableCode (Program &program)
void	EliminateEmptyStatements (Module &module)
void	EliminateUnnecessaryBraces (Module &module)
bool	EliminateDeadFunctions (const Context &context, Module &module, ProgramUsage *usage)
bool	EliminateDeadFunctions (Program &program)
bool	EliminateDeadLocalVariables (const Context &context, Module &module, ProgramUsage *usage)
bool	EliminateDeadLocalVariables (Program &program)
bool	EliminateDeadGlobalVariables (const Context &context, Module &module, ProgramUsage *usage, bool onlyPrivateGlobals)
bool	EliminateDeadGlobalVariables (Program &program)
void	RenamePrivateSymbols (Context &context, Module &module, ProgramUsage *usage, ProgramKind kind)
void	ReplaceConstVarsWithLiterals (Module &module, ProgramUsage *usage)
std::unique_ptr< Statement >	HoistSwitchVarDeclarationsAtTopLevel (const Context &, std::unique_ptr< SwitchStatement >)

Function Documentation

AddConstToVarModifiers()

ModifierFlags SkSL::Transform::AddConstToVarModifiers	(	const Variable &	var,
		const Expression *	initialValue,
		const ProgramUsage *	usage
	)

Checks to see if it would be safe to add const to the modifier flags of a variable. If so, returns the modifiers with const applied; if not, returns the existing modifiers as-is. Adding const allows the inliner to fold away more values and generate tighter code.

Definition at line 19 of file SkSLAddConstToVarModifiers.cpp.

                                                                           {
    // If the variable is already marked as `const`, keep our existing modifiers.
    ModifierFlags flags = var.modifierFlags();
    if (flags.isConst()) {
        return flags;
    }
    // If the variable doesn't have a compile-time-constant initial value, we can't `const` it.
    if (!initialValue || !Analysis::IsCompileTimeConstant(*initialValue)) {
        return flags;
    }
    // This only works for variables that are written-to a single time.
    ProgramUsage::VariableCounts counts = usage->get(var);
    if (counts.fWrite != 1) {
        return flags;
    }
    // Add `const` to our variable's modifier flags, making it eligible for constant-folding.
    return flags | ModifierFlag::kConst;
}

EliminateDeadFunctions() [1/2]

bool SkSL::Transform::EliminateDeadFunctions	(	const Context &	context,
		Module &	module,
		ProgramUsage *	usage
	)

Eliminates functions in a program which are never called. Returns true if any changes were made.

Definition at line 63 of file SkSLEliminateDeadFunctions.cpp.

                                                            {
    size_t numElements = module.fElements.size();
 
    if (context.fConfig->fSettings.fRemoveDeadFunctions) {
        module.fElements.erase(std::remove_if(module.fElements.begin(),
                                              module.fElements.end(),
                                              [&](const std::unique_ptr<ProgramElement>& pe) {
                                                  return dead_function_predicate(pe.get(), usage);
                                              }),
                               module.fElements.end());
    }
    return module.fElements.size() < numElements;
}

EliminateDeadFunctions() [2/2]

bool SkSL::Transform::EliminateDeadFunctions

(

Program &

program

)

Definition at line 38 of file SkSLEliminateDeadFunctions.cpp.

                                                       {
    ProgramUsage* usage = program.fUsage.get();
 
    size_t numOwnedElements = program.fOwnedElements.size();
    size_t numSharedElements = program.fSharedElements.size();
 
    if (program.fConfig->fSettings.fRemoveDeadFunctions) {
        program.fOwnedElements.erase(std::remove_if(program.fOwnedElements.begin(),
                                                    program.fOwnedElements.end(),
                                                    [&](const std::unique_ptr<ProgramElement>& pe) {
                                                        return dead_function_predicate(pe.get(),
                                                                                       usage);
                                                    }),
                                     program.fOwnedElements.end());
        program.fSharedElements.erase(std::remove_if(program.fSharedElements.begin(),
                                                     program.fSharedElements.end(),
                                                     [&](const ProgramElement* pe) {
                                                         return dead_function_predicate(pe, usage);
                                                     }),
                                      program.fSharedElements.end());
    }
    return program.fOwnedElements.size() < numOwnedElements ||
           program.fSharedElements.size() < numSharedElements;
}

EliminateDeadGlobalVariables() [1/2]

bool SkSL::Transform::EliminateDeadGlobalVariables	(	const Context &	context,
		Module &	module,
		ProgramUsage *	usage,
		bool	onlyPrivateGlobals
	)

Definition at line 45 of file SkSLEliminateDeadGlobalVariables.cpp.

                                                                      {
    auto isDeadVariable = [&](const ProgramElement& element) {
        return is_dead_variable(element, usage, onlyPrivateGlobals);
    };
 
    size_t numElements = module.fElements.size();
    if (context.fConfig->fSettings.fRemoveDeadVariables) {
        module.fElements.erase(std::remove_if(module.fElements.begin(),
                                              module.fElements.end(),
                                              [&](const std::unique_ptr<ProgramElement>& pe) {
                                                  return isDeadVariable(*pe);
                                              }),
                               module.fElements.end());
    }
    return module.fElements.size() < numElements;
}

EliminateDeadGlobalVariables() [2/2]

bool SkSL::Transform::EliminateDeadGlobalVariables

(

Program &

program

)

Definition at line 65 of file SkSLEliminateDeadGlobalVariables.cpp.

                                                             {
    auto isDeadVariable = [&](const ProgramElement& element) {
        return is_dead_variable(element, program.fUsage.get(), /*onlyPrivateGlobals=*/false);
    };
 
    size_t numOwnedElements = program.fOwnedElements.size();
    size_t numSharedElements = program.fSharedElements.size();
    if (program.fConfig->fSettings.fRemoveDeadVariables) {
        program.fOwnedElements.erase(std::remove_if(program.fOwnedElements.begin(),
                                                    program.fOwnedElements.end(),
                                                    [&](const std::unique_ptr<ProgramElement>& pe) {
                                                        return isDeadVariable(*pe);
                                                    }),
                                     program.fOwnedElements.end());
        program.fSharedElements.erase(std::remove_if(program.fSharedElements.begin(),
                                                     program.fSharedElements.end(),
                                                     [&](const ProgramElement* pe) {
                                                         return isDeadVariable(*pe);
                                                     }),
                                      program.fSharedElements.end());
    }
    return program.fOwnedElements.size() < numOwnedElements ||
           program.fSharedElements.size() < numSharedElements;
}

EliminateDeadLocalVariables() [1/2]

bool SkSL::Transform::EliminateDeadLocalVariables	(	const Context &	context,
		Module &	module,
		ProgramUsage *	usage
	)

Eliminates variables in a program which are never read or written (past their initializer). Preserves side effects from initializers, if any. Returns true if any changes were made.

Definition at line 158 of file SkSLEliminateDeadLocalVariables.cpp.

                                                                 {
    return eliminate_dead_local_variables(context, SkSpan(module.fElements), usage);
}

EliminateDeadLocalVariables() [2/2]

bool SkSL::Transform::EliminateDeadLocalVariables

(

Program &

program

)

Definition at line 164 of file SkSLEliminateDeadLocalVariables.cpp.

                                                            {
    return program.fConfig->fSettings.fRemoveDeadVariables
                   ? eliminate_dead_local_variables(*program.fContext,
                                                    SkSpan(program.fOwnedElements),
                                                    program.fUsage.get())
                   : false;
}

EliminateEmptyStatements()

void SkSL::Transform::EliminateEmptyStatements

(

Module &

module

)

Eliminates empty statements in a module (Nops, or blocks holding only Nops). Not implemented for Programs because Nops are harmless, but they waste space in long-lived module IR.

Definition at line 63 of file SkSLEliminateEmptyStatements.cpp.

                                                       {
    return eliminate_empty_statements(SkSpan(module.fElements));
}

EliminateUnnecessaryBraces()

void SkSL::Transform::EliminateUnnecessaryBraces

(

Module &

module

)

Eliminates unnecessary braces in a module (e.g., single-statement child blocks). Not implemented for Programs because extra braces are harmless, but they waste space in long-lived module IR.

Definition at line 107 of file SkSLEliminateUnnecessaryBraces.cpp.

                                                         {
    return eliminate_unnecessary_braces(SkSpan(module.fElements));
}

EliminateUnreachableCode() [1/2]

void SkSL::Transform::EliminateUnreachableCode	(	Module &	module,
		ProgramUsage *	usage
	)

Eliminates statements in a block which cannot be reached; for example, a statement immediately after a return or continue can safely be eliminated.

Definition at line 208 of file SkSLEliminateUnreachableCode.cpp.

                                                                            {
    return eliminate_unreachable_code(SkSpan(module.fElements), usage);
}

EliminateUnreachableCode() [2/2]

void SkSL::Transform::EliminateUnreachableCode

(

Program &

program

)

Definition at line 212 of file SkSLEliminateUnreachableCode.cpp.

                                                         {
    return eliminate_unreachable_code(SkSpan(program.fOwnedElements), program.fUsage.get());
}

FindAndDeclareBuiltinFunctions()

void SkSL::Transform::FindAndDeclareBuiltinFunctions

(

Program &

program

)

Copies built-in functions from modules into the program. Relies on ProgramUsage to determine which functions are necessary.

Definition at line 31 of file SkSLFindAndDeclareBuiltinFunctions.cpp.

                                                               {
    ProgramUsage* usage = program.fUsage.get();
    Context& context = *program.fContext;
 
    std::vector<const FunctionDefinition*> addedBuiltins;
    for (;;) {
        // Find all the built-ins referenced by the program but not yet included in the code.
        size_t numBuiltinsAtStart = addedBuiltins.size();
        for (const auto& [symbol, count] : usage->fCallCounts) {
            const FunctionDeclaration& fn = symbol->as<FunctionDeclaration>();
            if (!fn.isBuiltin() || count == 0) {
                // Not a built-in; skip it.
                continue;
            }
            if (fn.intrinsicKind() == k_dFdy_IntrinsicKind) {
                // Programs that invoke the `dFdy` intrinsic will need the RTFlip input.
                if (!context.fConfig->fSettings.fForceNoRTFlip) {
                    program.fInterface.fRTFlipUniform |= Program::Interface::kRTFlip_Derivative;
                }
            }
            if (const FunctionDefinition* builtinDef = fn.definition()) {
                // Make sure we only add a built-in function once. We rarely add more than a handful
                // of builtin functions, so linear search here is good enough.
                if (std::find(addedBuiltins.begin(), addedBuiltins.end(), builtinDef) ==
                    addedBuiltins.end()) {
                    addedBuiltins.push_back(builtinDef);
                }
            }
        }
 
        if (addedBuiltins.size() == numBuiltinsAtStart) {
            // If we didn't reference any more built-in functions than before, we're done.
            break;
        }
 
        // Sort the referenced builtin functions into a consistent order; otherwise our output will
        // become non-deterministic. The exact order isn't particularly important; we sort backwards
        // because we add elements to the shared-elements in reverse order at the end.
        std::sort(addedBuiltins.begin() + numBuiltinsAtStart,
                  addedBuiltins.end(),
                  [](const FunctionDefinition* aDefinition, const FunctionDefinition* bDefinition) {
                      const FunctionDeclaration& a = aDefinition->declaration();
                      const FunctionDeclaration& b = bDefinition->declaration();
                      if (a.name() != b.name()) {
                          return a.name() > b.name();
                      }
                      return a.description() > b.description();
                  });
 
        // Update the ProgramUsage to track all these newly discovered functions.
        int usageCallCounts = usage->fCallCounts.count();
 
        for (size_t index = numBuiltinsAtStart; index < addedBuiltins.size(); ++index) {
            usage->add(*addedBuiltins[index]);
        }
 
        if (usage->fCallCounts.count() == usageCallCounts) {
            // If we aren't making any more unique function calls than before, we're done.
            break;
        }
    }
 
    // Insert the new functions into the program's shared elements, right at the front.
    // They are added in reverse so that the deepest dependencies are added to the top.
    program.fSharedElements.insert(program.fSharedElements.begin(),
                                   addedBuiltins.rbegin(), addedBuiltins.rend());
}

FindAndDeclareBuiltinStructs()

void SkSL::Transform::FindAndDeclareBuiltinStructs

(

Program &

program

)

Copies built-in structs from modules into the program. Relies on ProgramUsage to determine which structs are necessary.

Definition at line 60 of file SkSLFindAndDeclareBuiltinStructs.cpp.

                                                             {
    // Check if the program references any builtin structs at all.
    if (contains_builtin_struct(*program.fUsage)) {
        // Visit all of our modules to find struct definitions that were referenced by ProgramUsage.
        std::vector<const ProgramElement*> addedStructDefs;
        get_struct_definitions_from_module(program, *program.fContext->fModule, &addedStructDefs);
 
        // Copy the struct definitions into our shared elements, and update ProgramUsage to match.
        program.fSharedElements.insert(program.fSharedElements.begin(),
                                       addedStructDefs.begin(), addedStructDefs.end());
 
        for (const ProgramElement* element : addedStructDefs) {
            program.fUsage->add(*element);
        }
    }
}

FindAndDeclareBuiltinVariables()

void SkSL::Transform::FindAndDeclareBuiltinVariables

(

Program &

program

)

Scans the finished program for built-in variables like sk_FragColor and adds them to the program's shared elements.

Definition at line 127 of file SkSLFindAndDeclareBuiltinVariables.cpp.

                                                      {
    using Interface = Program::Interface;
    const Context& context = *program.fContext;
    const SymbolTable& symbols = *program.fSymbols;
    BuiltinVariableScanner scanner(context, symbols);
 
    if (ProgramConfig::IsFragment(program.fConfig->fKind)) {
        // Find main() in the program and check its return type.
        // If it's half4, we treat that as an implicit write to sk_FragColor and add a reference.
        scanner.addImplicitFragColorWrite(program.fOwnedElements);
    }
 
    // Scan all the variables used by the program and declare any built-ins.
    for (const auto& [var, counts] : program.fUsage->fVariableCounts) {
        if (var->isBuiltin()) {
            scanner.addDeclaringElement(var);
 
            switch (var->layout().fBuiltin) {
                // Set the RTFlip program input if we find sk_FragCoord or sk_Clockwise.
                case SK_FRAGCOORD_BUILTIN:
                    if (!context.fConfig->fSettings.fForceNoRTFlip) {
                        program.fInterface.fRTFlipUniform |= Interface::kRTFlip_FragCoord;
                    }
                    break;
 
                case SK_CLOCKWISE_BUILTIN:
                    if (!context.fConfig->fSettings.fForceNoRTFlip) {
                        program.fInterface.fRTFlipUniform |= Interface::kRTFlip_Clockwise;
                    }
                    break;
 
                // Set the UseLastFragColor program input if we find sk_LastFragColor.
                // Metal and Dawn define this as a program input, rather than a global variable.
                case SK_LASTFRAGCOLOR_BUILTIN:
                    program.fInterface.fUseLastFragColor = true;
                    break;
 
                // Set secondary color output if we find sk_SecondaryFragColor.
                case SK_SECONDARYFRAGCOLOR_BUILTIN:
                    program.fInterface.fOutputSecondaryColor = true;
                    break;
            }
        }
    }
 
    // Sort the referenced builtin functions into a consistent order; otherwise our output will
    // become non-deterministic. The exact order isn't particularly important.
    scanner.sortNewElements();
 
    // Add all the newly-declared elements to the program, and update ProgramUsage to match.
    program.fSharedElements.insert(program.fSharedElements.begin(),
                                   scanner.fNewElements.begin(),
                                   scanner.fNewElements.end());
 
    for (const ProgramElement* element : scanner.fNewElements) {
        program.fUsage->add(*element);
    }
}

HoistSwitchVarDeclarationsAtTopLevel()

std::unique_ptr< Statement > SkSL::Transform::HoistSwitchVarDeclarationsAtTopLevel	(	const Context &	context,
		std::unique_ptr< SwitchStatement >	stmt
	)

Looks for variables inside of the top-level of a switch body, such as:

switch (x) { case 1: int i; // i is at top-level case 2: float f = 5.0; // f is at top-level, and has an initial-value assignment case 3: { bool b; } // b is not at top-level; it has an additional scope }

If any top-level variables are found, a scoped block is created around the switch, and the variable declarations are moved out of the switch body and into the outer scope. (Variables with additional scoping are left as-is.) Then, we replace the declarations with assignment statements:

{ int i; float f; switch (a) { case 1: // i is declared above and does not need initialization case 2: f = 5.0; // f is declared above and initialized here case 3: { bool b; } // b is left as-is because it has a block-scope } }

This doesn't change the meaning or correctness of the code. If the switch needs to be rewriten (e.g. due to the restrictions of ES2 or WGSL), this transformation prevents scoping issues with variables falling out of scope between switch-cases when we fall through.

If there are no variables at the top-level, the switch statement is returned as-is.

Definition at line 36 of file SkSLHoistSwitchVarDeclarationsAtTopLevel.cpp.

                                             {
    struct HoistSwitchVarDeclsVisitor : public ProgramWriter {
        HoistSwitchVarDeclsVisitor(const Context& c) : fContext(c) {}
 
        bool visitExpressionPtr(std::unique_ptr<Expression>& expr) override {
            // We don't need to recurse into expressions.
            return false;
        }
 
        bool visitStatementPtr(std::unique_ptr<Statement>& stmt) override {
            switch (stmt->kind()) {
                case StatementKind::kSwitchCase:
                    // Recurse inward from the switch and its inner switch-cases.
                    return INHERITED::visitStatementPtr(stmt);
 
                case StatementKind::kBlock:
                    if (!stmt->as<Block>().isScope()) {
                        // Recurse inward from unscoped blocks.
                        return INHERITED::visitStatementPtr(stmt);
                    }
                    break;
 
                case StatementKind::kVarDeclaration:
                    // Keep track of variable declarations.
                    fVarDeclarations.push_back(&stmt);
                    break;
 
                default:
                    break;
            }
 
            // We don't need to recurse into other statement types; we're only interested in the top
            // level of the switch statement.
            return false;
        }
 
        const Context& fContext;
        TArray<std::unique_ptr<Statement>*> fVarDeclarations;
 
        using INHERITED = ProgramWriter;
    };
 
    // Visit every switch-case in the switch, looking for hoistable var-declarations.
    HoistSwitchVarDeclsVisitor visitor(context);
    for (std::unique_ptr<Statement>& sc : stmt->as<SwitchStatement>().cases()) {
        visitor.visitStatementPtr(sc);
    }
 
    // If no declarations were found, return the switch as-is.
    if (visitor.fVarDeclarations.empty()) {
        return stmt;
    }
 
    // Move all of the var-declaration statements into a separate block.
    SymbolTable* switchSymbols = stmt->caseBlock()->as<Block>().symbolTable();
    std::unique_ptr<SymbolTable> blockSymbols = switchSymbols->insertNewParent();
 
    StatementArray blockStmts;
    blockStmts.reserve_exact(visitor.fVarDeclarations.size() + 1);
    for (std::unique_ptr<Statement>* innerDeclaration : visitor.fVarDeclarations) {
        VarDeclaration& decl = (*innerDeclaration)->as<VarDeclaration>();
        Variable* var = decl.var();
        bool isConst = var->modifierFlags().isConst();
 
        std::unique_ptr<Statement> replacementStmt;
        if (decl.value() && !isConst) {
            // The inner variable-declaration has an initial-value; we must replace the declaration
            // with an assignment to the variable. This also has the helpful effect of stripping off
            // the initial-value from the declaration.
            struct AssignmentHelper : public IRHelpers {
                using IRHelpers::IRHelpers;
 
                std::unique_ptr<Statement> makeAssignmentStmt(VarDeclaration& decl) const {
                    return Assign(Ref(decl.var()), std::move(decl.value()));
                }
            };
 
            AssignmentHelper helper(context);
            replacementStmt = helper.makeAssignmentStmt(decl);
        } else {
            // The inner variable-declaration has no initial-value, or it's const and has a constant
            // value; we can move it upwards as-is and replace its statement with a no-op.
            SkASSERT(!isConst || Analysis::IsConstantExpression(*decl.value()));
 
            replacementStmt = Nop::Make();
        }
 
        // Move the var-declaration above the switch, and replace the existing statement with either
        // an assignment (if there was an initial-value) or a no-op (if there wasn't one).
        blockStmts.push_back(std::move(*innerDeclaration));
        *innerDeclaration = std::move(replacementStmt);
 
        // Hoist the variable's symbol outside of the switch's symbol table, and into the enclosing
        // block's symbol table.
        switchSymbols->moveSymbolTo(blockSymbols.get(), var, context);
    }
 
    // Return a scoped Block holding the switch.
    Position pos = stmt->fPosition;
    blockStmts.push_back(std::move(stmt));
    return Block::MakeBlock(pos, std::move(blockStmts), Block::Kind::kBracedScope,
                            std::move(blockSymbols));
}

RenamePrivateSymbols()

void SkSL::Transform::RenamePrivateSymbols	(	Context &	context,
		Module &	module,
		ProgramUsage *	usage,
		ProgramKind	kind
	)

Renames private functions and function-local variables to minimize code size.

Definition at line 58 of file SkSLRenamePrivateSymbols.cpp.

                                                       {
    class SymbolRenamer : public ProgramWriter {
    public:
        SymbolRenamer(Context& context,
                      ProgramUsage* usage,
                      SymbolTable* symbolBase,
                      ProgramKind kind)
                : fContext(context)
                , fUsage(usage)
                , fSymbolTableStack({symbolBase})
                , fKind(kind) {}
 
        static std::string FindShortNameForSymbol(const Symbol* sym,
                                                  const SymbolTable* symbolTable,
                                                  const std::string& namePrefix) {
            static constexpr std::string_view kLetters[] = {
                    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
                    "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
                    "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
                    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
 
            // Try any single-letter option.
            for (std::string_view letter : kLetters) {
                std::string name = namePrefix + std::string(letter);
                if (symbolTable->find(name) == nullptr) {
                    return name;
                }
            }
 
            // Try every two-letter option.
            for (std::string_view letterA : kLetters) {
                for (std::string_view letterB : kLetters) {
                    std::string name = namePrefix + std::string(letterA) + std::string(letterB);
                    if (symbolTable->find(name) == nullptr) {
                        return name;
                    }
                }
            }
 
            // We struck out. Somehow, all 2700 two-letter names have been claimed.
            SkDEBUGFAILF("Unable to find unique name for '%s'", std::string(sym->name()).c_str());
            return std::string(sym->name());
        }
 
        void minifyVariableName(const Variable* var) {
            // Some variables are associated with anonymous parameters--these don't have names and
            // aren't present in the symbol table. Their names are already empty so there's no way
            // to shrink them further.
            if (var->name().empty()) {
                return;
            }
 
            // Ensure that this variable is properly set up in the symbol table.
            SymbolTable* symbols = fSymbolTableStack.back();
            Symbol* mutableSym = symbols->findMutable(var->name());
            SkASSERTF(mutableSym != nullptr,
                      "symbol table missing '%.*s'", (int)var->name().size(), var->name().data());
            SkASSERTF(mutableSym == var,
                      "wrong symbol found for '%.*s'", (int)var->name().size(), var->name().data());
 
            // Look for a new name for this symbol.
            // Note: we always rename _every_ variable, even ones with single-letter names. This is
            // a safeguard: if we claimed a name like `i`, and then the program itself contained an
            // `i` later on, in a nested SymbolTable, the two names would clash. By always renaming
            // everything, we can ignore that problem.
            std::string shortName = FindShortNameForSymbol(var, symbols, "");
            SkASSERT(symbols->findMutable(shortName) == nullptr);
 
            // Update the symbol's name.
            const std::string* ownedName = symbols->takeOwnershipOfString(std::move(shortName));
            symbols->renameSymbol(fContext, mutableSym, *ownedName);
        }
 
        void minifyFunctionName(const FunctionDeclaration* funcDecl) {
            // Look for a new name for this function.
            std::string namePrefix = ProgramConfig::IsRuntimeEffect(fKind) ? "" : "$";
            SymbolTable* symbols = fSymbolTableStack.back();
            std::string shortName = FindShortNameForSymbol(funcDecl, symbols,
                                                           std::move(namePrefix));
            SkASSERT(symbols->findMutable(shortName) == nullptr);
 
            if (shortName.size() < funcDecl->name().size()) {
                // Update the function's name. (If the function has overloads, this will rename all
                // of them at once.)
                Symbol* mutableSym = symbols->findMutable(funcDecl->name());
                const std::string* ownedName = symbols->takeOwnershipOfString(std::move(shortName));
                symbols->renameSymbol(fContext, mutableSym, *ownedName);
            }
        }
 
        bool functionNameCanBeMinifiedSafely(const FunctionDeclaration& funcDecl) const {
            if (ProgramConfig::IsRuntimeEffect(fKind)) {
                // The only externally-accessible function in a runtime effect is main().
                return !funcDecl.isMain();
            } else {
                // We will only minify $private_functions, and only ones not marked as $export.
                return skstd::starts_with(funcDecl.name(), '$') &&
                       !funcDecl.modifierFlags().isExport();
            }
        }
 
        void minifyFunction(FunctionDefinition& def) {
            // If the function is private, minify its name.
            const FunctionDeclaration* funcDecl = &def.declaration();
            if (this->functionNameCanBeMinifiedSafely(*funcDecl)) {
                this->minifyFunctionName(funcDecl);
            }
 
            // Minify the names of each function parameter.
            Analysis::SymbolTableStackBuilder symbolTableStackBuilder(def.body().get(),
                                                                      &fSymbolTableStack);
            for (Variable* param : funcDecl->parameters()) {
                this->minifyVariableName(param);
            }
        }
 
        void minifyPrototype(FunctionPrototype& proto) {
            const FunctionDeclaration* funcDecl = &proto.declaration();
            if (funcDecl->definition()) {
                // This function is defined somewhere; this isn't just a loose prototype.
                return;
            }
 
            // Eliminate the names of each function parameter.
            // The parameter names aren't in the symbol table's name lookup map at all.
            // All we need to do is blank out their names.
            for (Variable* param : funcDecl->parameters()) {
                param->setName("");
            }
        }
 
        bool visitProgramElement(ProgramElement& elem) override {
            switch (elem.kind()) {
                case ProgramElement::Kind::kFunction:
                    this->minifyFunction(elem.as<FunctionDefinition>());
                    return INHERITED::visitProgramElement(elem);
 
               case ProgramElement::Kind::kFunctionPrototype:
                   this->minifyPrototype(elem.as<FunctionPrototype>());
                    return INHERITED::visitProgramElement(elem);
 
                default:
                    return false;
            }
        }
 
        bool visitStatementPtr(std::unique_ptr<Statement>& stmt) override {
            Analysis::SymbolTableStackBuilder symbolTableStackBuilder(stmt.get(),
                                                                      &fSymbolTableStack);
            if (stmt->is<VarDeclaration>()) {
                // Minify the variable's name.
                VarDeclaration& decl = stmt->as<VarDeclaration>();
                this->minifyVariableName(decl.var());
            }
 
            return INHERITED::visitStatementPtr(stmt);
        }
 
        Context& fContext;
        ProgramUsage* fUsage;
        std::vector<SymbolTable*> fSymbolTableStack;
        ProgramKind fKind;
        using INHERITED = ProgramWriter;
    };
 
    // Rename local variables and private functions.
    SymbolRenamer renamer{context, usage, module.fSymbols.get(), kind};
    for (std::unique_ptr<ProgramElement>& pe : module.fElements) {
        renamer.visitProgramElement(*pe);
    }
 
    // Strip off modifier `$export` from every function. (Only the minifier checks this flag, so we
    // can remove it without affecting the meaning of the code.)
    for (std::unique_ptr<ProgramElement>& pe : module.fElements) {
        if (pe->is<FunctionDefinition>()) {
            const FunctionDeclaration* funcDecl = &pe->as<FunctionDefinition>().declaration();
            if (funcDecl->modifierFlags().isExport()) {
                strip_export_flag(context, funcDecl, module.fSymbols.get());
            }
        }
    }
}

ReplaceConstVarsWithLiterals()

void SkSL::Transform::ReplaceConstVarsWithLiterals	(	Module &	module,
		ProgramUsage *	usage
	)

Replaces constant variables in a program with their equivalent values.

Definition at line 32 of file SkSLReplaceConstVarsWithLiterals.cpp.

                                                                                {
    class ConstVarReplacer : public ProgramWriter {
    public:
        ConstVarReplacer(ProgramUsage* usage) : fUsage(usage) {}
 
        using ProgramWriter::visitProgramElement;
 
        bool visitExpressionPtr(std::unique_ptr<Expression>& expr) override {
            // If this is a variable...
            if (expr->is<VariableReference>()) {
                VariableReference& var = expr->as<VariableReference>();
                // ... and it's a candidate for size reduction...
                if (fCandidates.contains(var.variable())) {
                    // ... get its constant value...
                    if (const Expression* value = ConstantFolder::GetConstantValueOrNull(var)) {
                        // ... and replace it with that value.
                        fUsage->remove(expr.get());
                        expr = value->clone();
                        fUsage->add(expr.get());
                        return false;
                    }
                }
            }
            return INHERITED::visitExpressionPtr(expr);
        }
 
        ProgramUsage* fUsage;
        THashSet<const Variable*> fCandidates;
 
        using INHERITED = ProgramWriter;
    };
 
    ConstVarReplacer visitor{usage};
 
    for (const auto& [var, count] : usage->fVariableCounts) {
        // We can only replace const variables that still exist, and that have initial values.
        if (!count.fVarExists || count.fWrite != 1) {
            continue;
        }
        if (!var->modifierFlags().isConst()) {
            continue;
        }
        if (!var->initialValue()) {
            continue;
        }
        // The current size is:
        //   strlen("const type varname=initialvalue;`") + count*strlen("varname").
        size_t initialvalueSize = ConstantFolder::GetConstantValueForVariable(*var->initialValue())
                                          ->description()
                                          .size();
        size_t totalOldSize = var->description().size() +        // const type varname
                              1 +                                // =
                              initialvalueSize +                 // initialvalue
                              1 +                                // ;
                              count.fRead * var->name().size();  // count * varname
        // If we replace varname with initialvalue everywhere, the new size would be:
        //   count*strlen("initialvalue")
        size_t totalNewSize = count.fRead * initialvalueSize;    // count * initialvalue
 
        if (totalNewSize <= totalOldSize) {
            visitor.fCandidates.add(var);
        }
    }
 
    if (!visitor.fCandidates.empty()) {
        for (std::unique_ptr<ProgramElement>& pe : module.fElements) {
            if (pe->is<FunctionDefinition>()) {
                visitor.visitProgramElement(*pe);
            }
        }
    }
}

RewriteIndexedSwizzle()

std::unique_ptr< Expression > SkSL::Transform::RewriteIndexedSwizzle	(	const Context &	context,
		const IndexExpression &	swizzle
	)

Rewrites indexed swizzles of the form myVec.zyx[i] by replacing the swizzle with a lookup into a constant vector. e.g., the above expression would be rewritten as myVec[vec3(2, 1, 0)[i]]. This roughly matches glslang's handling of the code.

Definition at line 24 of file SkSLRewriteIndexedSwizzle.cpp.

                                                                                               {
    // The index expression _must_ have a swizzle base for this transformation to be valid.
    if (!indexExpr.base()->is<Swizzle>()) {
        return nullptr;
    }
    const Swizzle& swizzle = indexExpr.base()->as<Swizzle>();
 
    // Convert the swizzle components to a literal array.
    double vecArray[4];
    for (int index = 0; index < swizzle.components().size(); ++index) {
        vecArray[index] = swizzle.components()[index];
    }
 
    // Make a compound constructor with the literal array.
    const Type& vecType =
            context.fTypes.fInt->toCompound(context, swizzle.components().size(), /*rows=*/1);
    std::unique_ptr<Expression> vec =
            ConstructorCompound::MakeFromConstants(context, indexExpr.fPosition, vecType, vecArray);
 
    // Create a rewritten inner-expression corresponding to `vec(1,2,3)[originalIndex]`.
    std::unique_ptr<Expression> innerExpr = IndexExpression::Make(
            context, indexExpr.fPosition, std::move(vec), indexExpr.index()->clone());
 
    // Return a rewritten outer-expression corresponding to `base[vec(1,2,3)[originalIndex]]`.
    return IndexExpression::Make(
            context, indexExpr.fPosition, swizzle.base()->clone(), std::move(innerExpr));
}