SkSL::Inliner Class Reference

#include <SkSLInliner.h>

Public Member Functions
	Inliner (const Context *context)
bool	analyze (const std::vector< std::unique_ptr< ProgramElement > > &elements, SymbolTable *symbols, ProgramUsage *usage)

Detailed Description

Converts a FunctionCall in the IR to a set of statements to be injected ahead of the function call, and a replacement expression. Can also detect cases where inlining isn't cleanly possible (e.g. return statements nested inside of a loop construct). The inliner isn't able to guarantee identical-to-GLSL execution order if the inlined function has visible side effects.

Definition at line 44 of file SkSLInliner.h.

Constructor & Destructor Documentation

Inliner()

SkSL::Inliner::Inliner ( const Context *  context )

inline

Definition at line 46 of file SkSLInliner.h.

: fContext(context) {}

Member Function Documentation

analyze()

bool SkSL::Inliner::analyze	(	const std::vector< std::unique_ptr< ProgramElement > > &	elements,
		SymbolTable *	symbols,
		ProgramUsage *	usage
	)

Inlines any eligible functions that are found. Returns true if any changes are made.

Definition at line 1080 of file SkSLInliner.cpp.

                                           {
    // A threshold of zero indicates that the inliner is completely disabled, so we can just return.
    if (this->settings().fInlineThreshold <= 0) {
        return false;
    }
 
    // Enforce a limit on inlining to avoid pathological cases. (inliner/ExponentialGrowth.sksl)
    if (fInlinedStatementCounter >= kInlinedStatementLimit) {
        return false;
    }
 
    InlineCandidateList candidateList;
    this->buildCandidateList(elements, symbols, usage, &candidateList);
 
    // Inline the candidates where we've determined that it's safe to do so.
    using StatementRemappingTable = THashMap<std::unique_ptr<Statement>*,
                                             std::unique_ptr<Statement>*>;
    StatementRemappingTable statementRemappingTable;
 
    bool madeChanges = false;
    for (const InlineCandidate& candidate : candidateList.fCandidates) {
        const FunctionCall& funcCall = (*candidate.fCandidateExpr)->as<FunctionCall>();
 
        // Convert the function call to its inlined equivalent.
        InlinedCall inlinedCall = this->inlineCall(funcCall, candidate.fSymbols, *usage,
                                                   &candidate.fEnclosingFunction->declaration());
 
        // Stop if an error was detected during the inlining process.
        if (!inlinedCall.fInlinedBody && !inlinedCall.fReplacementExpr) {
            break;
        }
 
        // Ensure that the inlined body has a scope if it needs one.
        this->ensureScopedBlocks(inlinedCall.fInlinedBody.get(), candidate.fParentStmt->get());
 
        // Add references within the inlined body
        usage->add(inlinedCall.fInlinedBody.get());
 
        // Look up the enclosing statement; remap it if necessary.
        std::unique_ptr<Statement>* enclosingStmt = candidate.fEnclosingStmt;
        for (;;) {
            std::unique_ptr<Statement>** remappedStmt = statementRemappingTable.find(enclosingStmt);
            if (!remappedStmt) {
                break;
            }
            enclosingStmt = *remappedStmt;
        }
 
        // Move the enclosing statement to the end of the unscoped Block containing the inlined
        // function, then replace the enclosing statement with that Block.
        // Before:
        //     fInlinedBody = Block{ stmt1, stmt2, stmt3 }
        //     fEnclosingStmt = stmt4
        // After:
        //     fInlinedBody = null
        //     fEnclosingStmt = Block{ stmt1, stmt2, stmt3, stmt4 }
        inlinedCall.fInlinedBody->children().push_back(std::move(*enclosingStmt));
        *enclosingStmt = std::move(inlinedCall.fInlinedBody);
 
        // Replace the candidate function call with our replacement expression.
        usage->remove(candidate.fCandidateExpr->get());
        usage->add(inlinedCall.fReplacementExpr.get());
        *candidate.fCandidateExpr = std::move(inlinedCall.fReplacementExpr);
        madeChanges = true;
 
        // If anything else pointed at our enclosing statement, it's now pointing at a Block
        // containing many other statements as well. Maintain a fix-up table to account for this.
        statementRemappingTable.set(enclosingStmt,&(*enclosingStmt)->as<Block>().children().back());
 
        // Stop inlining if we've reached our hard cap on new statements.
        if (fInlinedStatementCounter >= kInlinedStatementLimit) {
            break;
        }
 
        // Note that nothing was destroyed except for the FunctionCall. All other nodes should
        // remain valid.
    }
 
    return madeChanges;
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/sksl/SkSLInliner.h
• third_party/skia/src/sksl/SkSLInliner.cpp