SkSL::FunctionDefinition Class Reference

#include <SkSLFunctionDefinition.h>

Inheritance diagram for SkSL::FunctionDefinition:

Public Member Functions
	FunctionDefinition (Position pos, const FunctionDeclaration *declaration, bool builtin, std::unique_ptr< Statement > body)
const FunctionDeclaration &	declaration () const
bool	isBuiltin () const
std::unique_ptr< Statement > &	body ()
const std::unique_ptr< Statement > &	body () const
std::string	description () const override
Public Member Functions inherited from SkSL::ProgramElement
	ProgramElement (Position pos, Kind kind)
Kind	kind () const
Public Member Functions inherited from SkSL::IRNode
virtual	~IRNode ()
	IRNode (const IRNode &)=delete
IRNode &	operator= (const IRNode &)=delete
Position	position () const
void	setPosition (Position p)
template<typename T >
bool	is () const
template<typename T >
const T &	as () const
template<typename T >
T &	as ()

Static Public Member Functions
static std::unique_ptr< FunctionDefinition >	Convert (const Context &context, Position pos, const FunctionDeclaration &function, std::unique_ptr< Statement > body, bool builtin)
static std::unique_ptr< FunctionDefinition >	Make (const Context &context, Position pos, const FunctionDeclaration &function, std::unique_ptr< Statement > body, bool builtin)
Static Public Member Functions inherited from SkSL::Poolable
static void *	operator new (const size_t size)
static void	operator delete (void *ptr)

Static Public Attributes
static constexpr Kind	kIRNodeKind = Kind::kFunction

Additional Inherited Members
Public Types inherited from SkSL::ProgramElement
using	Kind = ProgramElementKind
Public Attributes inherited from SkSL::IRNode
Position	fPosition
Protected Member Functions inherited from SkSL::IRNode
	IRNode (Position position, int kind)
Protected Attributes inherited from SkSL::IRNode
int	fKind

Detailed Description

A function definition (a declaration plus an associated block of code).

Definition at line 28 of file SkSLFunctionDefinition.h.

Constructor & Destructor Documentation

FunctionDefinition()

SkSL::FunctionDefinition::FunctionDefinition ( Position  pos, const FunctionDeclaration *  declaration, bool  builtin, std::unique_ptr< Statement >  body  )

inline

Definition at line 32 of file SkSLFunctionDefinition.h.

            : INHERITED(pos, kIRNodeKind)
            , fDeclaration(declaration)
            , fBuiltin(builtin)
            , fBody(std::move(body)) {}

Member Function Documentation

body() [1/2]

std::unique_ptr< Statement > & SkSL::FunctionDefinition::body ( )

inline

Definition at line 74 of file SkSLFunctionDefinition.h.

                                     {
        return fBody;
    }

body() [2/2]

const std::unique_ptr< Statement > & SkSL::FunctionDefinition::body ( ) const

inline

Definition at line 78 of file SkSLFunctionDefinition.h.

                                                 {
        return fBody;
    }

Convert()

std::unique_ptr< FunctionDefinition > SkSL::FunctionDefinition::Convert ( const Context &  context, Position  pos, const FunctionDeclaration &  function, std::unique_ptr< Statement >  body, bool  builtin  )

static

Coerces return statements to the return type of the function, and reports errors in the function that can't be detected at the individual statement level:

- `break` and `continue` statements must be in reasonable places.
- Non-void functions are required to return a value on all paths.
- Vertex main() functions don't allow early returns.
- Limits on overall stack size are enforced.

This will return a FunctionDefinition even if an error is detected; this leads to better diagnostics overall. (Returning null here leads to spurious "function 'f()' was not defined" errors when trying to call a function with an error in it.)

