SkSL::ForStatement Class Reference

#include <SkSLForStatement.h>

Inheritance diagram for SkSL::ForStatement:

Public Member Functions
	ForStatement (Position pos, ForLoopPositions forLoopPositions, std::unique_ptr< Statement > initializer, std::unique_ptr< Expression > test, std::unique_ptr< Expression > next, std::unique_ptr< Statement > statement, std::unique_ptr< LoopUnrollInfo > unrollInfo, std::unique_ptr< SymbolTable > symbols)
ForLoopPositions	forLoopPositions () const
std::unique_ptr< Statement > &	initializer ()
const std::unique_ptr< Statement > &	initializer () const
std::unique_ptr< Expression > &	test ()
const std::unique_ptr< Expression > &	test () const
std::unique_ptr< Expression > &	next ()
const std::unique_ptr< Expression > &	next () const
std::unique_ptr< Statement > &	statement ()
const std::unique_ptr< Statement > &	statement () const
SymbolTable *	symbols () const
const LoopUnrollInfo *	unrollInfo () const
std::string	description () const override
Public Member Functions inherited from SkSL::Statement
	Statement (Position pos, Kind kind)
Kind	kind () const
virtual bool	isEmpty () 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< Statement >	Convert (const Context &context, Position pos, ForLoopPositions forLoopPositions, std::unique_ptr< Statement > initializer, std::unique_ptr< Expression > test, std::unique_ptr< Expression > next, std::unique_ptr< Statement > statement, std::unique_ptr< SymbolTable > symbolTable)
static std::unique_ptr< Statement >	ConvertWhile (const Context &context, Position pos, std::unique_ptr< Expression > test, std::unique_ptr< Statement > statement)
static std::unique_ptr< Statement >	Make (const Context &context, Position pos, ForLoopPositions forLoopPositions, std::unique_ptr< Statement > initializer, std::unique_ptr< Expression > test, std::unique_ptr< Expression > next, std::unique_ptr< Statement > statement, std::unique_ptr< LoopUnrollInfo > unrollInfo, std::unique_ptr< SymbolTable > symbolTable)
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::kFor

Additional Inherited Members
Public Types inherited from SkSL::Statement
using	Kind = StatementKind
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 'for' statement.

Definition at line 39 of file SkSLForStatement.h.

Constructor & Destructor Documentation

ForStatement()

SkSL::ForStatement::ForStatement ( Position  pos, ForLoopPositions  forLoopPositions, std::unique_ptr< Statement >  initializer, std::unique_ptr< Expression >  test, std::unique_ptr< Expression >  next, std::unique_ptr< Statement >  statement, std::unique_ptr< LoopUnrollInfo >  unrollInfo, std::unique_ptr< SymbolTable >  symbols  )

inline

Definition at line 43 of file SkSLForStatement.h.

            : INHERITED(pos, kIRNodeKind)
            , fForLoopPositions(forLoopPositions)
            , fSymbolTable(std::move(symbols))
            , fInitializer(std::move(initializer))
            , fTest(std::move(test))
            , fNext(std::move(next))
            , fStatement(std::move(statement))
            , fUnrollInfo(std::move(unrollInfo)) {}

Member Function Documentation

Convert()

std::unique_ptr< Statement > SkSL::ForStatement::Convert ( const Context &  context, Position  pos, ForLoopPositions  forLoopPositions, std::unique_ptr< Statement >  initializer, std::unique_ptr< Expression >  test, std::unique_ptr< Expression >  next, std::unique_ptr< Statement >  statement, std::unique_ptr< SymbolTable >  symbolTable  )

static

