SkSL::ConstantFolder Class Reference

#include <SkSLConstantFolder.h>

Static Public Member Functions
static bool	GetConstantInt (const Expression &value, SKSL_INT *out)
static bool	GetConstantValue (const Expression &value, double *out)
static const Expression *	GetConstantValueForVariable (const Expression &value)
static const Expression *	GetConstantValueOrNull (const Expression &value)
static bool	IsConstantSplat (const Expression &expr, double value)
static std::unique_ptr< Expression >	MakeConstantValueForVariable (Position pos, std::unique_ptr< Expression > expr)
static std::unique_ptr< Expression >	Simplify (const Context &context, Position pos, const Expression &left, Operator op, const Expression &right, const Type &resultType)

Detailed Description

Performs constant folding on IR expressions. This simplifies expressions containing compile-time constants, such as replacing Literal(2) + Literal(2) with Literal(4).

Definition at line 27 of file SkSLConstantFolder.h.

Member Function Documentation

GetConstantInt()

bool SkSL::ConstantFolder::GetConstantInt ( const Expression &  value, SKSL_INT *  out  )

static

If value is an int literal or const int variable with a known value, returns true and stores the value in out. Otherwise, returns false.

Definition at line 325 of file SkSLConstantFolder.cpp.

                                                                          {
    const Expression* expr = GetConstantValueForVariable(value);
    if (!expr->isIntLiteral()) {
        return false;
    }
    *out = expr->as<Literal>().intValue();
    return true;
}

GetConstantValue()

bool SkSL::ConstantFolder::GetConstantValue ( const Expression &  value, double *  out  )

static

If value is a literal or const scalar variable with a known value, returns true and stores the value in out. Otherwise, returns false.

Definition at line 334 of file SkSLConstantFolder.cpp.

                                                                          {
    const Expression* expr = GetConstantValueForVariable(value);
    if (!expr->is<Literal>()) {
        return false;
    }
    *out = expr->as<Literal>().value();
    return true;
}

GetConstantValueForVariable()

const Expression * SkSL::ConstantFolder::GetConstantValueForVariable ( const Expression &  value )

static

If the expression is a const variable with a known compile-time-constant value, returns that value. If not, returns the original expression as-is.

Definition at line 461 of file SkSLConstantFolder.cpp.

                                                                                      {
    const Expression* expr = GetConstantValueOrNull(inExpr);
    return expr ? expr : &inExpr;
}

GetConstantValueOrNull()

const Expression * SkSL::ConstantFolder::GetConstantValueOrNull ( const Expression &  value )

static

If the expression can be replaced by a compile-time-constant value, returns that value. If not, returns null.

Definition at line 440 of file SkSLConstantFolder.cpp.

                                                                                 {
    const Expression* expr = &inExpr;
    while (expr->is<VariableReference>()) {
        const VariableReference& varRef = expr->as<VariableReference>();
        if (varRef.refKind() != VariableRefKind::kRead) {
            return nullptr;
        }
        const Variable& var = *varRef.variable();
        if (!var.modifierFlags().isConst()) {
            return nullptr;
        }
        expr = var.initialValue();
        if (!expr) {
            // Generally, const variables must have initial values. However, function parameters are
            // an exception; they can be const but won't have an initial value.
            return nullptr;
        }
    }
    return Analysis::IsCompileTimeConstant(*expr) ? expr : nullptr;
}

IsConstantSplat()

bool SkSL::ConstantFolder::IsConstantSplat ( const Expression &  expr, double  value  )

static

Returns true if the expression contains value in every slot.

Definition at line 354 of file SkSLConstantFolder.cpp.

                                                                         {
    int numSlots = expr.type().slotCount();
    for (int index = 0; index < numSlots; ++index) {
        std::optional<double> slotVal = expr.getConstantValue(index);
        if (!slotVal.has_value() || *slotVal != value) {
            return false;
        }
    }
    return true;
}

MakeConstantValueForVariable()

std::unique_ptr< Expression > SkSL::ConstantFolder::MakeConstantValueForVariable ( Position  pos, std::unique_ptr< Expression >  expr  )

static

If the expression is a const variable with a known compile-time-constant value, returns a clone of that value. If not, returns the original expression as-is.

Definition at line 466 of file SkSLConstantFolder.cpp.

                                                        {
    const Expression* expr = GetConstantValueOrNull(*inExpr);
    return expr ? expr->clone(pos) : std::move(inExpr);
}