Definition at line 88 of file SkSLFunctionDefinition.cpp.

                                                                              {
    class Finalizer : public ProgramWriter {
    public:
        Finalizer(const Context& context, const FunctionDeclaration& function, Position pos)
            : fContext(context)
            , fFunction(function) {
            // Function parameters count as local variables.
            for (const Variable* var : function.parameters()) {
                this->addLocalVariable(var, pos);
            }
        }
 
        ~Finalizer() override {
            SkASSERT(fBreakableLevel == 0);
            SkASSERT(fContinuableLevel == std::forward_list<int>{0});
        }
 
        void addLocalVariable(const Variable* var, Position pos) {
            if (var->type().isOrContainsUnsizedArray()) {
                fContext.fErrors->error(pos, "unsized arrays are not permitted here");
                return;
            }
            // We count the number of slots used, but don't consider the precision of the base type.
            // In practice, this reflects what GPUs actually do pretty well. (i.e., RelaxedPrecision
            // math doesn't mean your variable takes less space.) We also don't attempt to reclaim
            // slots at the end of a Block.
            size_t prevSlotsUsed = fSlotsUsed;
            fSlotsUsed = SkSafeMath::Add(fSlotsUsed, var->type().slotCount());
            // To avoid overzealous error reporting, only trigger the error at the first
            // place where the stack limit is exceeded.
            if (prevSlotsUsed < kVariableSlotLimit && fSlotsUsed >= kVariableSlotLimit) {
                fContext.fErrors->error(pos, "variable '" + std::string(var->name()) +
                                             "' exceeds the stack size limit");
            }
        }
 
        void fuseVariableDeclarationsWithInitialization(std::unique_ptr<Statement>& stmt) {
            switch (stmt->kind()) {
                case Statement::Kind::kNop:
                case Statement::Kind::kBlock:
                    // Blocks and no-ops are inert; it is safe to fuse a variable declaration with
                    // its initialization across a nop or an open-brace, so we don't null out
                    // `fUninitializedVarDecl` here.
                    break;
 
                case Statement::Kind::kVarDeclaration:
                    // Look for variable declarations without an initializer.
                    if (VarDeclaration& decl = stmt->as<VarDeclaration>(); !decl.value()) {
                        fUninitializedVarDecl = &decl;
                        break;
                    }
                    [[fallthrough]];
 
                default:
                    // We found an intervening statement; it's not safe to fuse a declaration
                    // with an initializer if we encounter any other code.
                    fUninitializedVarDecl = nullptr;
                    break;
 
                case Statement::Kind::kExpression: {
                    // We found an expression-statement. If there was a variable declaration
                    // immediately above it, it might be possible to fuse them.
                    if (fUninitializedVarDecl) {
                        VarDeclaration* vardecl = fUninitializedVarDecl;
                        fUninitializedVarDecl = nullptr;
 
                        std::unique_ptr<Expression>& nextExpr = stmt->as<ExpressionStatement>()
                                                                     .expression();
                        // This statement must be a binary-expression...
                        if (!nextExpr->is<BinaryExpression>()) {
                            break;
                        }
                        // ... performing simple `var = expr` assignment...
                        BinaryExpression& binaryExpr = nextExpr->as<BinaryExpression>();
                        if (binaryExpr.getOperator().kind() != OperatorKind::EQ) {
                            break;
                        }
                        // ... directly into the variable (not a field/swizzle)...
                        Expression& leftExpr = *binaryExpr.left();
                        if (!leftExpr.is<VariableReference>()) {
                            break;
                        }
                        // ... and it must be the same variable as our vardecl.
                        VariableReference& varRef = leftExpr.as<VariableReference>();
                        if (varRef.variable() != vardecl->var()) {
                            break;
                        }
                        // The init-expression must not reference the variable.
                        // `int x; x = x = 0;` is legal SkSL, but `int x = x = 0;` is not.
                        if (Analysis::ContainsVariable(*binaryExpr.right(), *varRef.variable())) {
                            break;
                        }
                        // We found a match! Move the init-expression directly onto the vardecl, and
                        // turn the assignment into a no-op.
                        vardecl->value() = std::move(binaryExpr.right());
 
                        // Turn the expression-statement into a no-op.
                        stmt = Nop::Make();
                    }
                    break;
                }
            }
        }
 
        bool functionReturnsValue() const {
            return !fFunction.returnType().isVoid();
        }
 
        bool visitExpressionPtr(std::unique_ptr<Expression>& expr) override {
            // We don't need to scan expressions.
            return false;
        }
 
        bool visitStatementPtr(std::unique_ptr<Statement>& stmt) override {
            // When the optimizer is on, we look for variable declarations that are immediately
            // followed by an initialization expression, and fuse them into one statement.
            // (e.g.: `int i; i = 1;` can become `int i = 1;`)
            if (fContext.fConfig->fSettings.fOptimize) {
                this->fuseVariableDeclarationsWithInitialization(stmt);
            }
 
            // Perform error checking.
            switch (stmt->kind()) {
                case Statement::Kind::kVarDeclaration:
                    this->addLocalVariable(stmt->as<VarDeclaration>().var(), stmt->fPosition);
                    break;
 
                case Statement::Kind::kReturn: {
                    // Early returns from a vertex main() function will bypass sk_Position
                    // normalization, so SkASSERT that we aren't doing that. If this becomes an
                    // issue, we can add normalization before each return statement.
                    if (ProgramConfig::IsVertex(fContext.fConfig->fKind) && fFunction.isMain()) {
                        fContext.fErrors->error(
                                stmt->fPosition,
                                "early returns from vertex programs are not supported");
                    }
 
                    // Verify that the return statement matches the function's return type.
                    ReturnStatement& returnStmt = stmt->as<ReturnStatement>();
                    if (returnStmt.expression()) {
                        if (this->functionReturnsValue()) {
                            // Coerce return expression to the function's return type.
                            returnStmt.setExpression(fFunction.returnType().coerceExpression(
                                    std::move(returnStmt.expression()), fContext));
                        } else {
                            // Returning something from a function with a void return type.
                            fContext.fErrors->error(returnStmt.expression()->fPosition,
                                                    "may not return a value from a void function");
                            returnStmt.setExpression(nullptr);
                        }
                    } else {
                        if (this->functionReturnsValue()) {
                            // Returning nothing from a function with a non-void return type.
                            fContext.fErrors->error(returnStmt.fPosition,
                                                    "expected function to return '" +
                                                    fFunction.returnType().displayName() + "'");
                        }
                    }
                    break;
                }
                case Statement::Kind::kDo:
                case Statement::Kind::kFor: {
                    ++fBreakableLevel;
                    ++fContinuableLevel.front();
                    bool result = INHERITED::visitStatementPtr(stmt);
                    --fContinuableLevel.front();
                    --fBreakableLevel;
                    return result;
                }
                case Statement::Kind::kSwitch: {
                    ++fBreakableLevel;
                    fContinuableLevel.push_front(0);
                    bool result = INHERITED::visitStatementPtr(stmt);
                    fContinuableLevel.pop_front();
                    --fBreakableLevel;
                    return result;
                }
                case Statement::Kind::kBreak:
                    if (fBreakableLevel == 0) {
                        fContext.fErrors->error(stmt->fPosition,
                                                "break statement must be inside a loop or switch");
                    }
                    break;
 
                case Statement::Kind::kContinue:
                    if (fContinuableLevel.front() == 0) {
                        if (std::any_of(fContinuableLevel.begin(),
                                        fContinuableLevel.end(),
                                        [](int level) { return level > 0; })) {
                            fContext.fErrors->error(stmt->fPosition,
                                                   "continue statement cannot be used in a switch");
                        } else {
                            fContext.fErrors->error(stmt->fPosition,
                                                    "continue statement must be inside a loop");
                        }
                    }
                    break;
 
                default:
                    break;
            }
            return INHERITED::visitStatementPtr(stmt);
        }
 
    private:
        const Context& fContext;
        const FunctionDeclaration& fFunction;
        // how deeply nested we are in breakable constructs (for, do, switch).
        int fBreakableLevel = 0;
        // number of slots consumed by all variables declared in the function
        size_t fSlotsUsed = 0;
        // how deeply nested we are in continuable constructs (for, do).
        // We keep a stack (via a forward_list) in order to disallow continue inside of switch.
        std::forward_list<int> fContinuableLevel{0};
        // We track uninitialized variable declarations, and if they are immediately assigned-to,
        // we can move the assignment directly into the decl.
        VarDeclaration* fUninitializedVarDecl = nullptr;
 
        using INHERITED = ProgramWriter;
    };
 
    // We don't allow modules to define actual functions with intrinsic names. (Those should be
    // reserved for actual intrinsics.)
    if (function.isIntrinsic()) {
        context.fErrors->error(function.fPosition, "Intrinsic function '" +
                                                   std::string(function.name()) +
                                                   "' should not have a definition");
        return nullptr;
    }
 
    // A function body must always be a braced block. (The parser should enforce this already, but
    // we rely on it, so it's best to be certain.)
    if (!body || !body->is<Block>() || !body->as<Block>().isScope()) {
        context.fErrors->error(function.fPosition, "function body '" + function.description() +
                                                   "' must be a braced block");
        return nullptr;
    }
 
    // A function can't have more than one definition.
    if (function.definition()) {
        context.fErrors->error(function.fPosition, "function '" + function.description() +
                                                   "' was already defined");
        return nullptr;
    }
 
    // Run the function finalizer. This checks for illegal constructs and missing return statements,
    // and also performs some simple code cleanup.
    Finalizer(context, function, pos).visitStatementPtr(body);
    if (function.isMain() && ProgramConfig::IsVertex(context.fConfig->fKind)) {
        append_rtadjust_fixup_to_vertex_main(context, function, body->as<Block>());
    }
 
    if (Analysis::CanExitWithoutReturningValue(function, *body)) {
        context.fErrors->error(body->fPosition, "function '" + std::string(function.name()) +
                                                "' can exit without returning a value");
    }
 
    return FunctionDefinition::Make(context, pos, function, std::move(body), builtin);
}