Definition at line 102 of file SkSLForStatement.cpp.

                                                                                         {
    bool isSimpleInitializer = is_simple_initializer(initializer.get());
    bool isVardeclBlockInitializer = !isSimpleInitializer &&
                                     is_vardecl_block_initializer(initializer.get());
 
    if (!isSimpleInitializer && !isVardeclBlockInitializer) {
        context.fErrors->error(initializer->fPosition, "invalid for loop initializer");
        return nullptr;
    }
 
    if (test) {
        test = context.fTypes.fBool->coerceExpression(std::move(test), context);
        if (!test) {
            return nullptr;
        }
    }
 
    // The type of the next-expression doesn't matter, but it needs to be a complete expression.
    // Report an error on intermediate expressions like FunctionReference or TypeReference.
    if (next && next->isIncomplete(context)) {
        return nullptr;
    }
 
    std::unique_ptr<LoopUnrollInfo> unrollInfo;
    if (context.fConfig->strictES2Mode()) {
        // In strict-ES2, loops must be unrollable or it's an error.
        unrollInfo = Analysis::GetLoopUnrollInfo(context, pos, positions, initializer.get(), &test,
                                                 next.get(), statement.get(), context.fErrors);
        if (!unrollInfo) {
            return nullptr;
        }
    } else {
        // In ES3, loops don't have to be unrollable, but we can use the unroll information for
        // optimization purposes.
        unrollInfo = Analysis::GetLoopUnrollInfo(context, pos, positions, initializer.get(), &test,
                                                 next.get(), statement.get(), /*errors=*/nullptr);
    }
 
    if (Analysis::DetectVarDeclarationWithoutScope(*statement, context.fErrors)) {
        return nullptr;
    }
 
    if (isVardeclBlockInitializer) {
        // If the initializer statement of a for loop contains multiple variables, this causes
        // difficulties for several of our backends; e.g. Metal doesn't have a way to express arrays
        // of different size in the same decl-stmt, because the array-size is part of the type. It's
        // conceptually equivalent to synthesize a scope, declare the variables, and then emit a for
        // statement with an empty init-stmt. (Note that we can't just do this transformation
        // unilaterally for all for-statements, because the resulting for loop isn't ES2-compliant.)
        std::unique_ptr<SymbolTable> hoistedSymbols = symbolTable->insertNewParent();
        hoist_vardecl_symbols_into_outer_scope(context, initializer->as<Block>(),
                                               symbolTable.get(), hoistedSymbols.get());
        StatementArray scope;
        scope.push_back(std::move(initializer));
        scope.push_back(ForStatement::Make(context,
                                           pos,
                                           positions,
                                           /*initializer=*/nullptr,
                                           std::move(test),
                                           std::move(next),
                                           std::move(statement),
                                           std::move(unrollInfo),
                                           std::move(symbolTable)));
        return Block::Make(pos,
                           std::move(scope),
                           Block::Kind::kBracedScope,
                           std::move(hoistedSymbols));
    }
 
    return ForStatement::Make(context,
                              pos,
                              positions,
                              std::move(initializer),
                              std::move(test),
                              std::move(next),
                              std::move(statement),
                              std::move(unrollInfo),
                              std::move(symbolTable));
}

ConvertWhile()

std::unique_ptr< Statement > SkSL::ForStatement::ConvertWhile ( const Context &  context, Position  pos, std::unique_ptr< Expression >  test, std::unique_ptr< Statement >  statement  )

static

Definition at line 189 of file SkSLForStatement.cpp.

                                                                                          {
    if (context.fConfig->strictES2Mode()) {
        context.fErrors->error(pos, "while loops are not supported");
        return nullptr;
    }
    return ForStatement::Convert(context,
                                 pos,
                                 ForLoopPositions(),
                                 /*initializer=*/nullptr,
                                 std::move(test),
                                 /*next=*/nullptr,
                                 std::move(statement),
                                 /*symbolTable=*/nullptr);
}

description()

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

overridevirtual

Implements SkSL::IRNode.

Definition at line 51 of file SkSLForStatement.cpp.

                                          {
    std::string result("for (");
    if (this->initializer()) {
        result += this->initializer()->description();
    } else {
        result += ";";
    }
    result += " ";
    if (this->test()) {
        result += this->test()->description();
    }
    result += "; ";
    if (this->next()) {
        result += this->next()->description();
    }
    result += ") " + this->statement()->description();
    return result;
}

forLoopPositions()

ForLoopPositions SkSL::ForStatement::forLoopPositions ( ) const

