SkSL::IndexExpression Class Reference

#include <SkSLIndexExpression.h>

Inheritance diagram for SkSL::IndexExpression:

Public Types
using	INHERITED = Expression
Public Types inherited from SkSL::Expression
enum class	ComparisonResult { kUnknown = -1 , kNotEqual , kEqual }
using	Kind = ExpressionKind

Public Member Functions
	IndexExpression (const Context &context, Position pos, std::unique_ptr< Expression > base, std::unique_ptr< Expression > index)
std::unique_ptr< Expression > &	base ()
const std::unique_ptr< Expression > &	base () const
std::unique_ptr< Expression > &	index ()
const std::unique_ptr< Expression > &	index () const
std::unique_ptr< Expression >	clone (Position pos) const override
std::string	description (OperatorPrecedence) const override
Public Member Functions inherited from SkSL::Expression
	Expression (Position pos, Kind kind, const Type *type)
Kind	kind () const
virtual const Type &	type () const
bool	isAnyConstructor () const
bool	isIntLiteral () const
bool	isFloatLiteral () const
bool	isBoolLiteral () const
AnyConstructor &	asAnyConstructor ()
const AnyConstructor &	asAnyConstructor () const
bool	isIncomplete (const Context &context) const
virtual ComparisonResult	compareConstant (const Expression &other) const
CoercionCost	coercionCost (const Type &target) const
virtual bool	supportsConstantValues () const
virtual std::optional< double >	getConstantValue (int n) const
std::unique_ptr< Expression >	clone () const
std::string	description () const final
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< Expression >	Convert (const Context &context, Position pos, std::unique_ptr< Expression > base, std::unique_ptr< Expression > index)
static std::unique_ptr< Expression >	Make (const Context &context, Position pos, std::unique_ptr< Expression > base, std::unique_ptr< Expression > index)
static const Type &	IndexType (const Context &context, const Type &type)
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::kIndex

Additional Inherited Members
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

An expression which extracts a value from an array, vector or matrix, as in 'm[2]'.

Definition at line 29 of file SkSLIndexExpression.h.

Member Typedef Documentation

INHERITED

using SkSL::IndexExpression::INHERITED = Expression

Definition at line 80 of file SkSLIndexExpression.h.

Constructor & Destructor Documentation

IndexExpression()

SkSL::IndexExpression::IndexExpression ( const Context &  context, Position  pos, std::unique_ptr< Expression >  base, std::unique_ptr< Expression >  index  )

inline

Definition at line 33 of file SkSLIndexExpression.h.

        : INHERITED(pos, kIRNodeKind, &IndexType(context, base->type()))
        , fBase(std::move(base))
        , fIndex(std::move(index)) {}

Member Function Documentation

base() [1/2]

std::unique_ptr< Expression > & SkSL::IndexExpression::base ( )

inline

Definition at line 56 of file SkSLIndexExpression.h.

                                      {
        return fBase;
    }

base() [2/2]

const std::unique_ptr< Expression > & SkSL::IndexExpression::base ( ) const

inline

Definition at line 60 of file SkSLIndexExpression.h.

                                                  {
        return fBase;
    }

clone()

std::unique_ptr< Expression > SkSL::IndexExpression::clone ( Position  pos ) const

inlineoverridevirtual

Implements SkSL::Expression.

Definition at line 72 of file SkSLIndexExpression.h.

                                                                 {
        return std::unique_ptr<Expression>(new IndexExpression(pos, this->base()->clone(),
                                                               this->index()->clone(),
                                                               &this->type()));
    }

Convert()

std::unique_ptr< Expression > SkSL::IndexExpression::Convert ( const Context &  context, Position  pos, std::unique_ptr< Expression >  base, std::unique_ptr< Expression >  index  )

static

Definition at line 67 of file SkSLIndexExpression.cpp.

                                                                                      {
    // Convert an array type reference: `int[10]`.
    if (base->is<TypeReference>()) {
        const Type& baseType = base->as<TypeReference>().value();
        SKSL_INT arraySize = baseType.convertArraySize(context, pos, std::move(index));
        if (!arraySize) {
            return nullptr;
        }
        return TypeReference::Convert(
                context,
                pos,
                context.fSymbolTable->addArrayDimension(context, &baseType, arraySize));
    }
    // Convert an index expression with an expression inside of it: `arr[a * 3]`.
    const Type& baseType = base->type();
    if (!baseType.isArray() && !baseType.isMatrix() && !baseType.isVector()) {
        context.fErrors->error(base->fPosition,
                               "expected array, but found '" + baseType.displayName() + "'");
        return nullptr;
    }
    if (!index->type().isInteger()) {
        index = context.fTypes.fInt->coerceExpression(std::move(index), context);
        if (!index) {
            return nullptr;
        }
    }
    // Perform compile-time bounds checking on constant-expression indices.
    const Expression* indexExpr = ConstantFolder::GetConstantValueForVariable(*index);
    if (indexExpr->isIntLiteral()) {
        SKSL_INT indexValue = indexExpr->as<Literal>().intValue();
        if (index_out_of_range(context, index->fPosition, indexValue, *base)) {
            return nullptr;
        }
    }
    return IndexExpression::Make(context, pos, std::move(base), std::move(index));
}