declaration()

const FunctionDeclaration & SkSL::FunctionDefinition::declaration ( ) const

inline

Definition at line 66 of file SkSLFunctionDefinition.h.

                                                   {
        return *fDeclaration;
    }

description()

std::string SkSL::FunctionDefinition::description ( ) const

inlineoverridevirtual

Implements SkSL::IRNode.

Definition at line 82 of file SkSLFunctionDefinition.h.

                                           {
        return this->declaration().description() + " " + this->body()->description();
    }

isBuiltin()

bool SkSL::FunctionDefinition::isBuiltin ( ) const

inline

Definition at line 70 of file SkSLFunctionDefinition.h.

                           {
        return fBuiltin;
    }

Make()

std::unique_ptr< FunctionDefinition > SkSL::FunctionDefinition::Make ( const Context &  context, Position  pos, const FunctionDeclaration &  function, std::unique_ptr< Statement >  body, bool  builtin  )

static

Definition at line 352 of file SkSLFunctionDefinition.cpp.

                                                                           {
    SkASSERT(!function.isIntrinsic());
    SkASSERT(body && body->as<Block>().isScope());
    SkASSERT(!function.definition());
 
    return std::make_unique<FunctionDefinition>(pos, &function, builtin, std::move(body));
}

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::FunctionDefinition::kIRNodeKind = Kind::kFunction

inlinestaticconstexpr

Definition at line 30 of file SkSLFunctionDefinition.h.

---

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

• third_party/skia/src/sksl/ir/SkSLFunctionDefinition.h
• third_party/skia/src/sksl/ir/SkSLFunctionDefinition.cpp