inline

Definition at line 87 of file SkSLForStatement.h.

                                              {
        return fForLoopPositions;
    }

initializer() [1/2]

std::unique_ptr< Statement > & SkSL::ForStatement::initializer ( )

inline

Definition at line 91 of file SkSLForStatement.h.

                                            {
        return fInitializer;
    }

initializer() [2/2]

const std::unique_ptr< Statement > & SkSL::ForStatement::initializer ( ) const

inline

Definition at line 95 of file SkSLForStatement.h.

                                                        {
        return fInitializer;
    }

Make()

std::unique_ptr< Statement > SkSL::ForStatement::Make ( const Context &  context, Position  pos, ForLoopPositions  forLoopPositions, std::unique_ptr< Statement >  initializer, std::unique_ptr< Expression >  test, std::unique_ptr< Expression >  next, std::unique_ptr< Statement >  statement, std::unique_ptr< LoopUnrollInfo >  unrollInfo, std::unique_ptr< SymbolTable >  symbolTable  )

static

Definition at line 207 of file SkSLForStatement.cpp.

                                                                                      {
    SkASSERT(is_simple_initializer(initializer.get()) ||
             is_vardecl_block_initializer(initializer.get()));
    SkASSERT(!test || test->type().matches(*context.fTypes.fBool));
    SkASSERT(!Analysis::DetectVarDeclarationWithoutScope(*statement));
    SkASSERT(unrollInfo || !context.fConfig->strictES2Mode());
 
    // Unrollable loops are easy to optimize because we know initializer, test and next don't have
    // interesting side effects.
    if (unrollInfo) {
        // A zero-iteration unrollable loop can be replaced with Nop.
        // An unrollable loop with an empty body can be replaced with Nop.
        if (unrollInfo->fCount <= 0 || statement->isEmpty()) {
            return Nop::Make();
        }
    }
 
    return std::make_unique<ForStatement>(pos,
                                          positions,
                                          std::move(initializer),
                                          std::move(test),
                                          std::move(next),
                                          std::move(statement),
                                          std::move(unrollInfo),
                                          std::move(symbolTable));
}

next() [1/2]

std::unique_ptr< Expression > & SkSL::ForStatement::next ( )

inline

Definition at line 107 of file SkSLForStatement.h.

                                      {
        return fNext;
    }

next() [2/2]

const std::unique_ptr< Expression > & SkSL::ForStatement::next ( ) const

inline

Definition at line 111 of file SkSLForStatement.h.

                                                  {
        return fNext;
    }

statement() [1/2]

std::unique_ptr< Statement > & SkSL::ForStatement::statement ( )

inline

Definition at line 115 of file SkSLForStatement.h.

                                          {
        return fStatement;
    }

statement() [2/2]

const std::unique_ptr< Statement > & SkSL::ForStatement::statement ( ) const

inline

Definition at line 119 of file SkSLForStatement.h.

                                                      {
        return fStatement;
    }

symbols()

SymbolTable * SkSL::ForStatement::symbols ( ) const

inline

Definition at line 123 of file SkSLForStatement.h.

                                 {
        return fSymbolTable.get();
    }

test() [1/2]

std::unique_ptr< Expression > & SkSL::ForStatement::test ( )

inline

Definition at line 99 of file SkSLForStatement.h.

                                      {
        return fTest;
    }

test() [2/2]

const std::unique_ptr< Expression > & SkSL::ForStatement::test ( ) const

inline

Definition at line 103 of file SkSLForStatement.h.

                                                  {
        return fTest;
    }

unrollInfo()

const LoopUnrollInfo * SkSL::ForStatement::unrollInfo ( ) const

inline

Loop-unroll information is only supported in strict-ES2 code. Null is returned in ES3+.

Definition at line 128 of file SkSLForStatement.h.

                                             {
        return fUnrollInfo.get();
    }

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::ForStatement::kIRNodeKind = Kind::kFor

inlinestaticconstexpr

Definition at line 41 of file SkSLForStatement.h.

---

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

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