blob: 785a2c9bc32dd9db08ee672c0ff405f13affb08b [file] [log] [blame]
* Copyright 2020 Google LLC
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
#include <memory>
#include <unordered_map>
#include "src/sksl/ir/SkSLProgram.h"
#include "src/sksl/ir/SkSLVariableReference.h"
namespace SkSL {
class Block;
class Context;
class Expression;
class FunctionCall;
class FunctionDefinition;
struct InlineCandidate;
struct InlineCandidateList;
class ModifiersPool;
class Statement;
class SymbolTable;
class Variable;
* 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.
class Inliner {
Inliner(const Context* context, const ShaderCapsClass* caps) : fContext(context), fCaps(caps) {}
void reset(ModifiersPool* modifiers, const Program::Settings*);
* Processes the passed-in FunctionCall expression. The FunctionCall expression should be
* replaced with `fReplacementExpr`. If non-null, `fInlinedBody` should be inserted immediately
* above the statement containing the inlined expression.
struct InlinedCall {
std::unique_ptr<Block> fInlinedBody;
std::unique_ptr<Expression> fReplacementExpr;
InlinedCall inlineCall(FunctionCall*, SymbolTable*, const FunctionDeclaration* caller);
/** Adds a scope to inlined bodies returned by `inlineCall`, if one is required. */
void ensureScopedBlocks(Statement* inlinedBody, Statement* parentStmt);
/** Checks whether inlining is viable for a FunctionCall, modulo recursion and function size. */
bool isSafeToInline(const FunctionDefinition* functionDef);
/** Checks whether a function's size exceeds the inline threshold from Settings. */
bool isLargeFunction(const FunctionDefinition* functionDef);
/** Inlines any eligible functions that are found. Returns true if any changes are made. */
bool analyze(const std::vector<std::unique_ptr<ProgramElement>>& elements,
SymbolTable* symbols,
ProgramUsage* usage);
using VariableRewriteMap = std::unordered_map<const Variable*, std::unique_ptr<Expression>>;
String uniqueNameForInlineVar(const String& baseName, SymbolTable* symbolTable);
void buildCandidateList(const std::vector<std::unique_ptr<ProgramElement>>& elements,
SymbolTable* symbols,
InlineCandidateList* candidateList);
std::unique_ptr<Expression> inlineExpression(int offset,
VariableRewriteMap* varMap,
const Expression& expression);
std::unique_ptr<Statement> inlineStatement(int offset,
VariableRewriteMap* varMap,
SymbolTable* symbolTableForStatement,
const Expression* resultExpr,
bool haveEarlyReturns,
const Statement& statement,
bool isBuiltinCode);
using InlinabilityCache = std::unordered_map<const FunctionDeclaration*, bool>;
bool candidateCanBeInlined(const InlineCandidate& candidate, InlinabilityCache* cache);
using LargeFunctionCache = std::unordered_map<const FunctionDeclaration*, bool>;
bool isLargeFunction(const InlineCandidate& candidate, LargeFunctionCache* cache);
const Context* fContext = nullptr;
ModifiersPool* fModifiers = nullptr;
const Program::Settings* fSettings = nullptr;
const ShaderCapsClass* fCaps = nullptr;
int fInlineVarCounter = 0;
int fInlinedStatementCounter = 0;
} // namespace SkSL
#endif // SKSL_INLINER