description()

std::string SkSL::IndexExpression::description ( OperatorPrecedence  ) const

overridevirtual

Implements SkSL::Expression.

Definition at line 172 of file SkSLIndexExpression.cpp.

                                                               {
    return this->base()->description(OperatorPrecedence::kPostfix) + "[" +
           this->index()->description(OperatorPrecedence::kExpression) + "]";
}

index() [1/2]

std::unique_ptr< Expression > & SkSL::IndexExpression::index ( )

inline

Definition at line 64 of file SkSLIndexExpression.h.

                                       {
        return fIndex;
    }

index() [2/2]

const std::unique_ptr< Expression > & SkSL::IndexExpression::index ( ) const

inline

Definition at line 68 of file SkSLIndexExpression.h.

                                                   {
        return fIndex;
    }

IndexType()

const Type & SkSL::IndexExpression::IndexType ( const Context &  context, const Type &  type  )

static

Given a type, returns the type that will result from extracting an array value from it.

Definition at line 46 of file SkSLIndexExpression.cpp.

                                                                               {
    if (type.isMatrix()) {
        if (type.componentType().matches(*context.fTypes.fFloat)) {
            switch (type.rows()) {
                case 2: return *context.fTypes.fFloat2;
                case 3: return *context.fTypes.fFloat3;
                case 4: return *context.fTypes.fFloat4;
                default: SkASSERT(false);
            }
        } else if (type.componentType().matches(*context.fTypes.fHalf)) {
            switch (type.rows()) {
                case 2: return *context.fTypes.fHalf2;
                case 3: return *context.fTypes.fHalf3;
                case 4: return *context.fTypes.fHalf4;
                default: SkASSERT(false);
            }
        }
    }
    return type.componentType();
}

Make()

std::unique_ptr< Expression > SkSL::IndexExpression::Make ( const Context &  context, Position  pos, std::unique_ptr< Expression >  base, std::unique_ptr< Expression >  index  )

static

Definition at line 107 of file SkSLIndexExpression.cpp.

                                                                                   {
    const Type& baseType = base->type();
    SkASSERT(baseType.isArray() || baseType.isMatrix() || baseType.isVector());
    SkASSERT(index->type().isInteger());
 
    const Expression* indexExpr = ConstantFolder::GetConstantValueForVariable(*index);
    if (indexExpr->isIntLiteral()) {
        SKSL_INT indexValue = indexExpr->as<Literal>().intValue();
        if (!index_out_of_range(context, index->fPosition, indexValue, *base)) {
            if (baseType.isVector()) {
                // Constant array indexes on vectors can be converted to swizzles: `v[2]` --> `v.z`.
                // Swizzling is harmless and can unlock further simplifications for some base types.
                return Swizzle::Make(context, pos, std::move(base),
                        ComponentArray{(int8_t)indexValue});
            }
 
            if (baseType.isArray() && !Analysis::HasSideEffects(*base)) {
                // Indexing an constant array constructor with a constant index can just pluck out
                // the requested value from the array.
                const Expression* baseExpr = ConstantFolder::GetConstantValueForVariable(*base);
                if (baseExpr->is<ConstructorArray>()) {
                    const ConstructorArray& arrayCtor = baseExpr->as<ConstructorArray>();
                    const ExpressionArray& arguments = arrayCtor.arguments();
                    SkASSERT(arguments.size() == baseType.columns());
 
                    return arguments[indexValue]->clone(pos);
                }
            }
 
            if (baseType.isMatrix() && !Analysis::HasSideEffects(*base)) {
                // Matrices can be constructed with vectors that don't line up on column boundaries,
                // so extracting out the values from the constructor can be tricky. Fortunately, we
                // can reconstruct an equivalent vector using `getConstantValue`. If we
                // can't extract the data using `getConstantValue`, it wasn't constant and
                // we're not obligated to simplify anything.
                const Expression* baseExpr = ConstantFolder::GetConstantValueForVariable(*base);
                int vecWidth = baseType.rows();
                const Type& vecType = baseType.columnType(context);
                indexValue *= vecWidth;
 
                double ctorArgs[4];
                bool allConstant = true;
                for (int slot = 0; slot < vecWidth; ++slot) {
                    std::optional<double> slotVal = baseExpr->getConstantValue(indexValue + slot);
                    if (slotVal.has_value()) {
                        ctorArgs[slot] = *slotVal;
                    } else {
                        allConstant = false;
                        break;
                    }
                }
 
                if (allConstant) {
                    return ConstructorCompound::MakeFromConstants(context, pos, vecType, ctorArgs);
                }
            }
        }
    }
 
    return std::make_unique<IndexExpression>(context, pos, std::move(base), std::move(index));
}

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::IndexExpression::kIRNodeKind = Kind::kIndex

inlinestaticconstexpr

Definition at line 31 of file SkSLIndexExpression.h.

---

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

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