Simplify()

std::unique_ptr< Expression > SkSL::ConstantFolder::Simplify ( const Context &  context, Position  pos, const Expression &  left, Operator  op, const Expression &  right, const Type &  resultType  )

static

Simplifies the binary expression left OP right. Returns null if it can't be simplified.

Definition at line 810 of file SkSLConstantFolder.cpp.

                                                                             {
    // Replace constant variables with their literal values.
    const Expression* left = GetConstantValueForVariable(leftExpr);
    const Expression* right = GetConstantValueForVariable(rightExpr);
 
    // If this is the assignment operator, and both sides are the same trivial expression, this is
    // self-assignment (i.e., `var = var`) and can be reduced to just a variable reference (`var`).
    // This can happen when other parts of the assignment are optimized away.
    if (op.kind() == Operator::Kind::EQ && Analysis::IsSameExpressionTree(*left, *right)) {
        return right->clone(pos);
    }
 
    // Simplify the expression when both sides are constant Boolean literals.
    if (left->isBoolLiteral() && right->isBoolLiteral()) {
        bool leftVal  = left->as<Literal>().boolValue();
        bool rightVal = right->as<Literal>().boolValue();
        bool result;
        switch (op.kind()) {
            case Operator::Kind::LOGICALAND: result = leftVal && rightVal; break;
            case Operator::Kind::LOGICALOR:  result = leftVal || rightVal; break;
            case Operator::Kind::LOGICALXOR: result = leftVal ^  rightVal; break;
            case Operator::Kind::EQEQ:       result = leftVal == rightVal; break;
            case Operator::Kind::NEQ:        result = leftVal != rightVal; break;
            default: return nullptr;
        }
        return Literal::MakeBool(context, pos, result);
    }
 
    // If the left side is a Boolean literal, apply short-circuit optimizations.
    if (left->isBoolLiteral()) {
        return short_circuit_boolean(pos, *left, op, *right);
    }
 
    // If the right side is a Boolean literal...
    if (right->isBoolLiteral()) {
        // ... and the left side has no side effects...
        if (!Analysis::HasSideEffects(*left)) {
            // We can reverse the expressions and short-circuit optimizations are still valid.
            return short_circuit_boolean(pos, *right, op, *left);
        }
 
        // We can't use short-circuiting, but we can still optimize away no-op Boolean expressions.
        return eliminate_no_op_boolean(pos, *left, op, *right);
    }
 
    if (op.kind() == Operator::Kind::EQEQ && Analysis::IsSameExpressionTree(*left, *right)) {
        // With == comparison, if both sides are the same trivial expression, this is self-
        // comparison and is always true. (We are not concerned with NaN.)
        return Literal::MakeBool(context, pos, /*value=*/true);
    }
 
    if (op.kind() == Operator::Kind::NEQ && Analysis::IsSameExpressionTree(*left, *right)) {
        // With != comparison, if both sides are the same trivial expression, this is self-
        // comparison and is always false. (We are not concerned with NaN.)
        return Literal::MakeBool(context, pos, /*value=*/false);
    }
 
    if (error_on_divide_by_zero(context, pos, op, *right)) {
        return nullptr;
    }
 
    // Perform full constant folding when both sides are compile-time constants.
    bool leftSideIsConstant = Analysis::IsCompileTimeConstant(*left);
    bool rightSideIsConstant = Analysis::IsCompileTimeConstant(*right);
    if (leftSideIsConstant && rightSideIsConstant) {
        return fold_two_constants(context, pos, left, op, right, resultType);
    }
 
    if (context.fConfig->fSettings.fOptimize) {
        // If just one side is constant, we might still be able to simplify arithmetic expressions
        // like `x * 1`, `x *= 1`, `x + 0`, `x * 0`, `0 / x`, etc.
        if (leftSideIsConstant || rightSideIsConstant) {
            if (std::unique_ptr<Expression> expr = simplify_arithmetic(context, pos, *left, op,
                                                                       *right, resultType)) {
                return expr;
            }
        }
 
        // We can simplify some forms of matrix division even when neither side is constant.
        if (std::unique_ptr<Expression> expr = simplify_matrix_division(context, pos, *left, op,
                                                                        *right, resultType)) {
            return expr;
        }
    }
 
    // We aren't able to constant-fold.
    return nullptr;
}

---

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

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