SkSL::RP::Generator Class Reference

Classes
struct	TypedOps

Public Types
using	ImmutableBits = int32_t

Public Member Functions
	Generator (const SkSL::Program &program, DebugTracePriv *debugTrace, bool writeTraceOps)
	~Generator ()
bool	writeProgram (const FunctionDefinition &function)
std::unique_ptr< RP::Program >	finish ()
std::optional< SlotRange >	writeFunction (const IRNode &callSite, const FunctionDefinition &function, SkSpan< std::unique_ptr< Expression > const > arguments)
int	getFunctionDebugInfo (const FunctionDeclaration &decl)
bool	hasVariableSlots (const Variable &v)
SlotRange	getVariableSlots (const Variable &v)
SlotRange	getImmutableSlots (const Variable &v)
SlotRange	getUniformSlots (const Variable &v)
SlotRange	getFunctionSlots (const IRNode &callSite, const FunctionDeclaration &f)
int	createStack ()
void	recycleStack (int stackID)
void	setCurrentStack (int stackID)
int	currentStack ()
std::unique_ptr< LValue >	makeLValue (const Expression &e, bool allowScratch=false)
bool	store (LValue &lvalue)
bool	push (LValue &lvalue)
Builder *	builder ()
bool	writeStatement (const Statement &s)
bool	writeBlock (const Block &b)
bool	writeBreakStatement (const BreakStatement &b)
bool	writeContinueStatement (const ContinueStatement &b)
bool	writeDoStatement (const DoStatement &d)
bool	writeExpressionStatement (const ExpressionStatement &e)
bool	writeMasklessForStatement (const ForStatement &f)
bool	writeForStatement (const ForStatement &f)
bool	writeGlobals ()
bool	writeIfStatement (const IfStatement &i)
bool	writeDynamicallyUniformIfStatement (const IfStatement &i)
bool	writeReturnStatement (const ReturnStatement &r)
bool	writeSwitchStatement (const SwitchStatement &s)
bool	writeVarDeclaration (const VarDeclaration &v)
bool	writeImmutableVarDeclaration (const VarDeclaration &d)
bool	pushBinaryExpression (const BinaryExpression &e)
bool	pushBinaryExpression (const Expression &left, Operator op, const Expression &right)
bool	pushChildCall (const ChildCall &c)
bool	pushConstructorCast (const AnyConstructor &c)
bool	pushConstructorCompound (const AnyConstructor &c)
bool	pushConstructorDiagonalMatrix (const ConstructorDiagonalMatrix &c)
bool	pushConstructorMatrixResize (const ConstructorMatrixResize &c)
bool	pushConstructorSplat (const ConstructorSplat &c)
bool	pushExpression (const Expression &e, bool usesResult=true)
bool	pushFieldAccess (const FieldAccess &f)
bool	pushFunctionCall (const FunctionCall &c)
bool	pushIndexExpression (const IndexExpression &i)
bool	pushIntrinsic (const FunctionCall &c)
bool	pushIntrinsic (IntrinsicKind intrinsic, const Expression &arg0)
bool	pushIntrinsic (IntrinsicKind intrinsic, const Expression &arg0, const Expression &arg1)
bool	pushIntrinsic (IntrinsicKind intrinsic, const Expression &arg0, const Expression &arg1, const Expression &arg2)
bool	pushLiteral (const Literal &l)
bool	pushPostfixExpression (const PostfixExpression &p, bool usesResult)
bool	pushPrefixExpression (const PrefixExpression &p)
bool	pushPrefixExpression (Operator op, const Expression &expr)
bool	pushSwizzle (const Swizzle &s)
bool	pushTernaryExpression (const TernaryExpression &t)
bool	pushTernaryExpression (const Expression &test, const Expression &ifTrue, const Expression &ifFalse)
bool	pushDynamicallyUniformTernaryExpression (const Expression &test, const Expression &ifTrue, const Expression &ifFalse)
bool	pushVariableReference (const VariableReference &v)
bool	pushImmutableData (const Expression &e)
std::optional< SlotRange >	findPreexistingImmutableData (const TArray< ImmutableBits > &immutableValues)
std::optional< ImmutableBits >	getImmutableBitsForSlot (const Expression &expr, size_t slot)
bool	getImmutableValueForExpression (const Expression &expr, TArray< ImmutableBits > *immutableValues)
void	storeImmutableValueToSlots (const TArray< ImmutableBits > &immutableValues, SlotRange slots)
void	popToSlotRange (SlotRange r)
void	popToSlotRangeUnmasked (SlotRange r)
void	discardExpression (int slots)
void	zeroSlotRangeUnmasked (SlotRange r)
void	emitTraceLine (Position pos)
void	pushTraceScopeMask ()
void	discardTraceScopeMask ()
void	emitTraceScope (int delta)
void	calculateLineOffsets ()
bool	shouldWriteTraceOps ()
int	traceMaskStackID ()
bool	unaryOp (const SkSL::Type &type, const TypedOps &ops)
bool	binaryOp (const SkSL::Type &type, const TypedOps &ops)
bool	ternaryOp (const SkSL::Type &type, const TypedOps &ops)
bool	pushIntrinsic (const TypedOps &ops, const Expression &arg0)
bool	pushIntrinsic (const TypedOps &ops, const Expression &arg0, const Expression &arg1)
bool	pushIntrinsic (BuilderOp builderOp, const Expression &arg0)
bool	pushIntrinsic (BuilderOp builderOp, const Expression &arg0, const Expression &arg1)
bool	pushAbsFloatIntrinsic (int slots)
bool	pushLengthIntrinsic (int slotCount)
bool	pushVectorizedExpression (const Expression &expr, const Type &vectorType)
bool	pushVariableReferencePartial (const VariableReference &v, SlotRange subset)
bool	pushLValueOrExpression (LValue *lvalue, const Expression &expr)
bool	pushMatrixMultiply (LValue *lvalue, const Expression &left, const Expression &right, int leftColumns, int leftRows, int rightColumns, int rightRows)
bool	pushStructuredComparison (LValue *left, Operator op, LValue *right, const Type &type)
void	foldWithMultiOp (BuilderOp op, int elements)
void	foldComparisonOp (Operator op, int elements)
BuilderOp	getTypedOp (const SkSL::Type &type, const TypedOps &ops) const
Analysis::ReturnComplexity	returnComplexity (const FunctionDefinition *func)
bool	needsReturnMask (const FunctionDefinition *func)
bool	needsFunctionResultSlots (const FunctionDefinition *func)

Static Public Member Functions
static BuilderOp	GetTypedOp (const SkSL::Type &type, const TypedOps &ops)
static bool	IsUniform (const Variable &var)
static bool	IsOutParameter (const Variable &var)
static bool	IsInoutParameter (const Variable &var)

Friends
class	AutoContinueMask

Detailed Description

Definition at line 181 of file SkSLRasterPipelineCodeGenerator.cpp.

Member Typedef Documentation

ImmutableBits

using SkSL::RP::Generator::ImmutableBits = int32_t

Support methods for immutable data, which trade more slots for smaller code size.

Definition at line 345 of file SkSLRasterPipelineCodeGenerator.cpp.

Constructor & Destructor Documentation

Generator()

SkSL::RP::Generator::Generator ( const SkSL::Program &  program, DebugTracePriv *  debugTrace, bool  writeTraceOps  )

inline

Definition at line 183 of file SkSLRasterPipelineCodeGenerator.cpp.

            : fProgram(program)
            , fContext(fProgram.fContext->fTypes, *fProgram.fContext->fErrors)
            , fDebugTrace(debugTrace)
            , fWriteTraceOps(writeTraceOps)
            , fProgramSlots(debugTrace ? &debugTrace->fSlotInfo : nullptr)
            , fUniformSlots(debugTrace ? &debugTrace->fUniformInfo : nullptr)
            , fImmutableSlots(nullptr) {
        fContext.fConfig = fProgram.fConfig.get();
        fContext.fModule = fProgram.fContext->fModule;
    }

~Generator()

SkSL::RP::Generator::~Generator ( )

inline

Definition at line 195 of file SkSLRasterPipelineCodeGenerator.cpp.

                 {
        // ~AutoStack calls into the Generator, so we need to make sure the trace mask is reset
        // before the Generator is destroyed.
        fTraceMask.reset();
    }

Member Function Documentation

binaryOp()

bool SkSL::RP::Generator::binaryOp	(	const SkSL::Type &	type,
		const TypedOps &	ops
	)

Definition at line 2262 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                  {
    BuilderOp op = GetTypedOp(type, ops);
    if (op == BuilderOp::unsupported) {
        return unsupported();
    }
    fBuilder.binary_op(op, type.slotCount());
    return true;
}

builder()

Builder * SkSL::RP::Generator::builder ( )

inline

The Builder stitches our instructions together into Raster Pipeline code.

Definition at line 287 of file SkSLRasterPipelineCodeGenerator.cpp.

{ return &fBuilder; }

calculateLineOffsets()

void SkSL::RP::Generator::calculateLineOffsets

(

)

Prepares our position-to-line-offset conversion table (stored in fLineOffsets).

Definition at line 1572 of file SkSLRasterPipelineCodeGenerator.cpp.

                                     {
    SkASSERT(fLineOffsets.empty());
    fLineOffsets.push_back(0);
    for (size_t i = 0; i < fProgram.fSource->length(); ++i) {
        if ((*fProgram.fSource)[i] == '\n') {
            fLineOffsets.push_back(i);
        }
    }
    fLineOffsets.push_back(fProgram.fSource->length());
}

createStack()

int SkSL::RP::Generator::createStack

(

)

Creates an additional stack for the program to push values onto. The stack will not become actively in-use until setCurrentStack is called.

Definition at line 1358 of file SkSLRasterPipelineCodeGenerator.cpp.

                           {
    if (!fRecycledStacks.empty()) {
        int stackID = fRecycledStacks.back();
        fRecycledStacks.pop_back();
        return stackID;
    }
    return ++fNextStackID;
}

currentStack()

int SkSL::RP::Generator::currentStack ( )

inline

Reports the currently active stack.

Definition at line 270 of file SkSLRasterPipelineCodeGenerator.cpp.

                       {
        return fCurrentStack;
    }

discardExpression()

void SkSL::RP::Generator::discardExpression ( int  slots )

inline

Pops an expression from the value stack and discards it.

Definition at line 371 of file SkSLRasterPipelineCodeGenerator.cpp.

{ fBuilder.discard_stack(slots); }

discardTraceScopeMask()

void SkSL::RP::Generator::discardTraceScopeMask

(

)

Definition at line 1560 of file SkSLRasterPipelineCodeGenerator.cpp.

                                      {
    if (this->shouldWriteTraceOps()) {
        this->discardExpression(/*slots=*/1);
    }
}

emitTraceLine()

void SkSL::RP::Generator::emitTraceLine

(

Position

pos

)

Emits a trace_line opcode. writeStatement does this, and statements that alter control flow may need to explicitly add additional traces.

Definition at line 1535 of file SkSLRasterPipelineCodeGenerator.cpp.

                                          {
    if (fDebugTrace && fWriteTraceOps && pos.valid() && fInsideCompoundStatement == 0) {
        // Binary search within fLineOffets to convert the position into a line number.
        SkASSERT(fLineOffsets.size() >= 2);
        SkASSERT(fLineOffsets[0] == 0);
        SkASSERT(fLineOffsets.back() == (int)fProgram.fSource->length());
        int lineNumber = std::distance(
                fLineOffsets.begin(),
                std::upper_bound(fLineOffsets.begin(), fLineOffsets.end(), pos.startOffset()));
 
        fBuilder.trace_line(fTraceMask->stackID(), lineNumber);
    }
}

emitTraceScope()

void SkSL::RP::Generator::emitTraceScope

(

int

delta

)

Definition at line 1566 of file SkSLRasterPipelineCodeGenerator.cpp.

                                        {
    if (this->shouldWriteTraceOps()) {
        fBuilder.trace_scope(this->currentStack(), delta);
    }
}

findPreexistingImmutableData()

std::optional< SlotRange > SkSL::RP::Generator::findPreexistingImmutableData

(

const TArray< ImmutableBits > &

immutableValues

)

Definition at line 2715 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                      {
    STArray<16, const THashSet<Slot>*> slotArray;
    slotArray.reserve_exact(immutableValues.size());
 
    // Find all the slots associated with each immutable-value bit representation.
    // If a given bit-pattern doesn't exist anywhere in our program yet, we can stop searching.
    for (const ImmutableBits& immutableValue : immutableValues) {
        const THashSet<Slot>* slotsForValue = fImmutableSlotMap.find(immutableValue);
        if (!slotsForValue) {
            return std::nullopt;
        }
        slotArray.push_back(slotsForValue);
    }
 
    // Look for the group with the fewest number of entries, since that can be searched in the
    // least amount of effort.
    int leastSlotIndex = 0, leastSlotCount = INT_MAX;
    for (int index = 0; index < slotArray.size(); ++index) {
        int currentCount = slotArray[index]->count();
        if (currentCount < leastSlotCount) {
            leastSlotIndex = index;
            leastSlotCount = currentCount;
        }
    }
 
    // See if we can reconstitute the value that we want with any of the data we've already got.
    for (int slot : *slotArray[leastSlotIndex]) {
        int firstSlot = slot - leastSlotIndex;
        bool found = true;
        for (int index = 0; index < slotArray.size(); ++index) {
            if (!slotArray[index]->contains(firstSlot + index)) {
                found = false;
                break;
            }
        }
        if (found) {
            // We've found an exact match for the input value; return its slot-range.
            return SlotRange{firstSlot, slotArray.size()};
        }
    }
 
    // We didn't find any reusable slot ranges.
    return std::nullopt;
}

finish()

std::unique_ptr< RP::Program > SkSL::RP::Generator::finish

(

)

Returns the generated program.

Definition at line 4061 of file SkSLRasterPipelineCodeGenerator.cpp.

                                           {
    return fBuilder.finish(fProgramSlots.slotCount(),
                           fUniformSlots.slotCount(),
                           fImmutableSlots.slotCount(),
                           fDebugTrace);
}

foldComparisonOp()

void SkSL::RP::Generator::foldComparisonOp	(	Operator	op,
		int	elements
	)

Definition at line 2328 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                          {
    switch (op.kind()) {
        case OperatorKind::EQEQ:
            // equal(x,y) returns a vector; use & to fold into a scalar.
            this->foldWithMultiOp(BuilderOp::bitwise_and_n_ints, elements);
            break;
 
        case OperatorKind::NEQ:
            // notEqual(x,y) returns a vector; use | to fold into a scalar.
            this->foldWithMultiOp(BuilderOp::bitwise_or_n_ints, elements);
            break;
 
        default:
            SkDEBUGFAIL("comparison only allows == and !=");
            break;
    }
}

foldWithMultiOp()

void SkSL::RP::Generator::foldWithMultiOp	(	BuilderOp	op,
		int	elements
	)

Definition at line 2280 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                          {
    // Fold the top N elements on the stack using an op that supports multiple slots, e.g.:
    // (A + B + C + D) -> add_2_floats $0..1 += $2..3
    //                    add_float    $0    += $1
    for (; elements >= 8; elements -= 4) {
        fBuilder.binary_op(op, /*slots=*/4);
    }
    for (; elements >= 6; elements -= 3) {
        fBuilder.binary_op(op, /*slots=*/3);
    }
    for (; elements >= 4; elements -= 2) {
        fBuilder.binary_op(op, /*slots=*/2);
    }
    for (; elements >= 2; elements -= 1) {
        fBuilder.binary_op(op, /*slots=*/1);
    }
}

getFunctionDebugInfo()

int SkSL::RP::Generator::getFunctionDebugInfo

(

const FunctionDeclaration &

decl

)

Returns the slot index of this function inside the FunctionDebugInfo array in DebugTracePriv. The FunctionDebugInfo slot will be created if it doesn't already exist.

Definition at line 1333 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                   {
    SkASSERT(fDebugTrace);
 
    std::string name = decl.description();
 
    // When generating the debug trace, we typically mark every function as `noinline`. This makes
    // the trace more confusing, since this isn't in the source program, so remove it.
    static constexpr std::string_view kNoInline = "noinline ";
    if (skstd::starts_with(name, kNoInline)) {
        name = name.substr(kNoInline.size());
    }
 
    // Look for a matching FunctionDebugInfo slot.
    for (size_t index = 0; index < fDebugTrace->fFuncInfo.size(); ++index) {
        if (fDebugTrace->fFuncInfo[index].name == name) {
            return index;
        }
    }
 
    // We've never called this function before; create a new slot to hold its information.
    int slot = (int)fDebugTrace->fFuncInfo.size();
    fDebugTrace->fFuncInfo.push_back(FunctionDebugInfo{std::move(name)});
    return slot;
}

getFunctionSlots()

SlotRange SkSL::RP::Generator::getFunctionSlots ( const IRNode &  callSite, const FunctionDeclaration &  f  )

inline

Looks up the slots associated with an SkSL function's return value; creates the range if necessary. Note that recursion is never supported, so we don't need to maintain return values in a stack; we can just statically allocate one slot per function call-site.

Definition at line 253 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                     {
        return fProgramSlots.getFunctionSlots(callSite, f);
    }

getImmutableBitsForSlot()

std::optional< Generator::ImmutableBits > SkSL::RP::Generator::getImmutableBitsForSlot	(	const Expression &	expr,
		size_t	slot
	)

Definition at line 2657 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                        {
    // Determine the constant-value of the slot; bail if it isn't constant.
    std::optional<double> v = expr.getConstantValue(slot);
    if (!v.has_value()) {
        return std::nullopt;
    }
    // Determine the number-kind of the slot, and convert the value to its bit-representation.
    Type::NumberKind kind = expr.type().slotType(slot).numberKind();
    double value = *v;
    switch (kind) {
        case Type::NumberKind::kFloat:
            return sk_bit_cast<ImmutableBits>((float)value);
 
        case Type::NumberKind::kSigned:
            return sk_bit_cast<ImmutableBits>((int32_t)value);
 
        case Type::NumberKind::kUnsigned:
            return sk_bit_cast<ImmutableBits>((uint32_t)value);
 
        case Type::NumberKind::kBoolean:
            return value ? ~0 : 0;
 
        default:
            return std::nullopt;
    }
}

getImmutableSlots()

SlotRange SkSL::RP::Generator::getImmutableSlots ( const Variable &  v )

inline

Looks up the slots associated with an immutable variable; creates the slots if necessary.

Definition at line 235 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                   {
        SkASSERT(!IsUniform(v));
        SkASSERT(fImmutableVariables.contains(&v));
        return fImmutableSlots.getVariableSlots(v);
    }

getImmutableValueForExpression()

bool SkSL::RP::Generator::getImmutableValueForExpression	(	const Expression &	expr,
		TArray< ImmutableBits > *	immutableValues
	)

Definition at line 2685 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                       {
    if (!expr.supportsConstantValues()) {
        return false;
    }
    size_t numSlots = expr.type().slotCount();
    immutableValues->reserve_exact(numSlots);
    for (size_t index = 0; index < numSlots; ++index) {
        std::optional<ImmutableBits> bits = this->getImmutableBitsForSlot(expr, index);
        if (!bits.has_value()) {
            return false;
        }
        immutableValues->push_back(*bits);
    }
    return true;
}

GetTypedOp()

BuilderOp SkSL::RP::Generator::GetTypedOp ( const SkSL::Type &  type, const TypedOps &  ops  )

static

Definition at line 2243 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                         {
    switch (type.componentType().numberKind()) {
        case Type::NumberKind::kFloat:    return ops.fFloatOp;
        case Type::NumberKind::kSigned:   return ops.fSignedOp;
        case Type::NumberKind::kUnsigned: return ops.fUnsignedOp;
        case Type::NumberKind::kBoolean:  return ops.fBooleanOp;
        default:                          return BuilderOp::unsupported;
    }
}

getTypedOp()

BuilderOp SkSL::RP::Generator::getTypedOp	(	const SkSL::Type &	type,
		const TypedOps &	ops
	)		const

getUniformSlots()

SlotRange SkSL::RP::Generator::getUniformSlots ( const Variable &  v )

inline

Looks up the slots associated with an SkSL uniform; creates the slots if necessary.

Definition at line 242 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                 {
        SkASSERT(IsUniform(v));
        SkASSERT(!fImmutableVariables.contains(&v));
        return fUniformSlots.getVariableSlots(v);
    }

getVariableSlots()

SlotRange SkSL::RP::Generator::getVariableSlots ( const Variable &  v )

inline

Looks up the slots associated with an SkSL variable; creates the slots if necessary.

Definition at line 227 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                  {
        SkASSERT(this->hasVariableSlots(v));
        return fProgramSlots.getVariableSlots(v);
    }

hasVariableSlots()

bool SkSL::RP::Generator::hasVariableSlots ( const Variable &  v )

inline

Returns true for variables with slots in fProgramSlots; immutables or uniforms are false.

Definition at line 222 of file SkSLRasterPipelineCodeGenerator.cpp.

                                             {
        return !IsUniform(v) && !fImmutableVariables.contains(&v);
    }

IsInoutParameter()

static bool SkSL::RP::Generator::IsInoutParameter ( const Variable &  var )

inlinestatic

Definition at line 470 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                      {
        return (var.modifierFlags() & (ModifierFlag::kIn | ModifierFlag::kOut)) ==
               (ModifierFlag::kIn | ModifierFlag::kOut);
    }

IsOutParameter()

static bool SkSL::RP::Generator::IsOutParameter ( const Variable &  var )

inlinestatic

Definition at line 465 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                    {
        return (var.modifierFlags() & (ModifierFlag::kIn | ModifierFlag::kOut)) ==
               ModifierFlag::kOut;
    }

IsUniform()

static bool SkSL::RP::Generator::IsUniform ( const Variable &  var )

inlinestatic

Definition at line 461 of file SkSLRasterPipelineCodeGenerator.cpp.

                                               {
       return var.modifierFlags().isUniform();
    }

makeLValue()

std::unique_ptr< LValue > SkSL::RP::Generator::makeLValue	(	const Expression &	e,
		bool	allowScratch = false
	)

Returns an LValue for the passed-in expression; if the expression isn't supported as an LValue, returns nullptr.

Definition at line 1245 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                  {
    if (e.is<VariableReference>()) {
        const Variable* variable = e.as<VariableReference>().variable();
        if (fImmutableVariables.contains(variable)) {
            return std::make_unique<ImmutableLValue>(variable);
        }
        return std::make_unique<VariableLValue>(variable);
    }
    if (e.is<Swizzle>()) {
        const Swizzle& swizzleExpr = e.as<Swizzle>();
        if (std::unique_ptr<LValue> base = this->makeLValue(*swizzleExpr.base(),
                                                            allowScratch)) {
            const ComponentArray& components = swizzleExpr.components();
            if (is_sliceable_swizzle(components)) {
                // If the swizzle is a contiguous subset, we can represent it with a fixed slice.
                return std::make_unique<LValueSlice>(std::move(base), components[0],
                                                     components.size());
            }
            return std::make_unique<SwizzleLValue>(std::move(base), components);
        }
        return nullptr;
    }
    if (e.is<FieldAccess>()) {
        const FieldAccess& fieldExpr = e.as<FieldAccess>();
        if (std::unique_ptr<LValue> base = this->makeLValue(*fieldExpr.base(),
                                                            allowScratch)) {
            // Represent field access with a slice.
            return std::make_unique<LValueSlice>(std::move(base), fieldExpr.initialSlot(),
                                                 fieldExpr.type().slotCount());
        }
        return nullptr;
    }
    if (e.is<IndexExpression>()) {
        const IndexExpression& indexExpr = e.as<IndexExpression>();
 
        // If the index base is swizzled (`vec.zyx[idx]`), rewrite it into an equivalent
        // non-swizzled form (`vec[uint3(2,1,0)[idx]]`).
        if (std::unique_ptr<Expression> rewritten = Transform::RewriteIndexedSwizzle(fContext,
                                                                                     indexExpr)) {
            // Convert the rewritten expression into an lvalue.
            std::unique_ptr<LValue> lvalue = this->makeLValue(*rewritten, allowScratch);
            if (!lvalue) {
                return nullptr;
            }
            // We need to hold onto the rewritten expression for the lifetime of the lvalue.
            lvalue->fScratchExpression = std::move(rewritten);
            return lvalue;
        }
        if (std::unique_ptr<LValue> base = this->makeLValue(*indexExpr.base(),
                                                            allowScratch)) {
            // If the index is a compile-time constant, we can represent it with a fixed slice.
            SKSL_INT indexValue;
            if (ConstantFolder::GetConstantInt(*indexExpr.index(), &indexValue)) {
                int numSlots = indexExpr.type().slotCount();
                return std::make_unique<LValueSlice>(std::move(base), numSlots * indexValue,
                                                     numSlots);
            }
 
            // Represent non-constant indexing via a dynamic index.
            auto dynLValue = std::make_unique<DynamicIndexLValue>(std::move(base), indexExpr);
            return dynLValue->evaluateDynamicIndices(this) ? std::move(dynLValue)
                                                           : nullptr;
        }
        return nullptr;
    }
    if (allowScratch) {
        // This path allows us to perform field- and index-accesses on an expression as if it were
        // an lvalue, but is a temporary and shouldn't be written back to.
        return std::make_unique<ScratchLValue>(e);
    }
    return nullptr;
}

needsFunctionResultSlots()

bool SkSL::RP::Generator::needsFunctionResultSlots ( const FunctionDefinition *  func )

inline

Definition at line 456 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                  {
        return this->shouldWriteTraceOps() || (this->returnComplexity(func) >
                                               Analysis::ReturnComplexity::kSingleSafeReturn);
    }

needsReturnMask()

bool SkSL::RP::Generator::needsReturnMask ( const FunctionDefinition *  func )

inline

Definition at line 452 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                         {
        return this->returnComplexity(func) >= Analysis::ReturnComplexity::kEarlyReturns;
    }

popToSlotRange()

void SkSL::RP::Generator::popToSlotRange ( SlotRange  r )

inline

Pops an expression from the value stack and copies it into slots.

Definition at line 357 of file SkSLRasterPipelineCodeGenerator.cpp.

                                     {
        fBuilder.pop_slots(r);
        if (this->shouldWriteTraceOps()) {
            fBuilder.trace_var(fTraceMask->stackID(), r);
        }
    }

popToSlotRangeUnmasked()

void SkSL::RP::Generator::popToSlotRangeUnmasked ( SlotRange  r )

inline

Definition at line 363 of file SkSLRasterPipelineCodeGenerator.cpp.

                                             {
        fBuilder.pop_slots_unmasked(r);
        if (this->shouldWriteTraceOps()) {
            fBuilder.trace_var(fTraceMask->stackID(), r);
        }
    }

push()

bool SkSL::RP::Generator::push

(

LValue &

lvalue

)

Pushes the lvalue onto the top-of-stack.

Definition at line 1318 of file SkSLRasterPipelineCodeGenerator.cpp.

                                   {
    return lvalue.push(this,
                       lvalue.fixedSlotRange(this),
                       lvalue.dynamicSlotRange(),
                       /*swizzle=*/{});
}

pushAbsFloatIntrinsic()

bool SkSL::RP::Generator::pushAbsFloatIntrinsic

(

int

slots

)

Definition at line 3048 of file SkSLRasterPipelineCodeGenerator.cpp.

                                               {
    // Perform abs(float) by masking off the sign bit.
    fBuilder.push_constant_u(0x7FFFFFFF, slots);
    fBuilder.binary_op(BuilderOp::bitwise_and_n_ints, slots);
    return true;
}

pushBinaryExpression() [1/2]

bool SkSL::RP::Generator::pushBinaryExpression

(

const BinaryExpression &

e

)

Pushes an expression to the value stack.

Definition at line 2416 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                              {
    return this->pushBinaryExpression(*e.left(), e.getOperator(), *e.right());
}

pushBinaryExpression() [2/2]

bool SkSL::RP::Generator::pushBinaryExpression	(	const Expression &	left,
		Operator	op,
		const Expression &	right
	)

Definition at line 2420 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                                 {
    switch (op.kind()) {
        // Rewrite greater-than ops as their less-than equivalents.
        case OperatorKind::GT:
            return this->pushBinaryExpression(right, OperatorKind::LT, left);
 
        case OperatorKind::GTEQ:
            return this->pushBinaryExpression(right, OperatorKind::LTEQ, left);
 
        // Handle struct and array comparisons.
        case OperatorKind::EQEQ:
        case OperatorKind::NEQ:
            if (left.type().isStruct() || left.type().isArray()) {
                SkASSERT(left.type().matches(right.type()));
                std::unique_ptr<LValue> lvLeft = this->makeLValue(left, /*allowScratch=*/true);
                std::unique_ptr<LValue> lvRight = this->makeLValue(right, /*allowScratch=*/true);
                return this->pushStructuredComparison(lvLeft.get(), op, lvRight.get(), left.type());
            }
            [[fallthrough]];
 
        // Rewrite commutative ops so that the literal is on the right-hand side. This gives the
        // Builder more opportunities to use immediate-mode ops.
        case OperatorKind::PLUS:
        case OperatorKind::STAR:
        case OperatorKind::BITWISEAND:
        case OperatorKind::BITWISEXOR:
        case OperatorKind::LOGICALXOR: {
            double unused;
            if (ConstantFolder::GetConstantValue(left, &unused) &&
                !ConstantFolder::GetConstantValue(right, &unused)) {
                return this->pushBinaryExpression(right, op, left);
            }
            break;
        }
        // Emit comma expressions.
        case OperatorKind::COMMA:
            if (Analysis::HasSideEffects(left)) {
                if (!this->pushExpression(left, /*usesResult=*/false)) {
                    return unsupported();
                }
                this->discardExpression(left.type().slotCount());
            }
            return this->pushExpression(right);
 
        default:
            break;
    }
 
    // Handle binary expressions with mismatched types.
    bool vectorizeLeft = false, vectorizeRight = false;
    if (!left.type().matches(right.type())) {
        if (left.type().componentType().numberKind() != right.type().componentType().numberKind()) {
            return unsupported();
        }
        if (left.type().isScalar() && (right.type().isVector() || right.type().isMatrix())) {
            vectorizeLeft = true;
        } else if ((left.type().isVector() || left.type().isMatrix()) && right.type().isScalar()) {
            vectorizeRight = true;
        }
    }
 
    const Type& type = vectorizeLeft ? right.type() : left.type();
 
    // If this is an assignment...
    std::unique_ptr<LValue> lvalue;
    if (op.isAssignment()) {
        // ... turn the left side into an lvalue.
        lvalue = this->makeLValue(left);
        if (!lvalue) {
            return unsupported();
        }
 
        // Handle simple assignment (`var = expr`).
        if (op.kind() == OperatorKind::EQ) {
            return this->pushExpression(right) &&
                   this->store(*lvalue);
        }
 
        // Strip off the assignment from the op (turning += into +).
        op = op.removeAssignment();
    }
 
    // Handle matrix multiplication (MxM/MxV/VxM).
    if (op.kind() == OperatorKind::STAR) {
        // Matrix * matrix:
        if (left.type().isMatrix() && right.type().isMatrix()) {
            return this->pushMatrixMultiply(lvalue.get(), left, right,
                                            left.type().columns(), left.type().rows(),
                                            right.type().columns(), right.type().rows());
        }
 
        // Vector * matrix:
        if (left.type().isVector() && right.type().isMatrix()) {
            return this->pushMatrixMultiply(lvalue.get(), left, right,
                                            left.type().columns(), 1,
                                            right.type().columns(), right.type().rows());
        }
 
        // Matrix * vector:
        if (left.type().isMatrix() && right.type().isVector()) {
            return this->pushMatrixMultiply(lvalue.get(), left, right,
                                            left.type().columns(), left.type().rows(),
                                            1, right.type().columns());
        }
    }
 
    if (!vectorizeLeft && !vectorizeRight && !type.matches(right.type())) {
        // We have mismatched types but don't know how to handle them.
        return unsupported();
    }
 
    // Handle binary ops which require short-circuiting.
    switch (op.kind()) {
        case OperatorKind::LOGICALAND:
            if (Analysis::HasSideEffects(right)) {
                // If the RHS has side effects, we rewrite `a && b` as `a ? b : false`. This
                // generates pretty solid code and gives us the required short-circuit behavior.
                SkASSERT(!op.isAssignment());
                SkASSERT(type.componentType().isBoolean());
                SkASSERT(type.slotCount() == 1);  // operator&& only works with scalar types
                Literal falseLiteral{Position{}, 0.0, &right.type()};
                return this->pushTernaryExpression(left, right, falseLiteral);
            }
            break;
 
        case OperatorKind::LOGICALOR:
            if (Analysis::HasSideEffects(right)) {
                // If the RHS has side effects, we rewrite `a || b` as `a ? true : b`.
                SkASSERT(!op.isAssignment());
                SkASSERT(type.componentType().isBoolean());
                SkASSERT(type.slotCount() == 1);  // operator|| only works with scalar types
                Literal trueLiteral{Position{}, 1.0, &right.type()};
                return this->pushTernaryExpression(left, trueLiteral, right);
            }
            break;
 
        default:
            break;
    }
 
    // Push the left- and right-expressions onto the stack.
    if (!this->pushLValueOrExpression(lvalue.get(), left)) {
        return unsupported();
    }
    if (vectorizeLeft) {
        fBuilder.push_duplicates(right.type().slotCount() - 1);
    }
    if (!this->pushExpression(right)) {
        return unsupported();
    }
    if (vectorizeRight) {
        fBuilder.push_duplicates(left.type().slotCount() - 1);
    }
 
    switch (op.kind()) {
        case OperatorKind::PLUS:
            if (!this->binaryOp(type, kAddOps)) {
                return unsupported();
            }
            break;
 
        case OperatorKind::MINUS:
            if (!this->binaryOp(type, kSubtractOps)) {
                return unsupported();
            }
            break;
 
        case OperatorKind::STAR:
            if (!this->binaryOp(type, kMultiplyOps)) {
                return unsupported();
            }
            break;
 
        case OperatorKind::SLASH:
            if (!this->binaryOp(type, kDivideOps)) {
                return unsupported();
            }
            break;
 
        case OperatorKind::LT:
        case OperatorKind::GT:
            if (!this->binaryOp(type, kLessThanOps)) {
                return unsupported();
            }
            SkASSERT(type.slotCount() == 1);  // operator< only works with scalar types
            break;
 
        case OperatorKind::LTEQ:
        case OperatorKind::GTEQ:
            if (!this->binaryOp(type, kLessThanEqualOps)) {
                return unsupported();
            }
            SkASSERT(type.slotCount() == 1);  // operator<= only works with scalar types
            break;
 
        case OperatorKind::EQEQ:
            if (!this->binaryOp(type, kEqualOps)) {
                return unsupported();
            }
            this->foldComparisonOp(op, type.slotCount());
            break;
 
        case OperatorKind::NEQ:
            if (!this->binaryOp(type, kNotEqualOps)) {
                return unsupported();
            }
            this->foldComparisonOp(op, type.slotCount());
            break;
 
        case OperatorKind::LOGICALAND:
        case OperatorKind::BITWISEAND:
            // For logical-and, we verified above that the RHS does not have side effects, so we
            // don't need to worry about short-circuiting side effects.
            fBuilder.binary_op(BuilderOp::bitwise_and_n_ints, type.slotCount());
            break;
 
        case OperatorKind::LOGICALOR:
        case OperatorKind::BITWISEOR:
            // For logical-or, we verified above that the RHS does not have side effects.
            fBuilder.binary_op(BuilderOp::bitwise_or_n_ints, type.slotCount());
            break;
 
        case OperatorKind::LOGICALXOR:
        case OperatorKind::BITWISEXOR:
            // Logical-xor does not short circuit.
            fBuilder.binary_op(BuilderOp::bitwise_xor_n_ints, type.slotCount());
            break;
 
        default:
            return unsupported();
    }
 
    // If we have an lvalue, we need to write the result back into it.
    return lvalue ? this->store(*lvalue)
                  : true;
}

pushChildCall()

bool SkSL::RP::Generator::pushChildCall

(

const ChildCall &

c

)

Definition at line 2792 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                {
    int* childIdx = fChildEffectMap.find(&c.child());
    SkASSERT(childIdx != nullptr);
    SkASSERT(!c.arguments().empty());
 
    // All child calls have at least one argument.
    const Expression* arg = c.arguments()[0].get();
    if (!this->pushExpression(*arg)) {
        return unsupported();
    }
 
    // Copy arguments from the stack into src/dst as required by this particular child-call.
    switch (c.child().type().typeKind()) {
        case Type::TypeKind::kShader: {
            // The argument must be a float2.
            SkASSERT(c.arguments().size() == 1);
            SkASSERT(arg->type().matches(*fContext.fTypes.fFloat2));
 
            // `exchange_src` will use the top four values on the stack, but we don't care what goes
            // into the blue/alpha components. We inject padding here to balance the stack.
            fBuilder.pad_stack(2);
 
            // Move the argument into src.rgba while also preserving the execution mask.
            fBuilder.exchange_src();
            fBuilder.invoke_shader(*childIdx);
            break;
        }
        case Type::TypeKind::kColorFilter: {
            // The argument must be a half4/float4.
            SkASSERT(c.arguments().size() == 1);
            SkASSERT(arg->type().matches(*fContext.fTypes.fHalf4) ||
                     arg->type().matches(*fContext.fTypes.fFloat4));
 
            // Move the argument into src.rgba while also preserving the execution mask.
            fBuilder.exchange_src();
            fBuilder.invoke_color_filter(*childIdx);
            break;
        }
        case Type::TypeKind::kBlender: {
            // Both arguments must be half4/float4.
            SkASSERT(c.arguments().size() == 2);
            SkASSERT(c.arguments()[0]->type().matches(*fContext.fTypes.fHalf4) ||
                     c.arguments()[0]->type().matches(*fContext.fTypes.fFloat4));
            SkASSERT(c.arguments()[1]->type().matches(*fContext.fTypes.fHalf4) ||
                     c.arguments()[1]->type().matches(*fContext.fTypes.fFloat4));
 
            // Move the second argument into dst.rgba, and the first argument into src.rgba, while
            // simultaneously preserving the execution mask.
            if (!this->pushExpression(*c.arguments()[1])) {
                return unsupported();
            }
            fBuilder.pop_dst_rgba();
            fBuilder.exchange_src();
            fBuilder.invoke_blender(*childIdx);
            break;
        }
        default: {
            SkDEBUGFAILF("cannot sample from type '%s'", c.child().type().description().c_str());
        }
    }
 
    // The child call has returned the result color via src.rgba, and the SkRP execution mask is
    // on top of the stack. Swapping the two puts the result color on top of the stack, and also
    // restores our execution masks.
    fBuilder.exchange_src();
    return true;
}

pushConstructorCast()

bool SkSL::RP::Generator::pushConstructorCast

(

const AnyConstructor &

c

)

Definition at line 2860 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                           {
    SkASSERT(c.argumentSpan().size() == 1);
    const Expression& inner = *c.argumentSpan().front();
    SkASSERT(inner.type().slotCount() == c.type().slotCount());
 
    if (!this->pushExpression(inner)) {
        return unsupported();
    }
    const Type::NumberKind innerKind = inner.type().componentType().numberKind();
    const Type::NumberKind outerKind = c.type().componentType().numberKind();
 
    if (innerKind == outerKind) {
        // Since we ignore type precision, this cast is effectively a no-op.
        return true;
    }
 
    switch (innerKind) {
        case Type::NumberKind::kSigned:
            if (outerKind == Type::NumberKind::kUnsigned) {
                // Treat uint(int) as a no-op.
                return true;
            }
            if (outerKind == Type::NumberKind::kFloat) {
                fBuilder.unary_op(BuilderOp::cast_to_float_from_int, c.type().slotCount());
                return true;
            }
            break;
 
        case Type::NumberKind::kUnsigned:
            if (outerKind == Type::NumberKind::kSigned) {
                // Treat int(uint) as a no-op.
                return true;
            }
            if (outerKind == Type::NumberKind::kFloat) {
                fBuilder.unary_op(BuilderOp::cast_to_float_from_uint, c.type().slotCount());
                return true;
            }
            break;
 
        case Type::NumberKind::kBoolean:
            // Converting boolean to int or float can be accomplished via bitwise-and.
            if (outerKind == Type::NumberKind::kFloat) {
                fBuilder.push_constant_f(1.0f);
            } else if (outerKind == Type::NumberKind::kSigned ||
                       outerKind == Type::NumberKind::kUnsigned) {
                fBuilder.push_constant_i(1);
            } else {
                SkDEBUGFAILF("unexpected cast from bool to %s", c.type().description().c_str());
                return unsupported();
            }
            fBuilder.push_duplicates(c.type().slotCount() - 1);
            fBuilder.binary_op(BuilderOp::bitwise_and_n_ints, c.type().slotCount());
            return true;
 
        case Type::NumberKind::kFloat:
            if (outerKind == Type::NumberKind::kSigned) {
                fBuilder.unary_op(BuilderOp::cast_to_int_from_float, c.type().slotCount());
                return true;
            }
            if (outerKind == Type::NumberKind::kUnsigned) {
                fBuilder.unary_op(BuilderOp::cast_to_uint_from_float, c.type().slotCount());
                return true;
            }
            break;
 
        case Type::NumberKind::kNonnumeric:
            break;
    }
 
    if (outerKind == Type::NumberKind::kBoolean) {
        // Converting int or float to boolean can be accomplished via `notEqual(x, 0)`.
        fBuilder.push_zeros(c.type().slotCount());
        return this->binaryOp(inner.type(), kNotEqualOps);
    }
 
    SkDEBUGFAILF("unexpected cast from %s to %s",
                 c.type().description().c_str(), inner.type().description().c_str());
    return unsupported();
}

pushConstructorCompound()

bool SkSL::RP::Generator::pushConstructorCompound

(

const AnyConstructor &

c

)

Definition at line 2780 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                               {
    if (c.type().slotCount() > 1 && this->pushImmutableData(c)) {
        return true;
    }
    for (const std::unique_ptr<Expression> &arg : c.argumentSpan()) {
        if (!this->pushExpression(*arg)) {
            return unsupported();
        }
    }
    return true;
}

pushConstructorDiagonalMatrix()

bool SkSL::RP::Generator::pushConstructorDiagonalMatrix

(

const ConstructorDiagonalMatrix &

c

)

Definition at line 2940 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                {
    if (this->pushImmutableData(c)) {
        return true;
    }
    fBuilder.push_zeros(1);
    if (!this->pushExpression(*c.argument())) {
        return unsupported();
    }
    fBuilder.diagonal_matrix(c.type().columns(), c.type().rows());
 
    return true;
}

pushConstructorMatrixResize()

bool SkSL::RP::Generator::pushConstructorMatrixResize

(

const ConstructorMatrixResize &

c

)

Definition at line 2953 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                            {
    if (!this->pushExpression(*c.argument())) {
        return unsupported();
    }
    fBuilder.matrix_resize(c.argument()->type().columns(),
                           c.argument()->type().rows(),
                           c.type().columns(),
                           c.type().rows());
    return true;
}

pushConstructorSplat()

bool SkSL::RP::Generator::pushConstructorSplat

(

const ConstructorSplat &

c

)

Definition at line 2964 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                              {
    if (!this->pushExpression(*c.argument())) {
        return unsupported();
    }
    fBuilder.push_duplicates(c.type().slotCount() - 1);
    return true;
}

pushDynamicallyUniformTernaryExpression()

bool SkSL::RP::Generator::pushDynamicallyUniformTernaryExpression	(	const Expression &	test,
		const Expression &	ifTrue,
		const Expression &	ifFalse
	)

Definition at line 3768 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                   {
    SkASSERT(Analysis::IsDynamicallyUniformExpression(test));
 
    int falseLabelID = fBuilder.nextLabelID();
    int exitLabelID = fBuilder.nextLabelID();
 
    // First, push the test-expression into a separate stack.
    AutoStack testStack(this);
    testStack.enter();
    if (!this->pushExpression(test)) {
        return unsupported();
    }
 
    // Branch to the true- or false-expression based on the test-expression. We can skip the
    // non-true path entirely since the test is known to be uniform.
    fBuilder.branch_if_no_active_lanes_on_stack_top_equal(~0, falseLabelID);
    testStack.exit();
 
    if (!this->pushExpression(ifTrue)) {
        return unsupported();
    }
 
    fBuilder.jump(exitLabelID);
 
    // The builder doesn't understand control flow, and assumes that every push moves the stack-top
    // forwards. We need to manually balance out the `pushExpression` from the if-true path by
    // moving the stack position backwards, so that the if-false path pushes its expression into the
    // same as the if-true result.
    this->discardExpression(/*slots=*/ifTrue.type().slotCount());
 
    fBuilder.label(falseLabelID);
 
    if (!this->pushExpression(ifFalse)) {
        return unsupported();
    }
 
    fBuilder.label(exitLabelID);
 
    // Jettison the text-expression from the separate stack.
    testStack.enter();
    this->discardExpression(/*slots=*/1);
    testStack.exit();
    return true;
}

pushExpression()

bool SkSL::RP::Generator::pushExpression	(	const Expression &	e,
		bool	usesResult = true
	)

Definition at line 2181 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                   {
    switch (e.kind()) {
        case Expression::Kind::kBinary:
            return this->pushBinaryExpression(e.as<BinaryExpression>());
 
        case Expression::Kind::kChildCall:
            return this->pushChildCall(e.as<ChildCall>());
 
        case Expression::Kind::kConstructorArray:
        case Expression::Kind::kConstructorArrayCast:
        case Expression::Kind::kConstructorCompound:
        case Expression::Kind::kConstructorStruct:
            return this->pushConstructorCompound(e.asAnyConstructor());
 
        case Expression::Kind::kConstructorCompoundCast:
        case Expression::Kind::kConstructorScalarCast:
            return this->pushConstructorCast(e.asAnyConstructor());
 
        case Expression::Kind::kConstructorDiagonalMatrix:
            return this->pushConstructorDiagonalMatrix(e.as<ConstructorDiagonalMatrix>());
 
        case Expression::Kind::kConstructorMatrixResize:
            return this->pushConstructorMatrixResize(e.as<ConstructorMatrixResize>());
 
        case Expression::Kind::kConstructorSplat:
            return this->pushConstructorSplat(e.as<ConstructorSplat>());
 
        case Expression::Kind::kEmpty:
            return true;
 
        case Expression::Kind::kFieldAccess:
            return this->pushFieldAccess(e.as<FieldAccess>());
 
        case Expression::Kind::kFunctionCall:
            return this->pushFunctionCall(e.as<FunctionCall>());
 
        case Expression::Kind::kIndex:
            return this->pushIndexExpression(e.as<IndexExpression>());
 
        case Expression::Kind::kLiteral:
            return this->pushLiteral(e.as<Literal>());
 
        case Expression::Kind::kPrefix:
            return this->pushPrefixExpression(e.as<PrefixExpression>());
 
        case Expression::Kind::kPostfix:
            return this->pushPostfixExpression(e.as<PostfixExpression>(), usesResult);
 
        case Expression::Kind::kSwizzle:
            return this->pushSwizzle(e.as<Swizzle>());
 
        case Expression::Kind::kTernary:
            return this->pushTernaryExpression(e.as<TernaryExpression>());
 
        case Expression::Kind::kVariableReference:
            return this->pushVariableReference(e.as<VariableReference>());
 
        default:
            return unsupported();
    }
}

pushFieldAccess()

bool SkSL::RP::Generator::pushFieldAccess

(

const FieldAccess &

f

)

Definition at line 2972 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                    {
    // If possible, get direct field access via the lvalue.
    std::unique_ptr<LValue> lvalue = this->makeLValue(f, /*allowScratch=*/true);
    return lvalue && this->push(*lvalue);
}

pushFunctionCall()

bool SkSL::RP::Generator::pushFunctionCall

(

const FunctionCall &

c

)

Definition at line 2978 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                      {
    if (c.function().isIntrinsic()) {
        return this->pushIntrinsic(c);
    }
 
    // Keep track of the current function.
    const FunctionDefinition* lastFunction = fCurrentFunction;
    fCurrentFunction = c.function().definition();
 
    // Skip over the function body entirely if there are no active lanes.
    // (If the function call was trivial, it would likely have been inlined in the frontend, so we
    // assume here that function calls generally represent a significant amount of work.)
    int skipLabelID = fBuilder.nextLabelID();
    fBuilder.branch_if_no_lanes_active(skipLabelID);
 
    // Emit the function body.
    std::optional<SlotRange> r = this->writeFunction(c, *fCurrentFunction, c.arguments());
    if (!r.has_value()) {
        return unsupported();
    }
 
    // If the function uses result slots, move its result from slots onto the stack.
    if (this->needsFunctionResultSlots(fCurrentFunction)) {
        fBuilder.push_slots(*r);
    }
 
    // We've returned back to the last function.
    fCurrentFunction = lastFunction;
 
    // Copy the function result from its slots onto the stack.
    fBuilder.label(skipLabelID);
    return true;
}

pushImmutableData()

bool SkSL::RP::Generator::pushImmutableData

(

const Expression &

e

)

Definition at line 2761 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                     {
    STArray<16, ImmutableBits> immutableValues;
    if (!this->getImmutableValueForExpression(e, &immutableValues)) {
        return false;
    }
    std::optional<SlotRange> preexistingData = this->findPreexistingImmutableData(immutableValues);
    if (preexistingData.has_value()) {
        fBuilder.push_immutable(*preexistingData);
        return true;
    }
    SlotRange range = fImmutableSlots.createSlots(e.description(),
                                                  e.type(),
                                                  e.fPosition,
                                                  /*isFunctionReturnValue=*/false);
    this->storeImmutableValueToSlots(immutableValues, range);
    fBuilder.push_immutable(range);
    return true;
}

pushIndexExpression()

bool SkSL::RP::Generator::pushIndexExpression

(

const IndexExpression &

i

)

Definition at line 3012 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                            {
    std::unique_ptr<LValue> lvalue = this->makeLValue(i, /*allowScratch=*/true);
    return lvalue && this->push(*lvalue);
}

pushIntrinsic() [1/8]

bool SkSL::RP::Generator::pushIntrinsic	(	BuilderOp	builderOp,
		const Expression &	arg0
	)

Definition at line 3073 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                         {
    if (!this->pushExpression(arg0)) {
        return unsupported();
    }
    fBuilder.unary_op(builderOp, arg0.type().slotCount());
    return true;
}

pushIntrinsic() [2/8]

bool SkSL::RP::Generator::pushIntrinsic	(	BuilderOp	builderOp,
		const Expression &	arg0,
		const Expression &	arg1
	)

Definition at line 3321 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                                 {
    if (!this->pushExpression(arg0) || !this->pushVectorizedExpression(arg1, arg0.type())) {
        return unsupported();
    }
    fBuilder.binary_op(builderOp, arg0.type().slotCount());
    return true;
}

pushIntrinsic() [3/8]

bool SkSL::RP::Generator::pushIntrinsic

(

const FunctionCall &

c

)

Definition at line 3017 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                   {
    const ExpressionArray& args = c.arguments();
    switch (args.size()) {
        case 1:
            return this->pushIntrinsic(c.function().intrinsicKind(), *args[0]);
 
        case 2:
            return this->pushIntrinsic(c.function().intrinsicKind(), *args[0], *args[1]);
 
        case 3:
            return this->pushIntrinsic(c.function().intrinsicKind(), *args[0], *args[1], *args[2]);
 
        default:
            break;
    }
 
    return unsupported();
}

pushIntrinsic() [4/8]

bool SkSL::RP::Generator::pushIntrinsic	(	const TypedOps &	ops,
		const Expression &	arg0
	)

Definition at line 3066 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                         {
    if (!this->pushExpression(arg0)) {
        return unsupported();
    }
    return this->unaryOp(arg0.type(), ops);
}

pushIntrinsic() [5/8]

bool SkSL::RP::Generator::pushIntrinsic	(	const TypedOps &	ops,
		const Expression &	arg0,
		const Expression &	arg1
	)

Definition at line 3314 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                                 {
    if (!this->pushExpression(arg0) || !this->pushVectorizedExpression(arg1, arg0.type())) {
        return unsupported();
    }
    return this->binaryOp(arg0.type(), ops);
}

pushIntrinsic() [6/8]

bool SkSL::RP::Generator::pushIntrinsic	(	IntrinsicKind	intrinsic,
		const Expression &	arg0
	)

Definition at line 3081 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                             {
    switch (intrinsic) {
        case IntrinsicKind::k_abs_IntrinsicKind:
            if (arg0.type().componentType().isFloat()) {
                // Perform abs(float) by masking off the sign bit.
                if (!this->pushExpression(arg0)) {
                    return unsupported();
                }
                return this->pushAbsFloatIntrinsic(arg0.type().slotCount());
            }
            // We have a dedicated op for abs(int).
            return this->pushIntrinsic(BuilderOp::abs_int, arg0);
 
        case IntrinsicKind::k_any_IntrinsicKind:
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            this->foldWithMultiOp(BuilderOp::bitwise_or_n_ints, arg0.type().slotCount());
            return true;
 
        case IntrinsicKind::k_all_IntrinsicKind:
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            this->foldWithMultiOp(BuilderOp::bitwise_and_n_ints, arg0.type().slotCount());
            return true;
 
        case IntrinsicKind::k_acos_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::acos_float, arg0);
 
        case IntrinsicKind::k_asin_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::asin_float, arg0);
 
        case IntrinsicKind::k_atan_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::atan_float, arg0);
 
        case IntrinsicKind::k_ceil_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::ceil_float, arg0);
 
        case IntrinsicKind::k_cos_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::cos_float, arg0);
 
        case IntrinsicKind::k_degrees_IntrinsicKind: {
            Literal lit180OverPi{Position{}, 57.2957795131f, &arg0.type().componentType()};
            return this->pushBinaryExpression(arg0, OperatorKind::STAR, lit180OverPi);
        }
        case IntrinsicKind::k_floatBitsToInt_IntrinsicKind:
        case IntrinsicKind::k_floatBitsToUint_IntrinsicKind:
        case IntrinsicKind::k_intBitsToFloat_IntrinsicKind:
        case IntrinsicKind::k_uintBitsToFloat_IntrinsicKind:
            return this->pushExpression(arg0);
 
        case IntrinsicKind::k_exp_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::exp_float, arg0);
 
        case IntrinsicKind::k_exp2_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::exp2_float, arg0);
 
        case IntrinsicKind::k_floor_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::floor_float, arg0);
 
        case IntrinsicKind::k_fract_IntrinsicKind:
            // Implement fract as `x - floor(x)`.
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            fBuilder.push_clone(arg0.type().slotCount());
            fBuilder.unary_op(BuilderOp::floor_float, arg0.type().slotCount());
            return this->binaryOp(arg0.type(), kSubtractOps);
 
        case IntrinsicKind::k_inverse_IntrinsicKind:
            SkASSERT(arg0.type().isMatrix());
            SkASSERT(arg0.type().rows() == arg0.type().columns());
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            fBuilder.inverse_matrix(arg0.type().rows());
            return true;
 
        case IntrinsicKind::k_inversesqrt_IntrinsicKind:
            return this->pushIntrinsic(kInverseSqrtOps, arg0);
 
        case IntrinsicKind::k_length_IntrinsicKind:
            return this->pushExpression(arg0) &&
                   this->pushLengthIntrinsic(arg0.type().slotCount());
 
        case IntrinsicKind::k_log_IntrinsicKind:
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            fBuilder.unary_op(BuilderOp::log_float, arg0.type().slotCount());
            return true;
 
        case IntrinsicKind::k_log2_IntrinsicKind:
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            fBuilder.unary_op(BuilderOp::log2_float, arg0.type().slotCount());
            return true;
 
        case IntrinsicKind::k_normalize_IntrinsicKind: {
            // Implement normalize as `x / length(x)`. First, push the expression.
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            int slotCount = arg0.type().slotCount();
            if (slotCount > 1) {
#if defined(SK_USE_RSQRT_IN_RP_NORMALIZE)
                // Instead of `x / sqrt(dot(x, x))`, we can get roughly the same result in less time
                // by computing `x * invsqrt(dot(x, x))`.
                fBuilder.push_clone(slotCount);
                fBuilder.push_clone(slotCount);
                fBuilder.dot_floats(slotCount);
 
                // Compute `vec(inversesqrt(dot(x, x)))`.
                fBuilder.unary_op(BuilderOp::invsqrt_float, 1);
                fBuilder.push_duplicates(slotCount - 1);
 
                // Return `x * vec(inversesqrt(dot(x, x)))`.
                return this->binaryOp(arg0.type(), kMultiplyOps);
#else
                // TODO: We can get roughly the same result in less time by using `invsqrt`, but
                // that leads to more variance across architectures, which Chromium layout tests do
                // not handle nicely.
                fBuilder.push_clone(slotCount);
                fBuilder.push_clone(slotCount);
                fBuilder.dot_floats(slotCount);
 
                // Compute `vec(sqrt(dot(x, x)))`.
                fBuilder.unary_op(BuilderOp::sqrt_float, 1);
                fBuilder.push_duplicates(slotCount - 1);
 
                // Return `x / vec(sqrt(dot(x, x)))`.
                return this->binaryOp(arg0.type(), kDivideOps);
#endif
            } else {
                // For single-slot normalization, we can simplify `sqrt(x * x)` into `abs(x)`.
                fBuilder.push_clone(slotCount);
                return this->pushAbsFloatIntrinsic(/*slots=*/1) &&
                       this->binaryOp(arg0.type(), kDivideOps);
            }
        }
        case IntrinsicKind::k_not_IntrinsicKind:
            return this->pushPrefixExpression(OperatorKind::LOGICALNOT, arg0);
 
        case IntrinsicKind::k_radians_IntrinsicKind: {
            Literal litPiOver180{Position{}, 0.01745329251f, &arg0.type().componentType()};
            return this->pushBinaryExpression(arg0, OperatorKind::STAR, litPiOver180);
        }
        case IntrinsicKind::k_saturate_IntrinsicKind: {
            // Implement saturate as clamp(arg, 0, 1).
            Literal zeroLiteral{Position{}, 0.0, &arg0.type().componentType()};
            Literal oneLiteral{Position{}, 1.0, &arg0.type().componentType()};
            return this->pushIntrinsic(k_clamp_IntrinsicKind, arg0, zeroLiteral, oneLiteral);
        }
        case IntrinsicKind::k_sign_IntrinsicKind: {
            // Implement floating-point sign() as `clamp(arg * FLT_MAX, -1, 1)`.
            // FLT_MIN * FLT_MAX evaluates to 4, so multiplying any float value against FLT_MAX is
            // sufficient to ensure that |value| is always 1 or greater (excluding zero and nan).
            // Integer sign() doesn't need to worry about fractional values or nans, and can simply
            // be `clamp(arg, -1, 1)`.
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            if (arg0.type().componentType().isFloat()) {
                Literal fltMaxLiteral{Position{}, FLT_MAX, &arg0.type().componentType()};
                if (!this->pushVectorizedExpression(fltMaxLiteral, arg0.type())) {
                    return unsupported();
                }
                if (!this->binaryOp(arg0.type(), kMultiplyOps)) {
                    return unsupported();
                }
            }
            Literal neg1Literal{Position{}, -1.0, &arg0.type().componentType()};
            if (!this->pushVectorizedExpression(neg1Literal, arg0.type())) {
                return unsupported();
            }
            if (!this->binaryOp(arg0.type(), kMaxOps)) {
                return unsupported();
            }
            Literal pos1Literal{Position{}, 1.0, &arg0.type().componentType()};
            if (!this->pushVectorizedExpression(pos1Literal, arg0.type())) {
                return unsupported();
            }
            return this->binaryOp(arg0.type(), kMinOps);
        }
        case IntrinsicKind::k_sin_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::sin_float, arg0);
 
        case IntrinsicKind::k_sqrt_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::sqrt_float, arg0);
 
        case IntrinsicKind::k_tan_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::tan_float, arg0);
 
        case IntrinsicKind::k_transpose_IntrinsicKind:
            SkASSERT(arg0.type().isMatrix());
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            fBuilder.transpose(arg0.type().columns(), arg0.type().rows());
            return true;
 
        case IntrinsicKind::k_trunc_IntrinsicKind:
            // Implement trunc as `float(int(x))`, since float-to-int rounds toward zero.
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            fBuilder.unary_op(BuilderOp::cast_to_int_from_float, arg0.type().slotCount());
            fBuilder.unary_op(BuilderOp::cast_to_float_from_int, arg0.type().slotCount());
            return true;
 
        case IntrinsicKind::k_fromLinearSrgb_IntrinsicKind:
        case IntrinsicKind::k_toLinearSrgb_IntrinsicKind:
            // The argument must be a half3.
            SkASSERT(arg0.type().matches(*fContext.fTypes.fHalf3));
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
 
            if (intrinsic == IntrinsicKind::k_fromLinearSrgb_IntrinsicKind) {
                fBuilder.invoke_from_linear_srgb();
            } else {
                fBuilder.invoke_to_linear_srgb();
            }
            return true;
 
        default:
            break;
    }
    return unsupported();
}

pushIntrinsic() [7/8]

bool SkSL::RP::Generator::pushIntrinsic	(	IntrinsicKind	intrinsic,
		const Expression &	arg0,
		const Expression &	arg1
	)

Definition at line 3329 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                      {
    switch (intrinsic) {
        case IntrinsicKind::k_atan_IntrinsicKind:
            return this->pushIntrinsic(BuilderOp::atan2_n_floats, arg0, arg1);
 
        case IntrinsicKind::k_cross_IntrinsicKind: {
            // Implement cross as `arg0.yzx * arg1.zxy - arg0.zxy * arg1.yzx`. We use two stacks so
            // that each subexpression can be multiplied separately.
            SkASSERT(arg0.type().matches(arg1.type()));
            SkASSERT(arg0.type().slotCount() == 3);
            SkASSERT(arg1.type().slotCount() == 3);
 
            // Push `arg0.yzx` onto this stack and `arg0.zxy` onto a separate subexpression stack.
            AutoStack subexpressionStack(this);
            subexpressionStack.enter();
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            subexpressionStack.exit();
            subexpressionStack.pushClone(/*slots=*/3);
 
            fBuilder.swizzle(/*consumedSlots=*/3, {1, 2, 0});
            subexpressionStack.enter();
            fBuilder.swizzle(/*consumedSlots=*/3, {2, 0, 1});
            subexpressionStack.exit();
 
            // Push `arg1.zxy` onto this stack and `arg1.yzx` onto the next stack. Perform the
            // multiply on each subexpression (`arg0.yzx * arg1.zxy` on the first stack, and
            // `arg0.zxy * arg1.yzx` on the next).
            subexpressionStack.enter();
            if (!this->pushExpression(arg1)) {
                return unsupported();
            }
            subexpressionStack.exit();
            subexpressionStack.pushClone(/*slots=*/3);
 
            fBuilder.swizzle(/*consumedSlots=*/3, {2, 0, 1});
            fBuilder.binary_op(BuilderOp::mul_n_floats, 3);
 
            subexpressionStack.enter();
            fBuilder.swizzle(/*consumedSlots=*/3, {1, 2, 0});
            fBuilder.binary_op(BuilderOp::mul_n_floats, 3);
            subexpressionStack.exit();
 
            // Migrate the result of the second subexpression (`arg0.zxy * arg1.yzx`) back onto the
            // main stack and subtract it from the first subexpression (`arg0.yzx * arg1.zxy`).
            subexpressionStack.pushClone(/*slots=*/3);
            fBuilder.binary_op(BuilderOp::sub_n_floats, 3);
 
            // Now that the calculation is complete, discard the subexpression on the next stack.
            subexpressionStack.enter();
            this->discardExpression(/*slots=*/3);
            subexpressionStack.exit();
            return true;
        }
        case IntrinsicKind::k_distance_IntrinsicKind:
            // Implement distance as `length(a - b)`.
            SkASSERT(arg0.type().slotCount() == arg1.type().slotCount());
            return this->pushBinaryExpression(arg0, OperatorKind::MINUS, arg1) &&
                   this->pushLengthIntrinsic(arg0.type().slotCount());
 
        case IntrinsicKind::k_dot_IntrinsicKind:
            SkASSERT(arg0.type().matches(arg1.type()));
            if (!this->pushExpression(arg0) || !this->pushExpression(arg1)) {
                return unsupported();
            }
            fBuilder.dot_floats(arg0.type().slotCount());
            return true;
 
        case IntrinsicKind::k_equal_IntrinsicKind:
            SkASSERT(arg0.type().matches(arg1.type()));
            return this->pushIntrinsic(kEqualOps, arg0, arg1);
 
        case IntrinsicKind::k_notEqual_IntrinsicKind:
            SkASSERT(arg0.type().matches(arg1.type()));
            return this->pushIntrinsic(kNotEqualOps, arg0, arg1);
 
        case IntrinsicKind::k_lessThan_IntrinsicKind:
            SkASSERT(arg0.type().matches(arg1.type()));
            return this->pushIntrinsic(kLessThanOps, arg0, arg1);
 
        case IntrinsicKind::k_greaterThan_IntrinsicKind:
            SkASSERT(arg0.type().matches(arg1.type()));
            return this->pushIntrinsic(kLessThanOps, arg1, arg0);
 
        case IntrinsicKind::k_lessThanEqual_IntrinsicKind:
            SkASSERT(arg0.type().matches(arg1.type()));
            return this->pushIntrinsic(kLessThanEqualOps, arg0, arg1);
 
        case IntrinsicKind::k_greaterThanEqual_IntrinsicKind:
            SkASSERT(arg0.type().matches(arg1.type()));
            return this->pushIntrinsic(kLessThanEqualOps, arg1, arg0);
 
        case IntrinsicKind::k_min_IntrinsicKind:
            SkASSERT(arg0.type().componentType().matches(arg1.type().componentType()));
            return this->pushIntrinsic(kMinOps, arg0, arg1);
 
        case IntrinsicKind::k_matrixCompMult_IntrinsicKind:
            SkASSERT(arg0.type().matches(arg1.type()));
            return this->pushIntrinsic(kMultiplyOps, arg0, arg1);
 
        case IntrinsicKind::k_max_IntrinsicKind:
            SkASSERT(arg0.type().componentType().matches(arg1.type().componentType()));
            return this->pushIntrinsic(kMaxOps, arg0, arg1);
 
        case IntrinsicKind::k_mod_IntrinsicKind:
            SkASSERT(arg0.type().componentType().matches(arg1.type().componentType()));
            return this->pushIntrinsic(kModOps, arg0, arg1);
 
        case IntrinsicKind::k_pow_IntrinsicKind:
            SkASSERT(arg0.type().matches(arg1.type()));
            return this->pushIntrinsic(BuilderOp::pow_n_floats, arg0, arg1);
 
        case IntrinsicKind::k_reflect_IntrinsicKind: {
            // Implement reflect as `I - (N * dot(I,N) * 2)`.
            SkASSERT(arg0.type().matches(arg1.type()));
            SkASSERT(arg0.type().slotCount() == arg1.type().slotCount());
            SkASSERT(arg0.type().componentType().isFloat());
            int slotCount = arg0.type().slotCount();
 
            // Stack: I, N.
            if (!this->pushExpression(arg0) || !this->pushExpression(arg1)) {
                return unsupported();
            }
            // Stack: I, N, I, N.
            fBuilder.push_clone(2 * slotCount);
            // Stack: I, N, dot(I,N)
            fBuilder.dot_floats(slotCount);
            // Stack: I, N, dot(I,N), 2
            fBuilder.push_constant_f(2.0);
            // Stack: I, N, dot(I,N) * 2
            fBuilder.binary_op(BuilderOp::mul_n_floats, 1);
            // Stack: I, N * dot(I,N) * 2
            fBuilder.push_duplicates(slotCount - 1);
            fBuilder.binary_op(BuilderOp::mul_n_floats, slotCount);
            // Stack: I - (N * dot(I,N) * 2)
            fBuilder.binary_op(BuilderOp::sub_n_floats, slotCount);
            return true;
        }
        case IntrinsicKind::k_step_IntrinsicKind: {
            // Compute step as `float(lessThanEqual(edge, x))`. We convert from boolean 0/~0 to
            // floating point zero/one by using a bitwise-and against the bit-pattern of 1.0.
            SkASSERT(arg0.type().componentType().matches(arg1.type().componentType()));
            if (!this->pushVectorizedExpression(arg0, arg1.type()) || !this->pushExpression(arg1)) {
                return unsupported();
            }
            if (!this->binaryOp(arg1.type(), kLessThanEqualOps)) {
                return unsupported();
            }
            Literal pos1Literal{Position{}, 1.0, &arg1.type().componentType()};
            if (!this->pushVectorizedExpression(pos1Literal, arg1.type())) {
                return unsupported();
            }
            fBuilder.binary_op(BuilderOp::bitwise_and_n_ints, arg1.type().slotCount());
            return true;
        }
 
        default:
            break;
    }
    return unsupported();
}

pushIntrinsic() [8/8]

bool SkSL::RP::Generator::pushIntrinsic	(	IntrinsicKind	intrinsic,
		const Expression &	arg0,
		const Expression &	arg1,
		const Expression &	arg2
	)

Definition at line 3494 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                      {
    switch (intrinsic) {
        case IntrinsicKind::k_clamp_IntrinsicKind:
            // Implement clamp as min(max(arg, low), high).
            SkASSERT(arg0.type().componentType().matches(arg1.type().componentType()));
            SkASSERT(arg0.type().componentType().matches(arg2.type().componentType()));
            if (!this->pushExpression(arg0) || !this->pushVectorizedExpression(arg1, arg0.type())) {
                return unsupported();
            }
            if (!this->binaryOp(arg0.type(), kMaxOps)) {
                return unsupported();
            }
            if (!this->pushVectorizedExpression(arg2, arg0.type())) {
                return unsupported();
            }
            if (!this->binaryOp(arg0.type(), kMinOps)) {
                return unsupported();
            }
            return true;
 
        case IntrinsicKind::k_faceforward_IntrinsicKind: {
            // Implement faceforward as `N ^ ((0 <= dot(I, NRef)) & 0x80000000)`.
            // In other words, flip the sign bit of N if `0 <= dot(I, NRef)`.
            SkASSERT(arg0.type().matches(arg1.type()));
            SkASSERT(arg0.type().matches(arg2.type()));
            int slotCount = arg0.type().slotCount();
 
            // Stack: N, 0, I, Nref
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            fBuilder.push_constant_f(0.0);
            if (!this->pushExpression(arg1) || !this->pushExpression(arg2)) {
                return unsupported();
            }
            // Stack: N, 0, dot(I,NRef)
            fBuilder.dot_floats(slotCount);
            // Stack: N, (0 <= dot(I,NRef))
            fBuilder.binary_op(BuilderOp::cmple_n_floats, 1);
            // Stack: N, (0 <= dot(I,NRef)), 0x80000000
            fBuilder.push_constant_u(0x80000000);
            // Stack: N, (0 <= dot(I,NRef)) & 0x80000000)
            fBuilder.binary_op(BuilderOp::bitwise_and_n_ints, 1);
            // Stack: N, vec(0 <= dot(I,NRef)) & 0x80000000)
            fBuilder.push_duplicates(slotCount - 1);
            // Stack: N ^ vec((0 <= dot(I,NRef)) & 0x80000000)
            fBuilder.binary_op(BuilderOp::bitwise_xor_n_ints, slotCount);
            return true;
        }
        case IntrinsicKind::k_mix_IntrinsicKind:
            // Note: our SkRP mix op takes the interpolation point first, not the interpolants.
            SkASSERT(arg0.type().matches(arg1.type()));
            if (arg2.type().componentType().isFloat()) {
                SkASSERT(arg0.type().componentType().matches(arg2.type().componentType()));
                if (!this->pushVectorizedExpression(arg2, arg0.type())) {
                    return unsupported();
                }
                if (!this->pushExpression(arg0) || !this->pushExpression(arg1)) {
                    return unsupported();
                }
                return this->ternaryOp(arg0.type(), kMixOps);
            }
            if (arg2.type().componentType().isBoolean()) {
                if (!this->pushExpression(arg2)) {
                    return unsupported();
                }
                if (!this->pushExpression(arg0) || !this->pushExpression(arg1)) {
                    return unsupported();
                }
                // The `mix_int` op isn't doing a lerp; it uses the third argument to select values
                // from the first and second arguments. It's safe for use with any type in arguments
                // 0 and 1.
                fBuilder.ternary_op(BuilderOp::mix_n_ints, arg0.type().slotCount());
                return true;
            }
            return unsupported();
 
        case IntrinsicKind::k_refract_IntrinsicKind: {
            // We always calculate refraction using vec4s, so we pad out unused N/I slots with zero.
            int padding = 4 - arg0.type().slotCount();
            if (!this->pushExpression(arg0)) {
                return unsupported();
            }
            fBuilder.push_zeros(padding);
 
            if (!this->pushExpression(arg1)) {
                return unsupported();
            }
            fBuilder.push_zeros(padding);
 
            // eta is always a scalar and doesn't need padding.
            if (!this->pushExpression(arg2)) {
                return unsupported();
            }
            fBuilder.refract_floats();
 
            // The result vector was returned as a vec4, so discard the extra columns.
            fBuilder.discard_stack(padding);
            return true;
        }
        case IntrinsicKind::k_smoothstep_IntrinsicKind:
            SkASSERT(arg0.type().componentType().isFloat());
            SkASSERT(arg1.type().matches(arg0.type()));
            SkASSERT(arg2.type().componentType().isFloat());
 
            if (!this->pushVectorizedExpression(arg0, arg2.type()) ||
                !this->pushVectorizedExpression(arg1, arg2.type()) ||
                !this->pushExpression(arg2)) {
                return unsupported();
            }
            fBuilder.ternary_op(BuilderOp::smoothstep_n_floats, arg2.type().slotCount());
            return true;
 
        default:
            break;
    }
    return unsupported();
}

pushLengthIntrinsic()

bool SkSL::RP::Generator::pushLengthIntrinsic

(

int

slotCount

)

Definition at line 3036 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                 {
    if (slotCount == 1) {
        // `length(scalar)` is `sqrt(x^2)`, which is equivalent to `abs(x)`.
        return this->pushAbsFloatIntrinsic(/*slots=*/1);
    }
    // Implement `length(vec)` as `sqrt(dot(x, x))`.
    fBuilder.push_clone(slotCount);
    fBuilder.dot_floats(slotCount);
    fBuilder.unary_op(BuilderOp::sqrt_float, 1);
    return true;
}

pushLiteral()

bool SkSL::RP::Generator::pushLiteral

(

const Literal &

l

)

Definition at line 3616 of file SkSLRasterPipelineCodeGenerator.cpp.

                                            {
    switch (l.type().numberKind()) {
        case Type::NumberKind::kFloat:
            fBuilder.push_constant_f(l.floatValue());
            return true;
 
        case Type::NumberKind::kSigned:
            fBuilder.push_constant_i(l.intValue());
            return true;
 
        case Type::NumberKind::kUnsigned:
            fBuilder.push_constant_u(l.intValue());
            return true;
 
        case Type::NumberKind::kBoolean:
            fBuilder.push_constant_i(l.boolValue() ? ~0 : 0);
            return true;
 
        default:
            SkUNREACHABLE;
    }
}

pushLValueOrExpression()

bool SkSL::RP::Generator::pushLValueOrExpression	(	LValue *	lvalue,
		const Expression &	expr
	)

Definition at line 2298 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                             {
    return lvalue ? this->push(*lvalue)
                  : this->pushExpression(expr);
}

pushMatrixMultiply()

bool SkSL::RP::Generator::pushMatrixMultiply	(	LValue *	lvalue,
		const Expression &	left,
		const Expression &	right,
		int	leftColumns,
		int	leftRows,
		int	rightColumns,
		int	rightRows
	)

Definition at line 2303 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                  {
    SkASSERT(left.type().isMatrix() || left.type().isVector());
    SkASSERT(right.type().isMatrix() || right.type().isVector());
 
    // Insert padding space on the stack to hold the result.
    fBuilder.pad_stack(rightColumns * leftRows);
 
    // Push the left and right matrices onto the stack.
    if (!this->pushLValueOrExpression(lvalue, left) || !this->pushExpression(right)) {
        return unsupported();
    }
 
    fBuilder.matrix_multiply(leftColumns, leftRows, rightColumns, rightRows);
 
    // If this multiply was actually an assignment (via *=), write the result back to the lvalue.
    return lvalue ? this->store(*lvalue)
                  : true;
}

pushPostfixExpression()

bool SkSL::RP::Generator::pushPostfixExpression	(	const PostfixExpression &	p,
		bool	usesResult
	)

Definition at line 3639 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                 {
    // If the result is ignored...
    if (!usesResult) {
        // ... just emit a prefix expression instead.
        return this->pushPrefixExpression(p.getOperator(), *p.operand());
    }
    // Get the operand as an lvalue, and push it onto the stack as-is.
    std::unique_ptr<LValue> lvalue = this->makeLValue(*p.operand());
    if (!lvalue || !this->push(*lvalue)) {
        return unsupported();
    }
 
    // Push a scratch copy of the operand.
    fBuilder.push_clone(p.type().slotCount());
 
    // Increment or decrement the scratch copy by one.
    Literal oneLiteral{Position{}, 1.0, &p.type().componentType()};
    if (!this->pushVectorizedExpression(oneLiteral, p.type())) {
        return unsupported();
    }
 
    switch (p.getOperator().kind()) {
        case OperatorKind::PLUSPLUS:
            if (!this->binaryOp(p.type(), kAddOps)) {
                return unsupported();
            }
            break;
 
        case OperatorKind::MINUSMINUS:
            if (!this->binaryOp(p.type(), kSubtractOps)) {
                return unsupported();
            }
            break;
 
        default:
            SkUNREACHABLE;
    }
 
    // Write the new value back to the operand.
    if (!this->store(*lvalue)) {
        return unsupported();
    }
 
    // Discard the scratch copy, leaving only the original value as-is.
    this->discardExpression(p.type().slotCount());
    return true;
}

pushPrefixExpression() [1/2]

bool SkSL::RP::Generator::pushPrefixExpression

(

const PrefixExpression &

p

)

Definition at line 3687 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                              {
    return this->pushPrefixExpression(p.getOperator(), *p.operand());
}

pushPrefixExpression() [2/2]

bool SkSL::RP::Generator::pushPrefixExpression	(	Operator	op,
		const Expression &	expr
	)

Definition at line 3691 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                        {
    switch (op.kind()) {
        case OperatorKind::BITWISENOT:
        case OperatorKind::LOGICALNOT:
            // Handle operators ! and ~.
            if (!this->pushExpression(expr)) {
                return unsupported();
            }
            fBuilder.push_constant_u(~0, expr.type().slotCount());
            fBuilder.binary_op(BuilderOp::bitwise_xor_n_ints, expr.type().slotCount());
            return true;
 
        case OperatorKind::MINUS: {
            if (!this->pushExpression(expr)) {
                return unsupported();
            }
            if (expr.type().componentType().isFloat()) {
                // Handle float negation as an integer `x ^ 0x80000000`. This toggles the sign bit.
                fBuilder.push_constant_u(0x80000000, expr.type().slotCount());
                fBuilder.binary_op(BuilderOp::bitwise_xor_n_ints, expr.type().slotCount());
            } else {
                // Handle integer negation as a componentwise `expr * -1`.
                fBuilder.push_constant_i(-1, expr.type().slotCount());
                fBuilder.binary_op(BuilderOp::mul_n_ints, expr.type().slotCount());
            }
            return true;
        }
        case OperatorKind::PLUSPLUS: {
            // Rewrite as `expr += 1`.
            Literal oneLiteral{Position{}, 1.0, &expr.type().componentType()};
            return this->pushBinaryExpression(expr, OperatorKind::PLUSEQ, oneLiteral);
        }
        case OperatorKind::MINUSMINUS: {
            // Rewrite as `expr += -1`.
            Literal minusOneLiteral{expr.fPosition, -1.0, &expr.type().componentType()};
            return this->pushBinaryExpression(expr, OperatorKind::PLUSEQ, minusOneLiteral);
        }
        default:
            break;
    }
 
    return unsupported();
}

pushStructuredComparison()

bool SkSL::RP::Generator::pushStructuredComparison	(	LValue *	left,
		Operator	op,
		LValue *	right,
		const Type &	type
	)

Definition at line 2346 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                           {
    if (type.isStruct()) {
        // Compare every field in the struct.
        SkSpan<const Field> fields = type.fields();
        int currentSlot = 0;
        for (size_t index = 0; index < fields.size(); ++index) {
            const Type& fieldType = *fields[index].fType;
            const int   fieldSlotCount = fieldType.slotCount();
            UnownedLValueSlice fieldLeft {left,  currentSlot, fieldSlotCount};
            UnownedLValueSlice fieldRight{right, currentSlot, fieldSlotCount};
            if (!this->pushStructuredComparison(&fieldLeft, op, &fieldRight, fieldType)) {
                return unsupported();
            }
            currentSlot += fieldSlotCount;
        }
 
        this->foldComparisonOp(op, fields.size());
        return true;
    }
 
    if (type.isArray()) {
        const Type& indexedType = type.componentType();
        if (indexedType.numberKind() == Type::NumberKind::kNonnumeric) {
            // Compare every element in the array.
            const int indexedSlotCount = indexedType.slotCount();
            int       currentSlot = 0;
            for (int index = 0; index < type.columns(); ++index) {
                UnownedLValueSlice indexedLeft {left,  currentSlot, indexedSlotCount};
                UnownedLValueSlice indexedRight{right, currentSlot, indexedSlotCount};
                if (!this->pushStructuredComparison(&indexedLeft, op, &indexedRight, indexedType)) {
                    return unsupported();
                }
                currentSlot += indexedSlotCount;
            }
 
            this->foldComparisonOp(op, type.columns());
            return true;
        }
    }
 
    // We've winnowed down to a single element, or an array of homogeneous numeric elements.
    // Push the elements onto the stack, then compare them.
    if (!this->push(*left) || !this->push(*right)) {
        return unsupported();
    }
    switch (op.kind()) {
        case OperatorKind::EQEQ:
            if (!this->binaryOp(type, kEqualOps)) {
                return unsupported();
            }
            break;
 
        case OperatorKind::NEQ:
            if (!this->binaryOp(type, kNotEqualOps)) {
                return unsupported();
            }
            break;
 
        default:
            SkDEBUGFAIL("comparison only allows == and !=");
            break;
    }
 
    this->foldComparisonOp(op, type.slotCount());
    return true;
}

pushSwizzle()

bool SkSL::RP::Generator::pushSwizzle

(

const Swizzle &

s

)

Definition at line 3735 of file SkSLRasterPipelineCodeGenerator.cpp.

                                            {
    SkASSERT(!s.components().empty() && s.components().size() <= 4);
 
    // If this is a simple subset of a variable's slots...
    bool isSimpleSubset = is_sliceable_swizzle(s.components());
    if (isSimpleSubset && s.base()->is<VariableReference>()) {
        // ... we can just push part of the variable directly onto the stack, rather than pushing
        // the whole expression and then immediately cutting it down. (Either way works, but this
        // saves a step.)
        return this->pushVariableReferencePartial(
                s.base()->as<VariableReference>(),
                SlotRange{/*index=*/s.components()[0], /*count=*/s.components().size()});
    }
    // Push the base expression.
    if (!this->pushExpression(*s.base())) {
        return false;
    }
    // An identity swizzle doesn't rearrange the data; it just (potentially) discards tail elements.
    if (isSimpleSubset && s.components()[0] == 0) {
        int discardedElements = s.base()->type().slotCount() - s.components().size();
        SkASSERT(discardedElements >= 0);
        fBuilder.discard_stack(discardedElements);
        return true;
    }
    // Perform the swizzle.
    fBuilder.swizzle(s.base()->type().slotCount(), s.components());
    return true;
}

pushTernaryExpression() [1/2]

bool SkSL::RP::Generator::pushTernaryExpression	(	const Expression &	test,
		const Expression &	ifTrue,
		const Expression &	ifFalse
	)

Definition at line 3815 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                 {
    // If the test-expression is dynamically-uniform, we can skip over the non-true expressions
    // entirely, and not need to involve the condition mask.
    if (Analysis::IsDynamicallyUniformExpression(test)) {
        return this->pushDynamicallyUniformTernaryExpression(test, ifTrue, ifFalse);
    }
 
    // Analyze the ternary to see which corners we can safely cut.
    bool ifFalseHasSideEffects = Analysis::HasSideEffects(ifFalse);
    bool ifTrueHasSideEffects  = Analysis::HasSideEffects(ifTrue);
    bool ifTrueIsTrivial       = Analysis::IsTrivialExpression(ifTrue);
    int  cleanupLabelID        = fBuilder.nextLabelID();
 
    // If the true- and false-expressions both lack side effects, we evaluate both of them safely
    // without masking off their effects. In that case, we can emit both sides and use boolean mix
    // to select the correct result without using the condition mask at all.
    if (!ifFalseHasSideEffects && !ifTrueHasSideEffects && ifTrueIsTrivial) {
        // Push all of the arguments to mix.
        if (!this->pushVectorizedExpression(test, ifTrue.type())) {
            return unsupported();
        }
        if (!this->pushExpression(ifFalse)) {
            return unsupported();
        }
        if (!this->pushExpression(ifTrue)) {
            return unsupported();
        }
        // Use boolean mix to select the true- or false-expression via the test-expression.
        fBuilder.ternary_op(BuilderOp::mix_n_ints, ifTrue.type().slotCount());
        return true;
    }
 
    // First, push the current condition-mask and the test-expression into a separate stack.
    fBuilder.enableExecutionMaskWrites();
    AutoStack testStack(this);
    testStack.enter();
    fBuilder.push_condition_mask();
    if (!this->pushExpression(test)) {
        return unsupported();
    }
    testStack.exit();
 
    // We can take some shortcuts with condition-mask handling if the false-expression is entirely
    // side-effect free. (We can evaluate it without masking off its effects.) We always handle the
    // condition mask properly for the test-expression and true-expression properly.
    if (!ifFalseHasSideEffects) {
        // Push the false-expression onto the primary stack.
        if (!this->pushExpression(ifFalse)) {
            return unsupported();
        }
 
        // Next, merge the condition mask (on the separate stack) with the test expression.
        testStack.enter();
        fBuilder.merge_condition_mask();
        testStack.exit();
 
        // If no lanes are active, we can skip the true-expression entirely. This isn't super likely
        // to happen, so it's probably only a win for non-trivial true-expressions.
        if (!ifTrueIsTrivial) {
            fBuilder.branch_if_no_lanes_active(cleanupLabelID);
        }
 
        // Push the true-expression onto the primary stack, immediately after the false-expression.
        if (!this->pushExpression(ifTrue)) {
            return unsupported();
        }
 
        // Use a select to conditionally mask-merge the true-expression and false-expression lanes.
        fBuilder.select(/*slots=*/ifTrue.type().slotCount());
        fBuilder.label(cleanupLabelID);
    } else {
        // Merge the condition mask (on the separate stack) with the test expression.
        testStack.enter();
        fBuilder.merge_condition_mask();
        testStack.exit();
 
        // Push the true-expression onto the primary stack.
        if (!this->pushExpression(ifTrue)) {
            return unsupported();
        }
 
        // Switch back to the test-expression stack and apply the inverted test condition.
        testStack.enter();
        fBuilder.merge_inv_condition_mask();
        testStack.exit();
 
        // Push the false-expression onto the primary stack, immediately after the true-expression.
        if (!this->pushExpression(ifFalse)) {
            return unsupported();
        }
 
        // Use a select to conditionally mask-merge the true-expression and false-expression lanes;
        // the mask is already set up for this.
        fBuilder.select(/*slots=*/ifTrue.type().slotCount());
    }
 
    // Restore the condition-mask to its original state and jettison the test-expression.
    testStack.enter();
    this->discardExpression(/*slots=*/1);
    fBuilder.pop_condition_mask();
    testStack.exit();
 
    fBuilder.disableExecutionMaskWrites();
    return true;
}

pushTernaryExpression() [2/2]

bool SkSL::RP::Generator::pushTernaryExpression

(

const TernaryExpression &

t

)

Definition at line 3764 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                {
    return this->pushTernaryExpression(*t.test(), *t.ifTrue(), *t.ifFalse());
}

pushTraceScopeMask()

void SkSL::RP::Generator::pushTraceScopeMask

(

)

Emits a trace_scope opcode, which alters the SkSL variable-scope depth. Unlike the other trace ops, trace_scope takes a dedicated mask instead of the trace-scope mask. Call pushTraceScopeMask to synthesize this mask; discard it when you're done.

Definition at line 1549 of file SkSLRasterPipelineCodeGenerator.cpp.

                                   {
    if (this->shouldWriteTraceOps()) {
        // Take the intersection of the trace mask and the execution mask. To do this, start with an
        // all-zero mask, then use select to overwrite those zeros with the trace mask across all
        // executing lanes. We'll get the trace mask in executing lanes, and zero in dead lanes.
        fBuilder.push_constant_i(0);
        fTraceMask->pushClone(/*slots=*/1);
        fBuilder.select(/*slots=*/1);
    }
}

pushVariableReference()

bool SkSL::RP::Generator::pushVariableReference

(

const VariableReference &

v

)

Definition at line 3923 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                  {
    // If we are pushing a constant-value variable, push the value directly; literal values are more
    // amenable to optimization.
    if (var.type().isScalar() || var.type().isVector()) {
        if (const Expression* expr = ConstantFolder::GetConstantValueOrNull(var)) {
            return this->pushExpression(*expr);
        }
        if (fImmutableVariables.contains(var.variable())) {
            return this->pushExpression(*var.variable()->initialValue());
        }
    }
    return this->pushVariableReferencePartial(var, SlotRange{0, (int)var.type().slotCount()});
}

pushVariableReferencePartial()

bool SkSL::RP::Generator::pushVariableReferencePartial	(	const VariableReference &	v,
		SlotRange	subset
	)

Definition at line 3937 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                         {
    const Variable& var = *v.variable();
    SlotRange r;
    if (IsUniform(var)) {
        // Push a uniform.
        r = this->getUniformSlots(var);
        SkASSERT(r.count == (int)var.type().slotCount());
        r.index += subset.index;
        r.count = subset.count;
        fBuilder.push_uniform(r);
    } else if (fImmutableVariables.contains(&var)) {
        // If we only need a single slot, we can push a constant. This saves a lookup, and can
        // occasionally permit the use of an immediate-mode op.
        if (subset.count == 1) {
            const Expression& expr = *v.variable()->initialValue();
            std::optional<ImmutableBits> bits = this->getImmutableBitsForSlot(expr, subset.index);
            if (bits.has_value()) {
                fBuilder.push_constant_i(*bits);
                return true;
            }
        }
        // Push the immutable slot range.
        r = this->getImmutableSlots(var);
        SkASSERT(r.count == (int)var.type().slotCount());
        r.index += subset.index;
        r.count = subset.count;
        fBuilder.push_immutable(r);
    } else {
        // Push the variable.
        r = this->getVariableSlots(var);
        SkASSERT(r.count == (int)var.type().slotCount());
        r.index += subset.index;
        r.count = subset.count;
        fBuilder.push_slots(r);
    }
    return true;
}

pushVectorizedExpression()

bool SkSL::RP::Generator::pushVectorizedExpression	(	const Expression &	expr,
		const Type &	vectorType
	)

Definition at line 3055 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                       {
    if (!this->pushExpression(expr)) {
        return unsupported();
    }
    if (vectorType.slotCount() > expr.type().slotCount()) {
        SkASSERT(expr.type().slotCount() == 1);
        fBuilder.push_duplicates(vectorType.slotCount() - expr.type().slotCount());
    }
    return true;
}

recycleStack()

void SkSL::RP::Generator::recycleStack

(

int

stackID

)

Frees a stack generated by createStack. The freed stack must be completely empty.

Definition at line 1367 of file SkSLRasterPipelineCodeGenerator.cpp.

                                        {
    fRecycledStacks.push_back(stackID);
}

returnComplexity()

Analysis::ReturnComplexity SkSL::RP::Generator::returnComplexity ( const FunctionDefinition *  func )

inline

Definition at line 443 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                              {
        Analysis::ReturnComplexity* complexity = fReturnComplexityMap.find(func);
        if (!complexity) {
            complexity = fReturnComplexityMap.set(fCurrentFunction,
                                                  Analysis::GetReturnComplexity(*func));
        }
        return *complexity;
    }

setCurrentStack()

void SkSL::RP::Generator::setCurrentStack

(

int

stackID

)

Redirects builder ops to point to a different stack (created by createStack).

Definition at line 1371 of file SkSLRasterPipelineCodeGenerator.cpp.

                                           {
    if (fCurrentStack != stackID) {
        fCurrentStack = stackID;
        fBuilder.set_current_stack(stackID);
    }
}

shouldWriteTraceOps()

bool SkSL::RP::Generator::shouldWriteTraceOps ( )

inline

Definition at line 399 of file SkSLRasterPipelineCodeGenerator.cpp.

{ return fDebugTrace && fWriteTraceOps; }

store()

bool SkSL::RP::Generator::store

(

LValue &

lvalue

)

Copies the top-of-stack value into this lvalue, without discarding it from the stack.

Definition at line 1325 of file SkSLRasterPipelineCodeGenerator.cpp.

                                    {
    SkASSERT(lvalue.isWritable());
    return lvalue.store(this,
                        lvalue.fixedSlotRange(this),
                        lvalue.dynamicSlotRange(),
                        /*swizzle=*/{});
}

storeImmutableValueToSlots()

void SkSL::RP::Generator::storeImmutableValueToSlots	(	const TArray< ImmutableBits > &	immutableValues,
		SlotRange	slots
	)

Definition at line 2702 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                            {
    for (int index = 0; index < slots.count; ++index) {
        // Store the immutable value in its slot.
        const Slot slot = slots.index++;
        const ImmutableBits bits = immutableValues[index];
        fBuilder.store_immutable_value_i(slot, bits);
 
        // Keep track of every stored immutable value for potential later reuse.
        fImmutableSlotMap[bits].add(slot);
    }
}

ternaryOp()

bool SkSL::RP::Generator::ternaryOp	(	const SkSL::Type &	type,
		const TypedOps &	ops
	)

Definition at line 2271 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                   {
    BuilderOp op = GetTypedOp(type, ops);
    if (op == BuilderOp::unsupported) {
        return unsupported();
    }
    fBuilder.ternary_op(op, type.slotCount());
    return true;
}

traceMaskStackID()

int SkSL::RP::Generator::traceMaskStackID ( )

inline

Definition at line 400 of file SkSLRasterPipelineCodeGenerator.cpp.

{ return fTraceMask->stackID(); }

unaryOp()

bool SkSL::RP::Generator::unaryOp	(	const SkSL::Type &	type,
		const TypedOps &	ops
	)

Definition at line 2253 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                 {
    BuilderOp op = GetTypedOp(type, ops);
    if (op == BuilderOp::unsupported) {
        return unsupported();
    }
    fBuilder.unary_op(op, type.slotCount());
    return true;
}

writeBlock()

bool SkSL::RP::Generator::writeBlock

(

const Block &

b

)

Definition at line 1696 of file SkSLRasterPipelineCodeGenerator.cpp.

                                         {
    if (b.blockKind() == Block::Kind::kCompoundStatement) {
        this->emitTraceLine(b.fPosition);
        ++fInsideCompoundStatement;
    } else {
        this->pushTraceScopeMask();
        this->emitTraceScope(+1);
    }
 
    for (const std::unique_ptr<Statement>& stmt : b.children()) {
        if (!this->writeStatement(*stmt)) {
            return unsupported();
        }
    }
 
    if (b.blockKind() == Block::Kind::kCompoundStatement) {
        --fInsideCompoundStatement;
    } else {
        this->emitTraceScope(-1);
        this->discardTraceScopeMask();
    }
 
    return true;
}

writeBreakStatement()

bool SkSL::RP::Generator::writeBreakStatement

(

const BreakStatement &

b

)

Definition at line 1721 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                         {
    // If all lanes have reached this break, we can just branch straight to the break target instead
    // of updating masks.
    fBuilder.branch_if_all_lanes_active(fCurrentBreakTarget);
    fBuilder.mask_off_loop_mask();
    return true;
}

writeContinueStatement()

bool SkSL::RP::Generator::writeContinueStatement

(

const ContinueStatement &

b

)

Definition at line 1729 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                               {
    fBuilder.continue_op(fCurrentContinueMask->stackID());
    return true;
}

writeDoStatement()

bool SkSL::RP::Generator::writeDoStatement

(

const DoStatement &

d

)

Definition at line 1734 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                     {
    // Set up a break target.
    AutoLoopTarget breakTarget(this, &fCurrentBreakTarget);
 
    // Save off the original loop mask.
    fBuilder.enableExecutionMaskWrites();
    fBuilder.push_loop_mask();
 
    // If `continue` is used in the loop...
    Analysis::LoopControlFlowInfo loopInfo = Analysis::GetLoopControlFlowInfo(*d.statement());
    AutoContinueMask autoContinueMask(this);
    if (loopInfo.fHasContinue) {
        // ... create a temporary slot for continue-mask storage.
        autoContinueMask.enable();
    }
 
    // Write the do-loop body.
    int labelID = fBuilder.nextLabelID();
    fBuilder.label(labelID);
 
    autoContinueMask.enterLoopBody();
 
    if (!this->writeStatement(*d.statement())) {
        return false;
    }
 
    autoContinueMask.exitLoopBody();
 
    // Point the debugger at the do-statement's test-expression before we run it.
    this->emitTraceLine(d.test()->fPosition);
 
    // Emit the test-expression, in order to combine it with the loop mask.
    if (!this->pushExpression(*d.test())) {
        return false;
    }
 
    // Mask off any lanes in the loop mask where the test-expression is false; this breaks the loop.
    // We don't use the test expression for anything else, so jettison it.
    fBuilder.merge_loop_mask();
    this->discardExpression(/*slots=*/1);
 
    // If any lanes are still running, go back to the top and run the loop body again.
    fBuilder.branch_if_any_lanes_active(labelID);
 
    // If we hit a break statement on all lanes, we will branch here to escape from the loop.
    fBuilder.label(breakTarget.labelID());
 
    // Restore the loop mask.
    fBuilder.pop_loop_mask();
    fBuilder.disableExecutionMaskWrites();
 
    return true;
}

writeDynamicallyUniformIfStatement()

bool SkSL::RP::Generator::writeDynamicallyUniformIfStatement

(

const IfStatement &

i

)

Definition at line 1967 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                       {
    SkASSERT(Analysis::IsDynamicallyUniformExpression(*i.test()));
 
    int falseLabelID = fBuilder.nextLabelID();
    int exitLabelID = fBuilder.nextLabelID();
 
    if (!this->pushExpression(*i.test())) {
        return unsupported();
    }
 
    fBuilder.branch_if_no_active_lanes_on_stack_top_equal(~0, falseLabelID);
 
    if (!this->writeStatement(*i.ifTrue())) {
        return unsupported();
    }
 
    if (!i.ifFalse()) {
        // We don't have an if-false condition at all.
        fBuilder.label(falseLabelID);
    } else {
        // We do have an if-false condition. We've just completed the if-true block, so we need to
        // jump past the if-false block to avoid executing it.
        fBuilder.jump(exitLabelID);
 
        // The if-false block starts here.
        fBuilder.label(falseLabelID);
 
        if (!this->writeStatement(*i.ifFalse())) {
            return unsupported();
        }
 
        fBuilder.label(exitLabelID);
    }
 
    // Jettison the test-expression.
    this->discardExpression(/*slots=*/1);
    return true;
}

writeExpressionStatement()

bool SkSL::RP::Generator::writeExpressionStatement

(

const ExpressionStatement &

e

)

Definition at line 1959 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                     {
    if (!this->pushExpression(*e.expression(), /*usesResult=*/false)) {
        return unsupported();
    }
    this->discardExpression(e.expression()->type().slotCount());
    return true;
}

writeForStatement()

bool SkSL::RP::Generator::writeForStatement

(

const ForStatement &

f

)

Definition at line 1856 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                       {
    // If we've determined that the loop does not run, omit its code entirely.
    if (f.unrollInfo() && f.unrollInfo()->fCount == 0) {
        return true;
    }
 
    // If the loop doesn't escape early due to a `continue`, `break` or `return`, and the loop
    // conforms to ES2 structure, we know that we will run the full number of iterations across all
    // lanes and don't need to use a loop mask.
    Analysis::LoopControlFlowInfo loopInfo = Analysis::GetLoopControlFlowInfo(*f.statement());
    if (!loopInfo.fHasContinue && !loopInfo.fHasBreak && !loopInfo.fHasReturn && f.unrollInfo()) {
        return this->writeMasklessForStatement(f);
    }
 
    // We want the loop index to disappear at the end of the loop, so wrap the for statement in a
    // trace scope.
    this->pushTraceScopeMask();
    this->emitTraceScope(+1);
 
    // Set up a break target.
    AutoLoopTarget breakTarget(this, &fCurrentBreakTarget);
 
    // Run the loop initializer.
    if (f.initializer()) {
        if (!this->writeStatement(*f.initializer())) {
            return unsupported();
        }
    } else {
        this->emitTraceLine(f.fPosition);
    }
 
    AutoContinueMask autoContinueMask(this);
    if (loopInfo.fHasContinue) {
        // Acquire a temporary slot for continue-mask storage.
        autoContinueMask.enable();
    }
 
    // Save off the original loop mask.
    fBuilder.enableExecutionMaskWrites();
    fBuilder.push_loop_mask();
 
    int loopTestID = fBuilder.nextLabelID();
    int loopBodyID = fBuilder.nextLabelID();
 
    // Jump down to the loop test so we can fall out of the loop immediately if it's zero-iteration.
    fBuilder.jump(loopTestID);
 
    // Write the for-loop body.
    fBuilder.label(loopBodyID);
 
    autoContinueMask.enterLoopBody();
 
    if (!this->writeStatement(*f.statement())) {
        return unsupported();
    }
 
    autoContinueMask.exitLoopBody();
 
    // Point the debugger at the for-statement's next-expression before we run it, or as close as we
    // can reasonably get.
    if (f.next()) {
        this->emitTraceLine(f.next()->fPosition);
    } else if (f.test()) {
        this->emitTraceLine(f.test()->fPosition);
    } else {
        this->emitTraceLine(f.fPosition);
    }
 
    // Run the next-expression. Immediately discard its result.
    if (f.next()) {
        if (!this->pushExpression(*f.next(), /*usesResult=*/false)) {
            return unsupported();
        }
        this->discardExpression(f.next()->type().slotCount());
    }
 
    fBuilder.label(loopTestID);
    if (f.test()) {
        // Emit the test-expression, in order to combine it with the loop mask.
        if (!this->pushExpression(*f.test())) {
            return unsupported();
        }
        // Mask off any lanes in the loop mask where the test-expression is false; this breaks the
        // loop. We don't use the test expression for anything else, so jettison it.
        fBuilder.merge_loop_mask();
        this->discardExpression(/*slots=*/1);
    }
 
    // If any lanes are still running, go back to the top and run the loop body again.
    fBuilder.branch_if_any_lanes_active(loopBodyID);
 
    // If we hit a break statement on all lanes, we will branch here to escape from the loop.
    fBuilder.label(breakTarget.labelID());
 
    // Restore the loop mask.
    fBuilder.pop_loop_mask();
    fBuilder.disableExecutionMaskWrites();
 
    this->emitTraceScope(-1);
    this->discardTraceScopeMask();
    return true;
}

writeFunction()

std::optional< SlotRange > SkSL::RP::Generator::writeFunction	(	const IRNode &	callSite,
		const FunctionDefinition &	function,
		SkSpan< std::unique_ptr< Expression > const >	arguments
	)

Converts an SkSL function into a set of Instructions. Returns nullopt if the function contained unsupported statements or expressions.

Definition at line 1378 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                           {
    // Generate debug information and emit a trace-enter op.
    int funcIndex = -1;
    if (fDebugTrace) {
        funcIndex = this->getFunctionDebugInfo(function.declaration());
        SkASSERT(funcIndex >= 0);
        if (this->shouldWriteTraceOps()) {
            fBuilder.trace_enter(fTraceMask->stackID(), funcIndex);
        }
    }
 
    // Handle parameter lvalues.
    struct RemappedSlotRange {
        const Variable* fVariable;
        std::optional<SlotRange> fSlotRange;
    };
    SkSpan<Variable* const> parameters = function.declaration().parameters();
    TArray<std::unique_ptr<LValue>> lvalues;
    TArray<RemappedSlotRange> remappedSlotRanges;
 
    if (function.declaration().isMain()) {
        // For main(), the parameter slots have already been populated by `writeProgram`, but we
        // still need to explicitly emit trace ops for the variables in main(), since they are
        // initialized before it is safe to use trace-var. (We can't invoke init-lane-masks until
        // after we've copied the inputs from main into slots, because dst.rgba is used to pass in a
        // blend-destination color, but we clobber it and put in the execution mask instead.)
        if (this->shouldWriteTraceOps()) {
            for (const Variable* var : parameters) {
                fBuilder.trace_var(fTraceMask->stackID(), this->getVariableSlots(*var));
            }
        }
    } else {
        // Write all the arguments into their parameter's variable slots. Because we never allow
        // recursion, we don't need to worry about overwriting any existing values in those slots.
        // (In fact, we don't even need to apply the write mask.)
        lvalues.resize(arguments.size());
 
        for (size_t index = 0; index < arguments.size(); ++index) {
            const Expression& arg = *arguments[index];
            const Variable& param = *parameters[index];
 
            // Use LValues for out-parameters and inout-parameters, so we can store back to them
            // later.
            if (IsInoutParameter(param) || IsOutParameter(param)) {
                lvalues[index] = this->makeLValue(arg);
                if (!lvalues[index]) {
                    return std::nullopt;
                }
                // There are no guarantees on the starting value of an out-parameter, so we only
                // need to store the lvalues associated with an inout parameter.
                if (IsInoutParameter(param)) {
                    if (!this->push(*lvalues[index])) {
                        return std::nullopt;
                    }
                    this->popToSlotRangeUnmasked(this->getVariableSlots(param));
                }
                continue;
            }
 
            // If a parameter is never read by the function, we don't need to populate its slots.
            ProgramUsage::VariableCounts paramCounts = fProgram.fUsage->get(param);
            if (paramCounts.fRead == 0) {
                // Honor the expression's side effects, if any.
                if (Analysis::HasSideEffects(arg)) {
                    if (!this->pushExpression(arg, /*usesResult=*/false)) {
                        return std::nullopt;
                    }
                    this->discardExpression(arg.type().slotCount());
                }
                continue;
            }
 
            // If the expression is a plain variable and the parameter is never written to, we don't
            // need to copy it; we can just share the slots from the existing variable.
            if (paramCounts.fWrite == 0 && arg.is<VariableReference>()) {
                const Variable& var = *arg.as<VariableReference>().variable();
                if (this->hasVariableSlots(var)) {
                    std::optional<SlotRange> originalRange =
                            fProgramSlots.mapVariableToSlots(param, this->getVariableSlots(var));
                    remappedSlotRanges.push_back({&param, originalRange});
                    continue;
                }
            }
 
            // Copy input arguments into their respective parameter slots.
            if (!this->pushExpression(arg)) {
                return std::nullopt;
            }
            this->popToSlotRangeUnmasked(this->getVariableSlots(param));
        }
    }
 
    // Set up a slot range dedicated to this function's return value.
    SlotRange lastFunctionResult = fCurrentFunctionResult;
    fCurrentFunctionResult = this->getFunctionSlots(callSite, function.declaration());
 
    // Save off the return mask.
    if (this->needsReturnMask(&function)) {
        fBuilder.enableExecutionMaskWrites();
        if (!function.declaration().isMain()) {
            fBuilder.push_return_mask();
        }
    }
 
    // Emit the function body.
    if (!this->writeStatement(*function.body())) {
        return std::nullopt;
    }
 
    // Restore the original return mask.
    if (this->needsReturnMask(&function)) {
        if (!function.declaration().isMain()) {
            fBuilder.pop_return_mask();
        }
        fBuilder.disableExecutionMaskWrites();
    }
 
    // Restore the function-result slot range.
    SlotRange functionResult = fCurrentFunctionResult;
    fCurrentFunctionResult = lastFunctionResult;
 
    // Emit a trace-exit op.
    if (fDebugTrace && fWriteTraceOps) {
        fBuilder.trace_exit(fTraceMask->stackID(), funcIndex);
    }
 
    // Copy out-parameters and inout-parameters back to their homes.
    for (int index = 0; index < lvalues.size(); ++index) {
        if (lvalues[index]) {
            // Only out- and inout-parameters should have an associated lvalue.
            const Variable& param = *parameters[index];
            SkASSERT(IsInoutParameter(param) || IsOutParameter(param));
 
            // Copy the parameter's slots directly into the lvalue.
            fBuilder.push_slots(this->getVariableSlots(param));
            if (!this->store(*lvalues[index])) {
                return std::nullopt;
            }
            this->discardExpression(param.type().slotCount());
        }
    }
 
    // Restore any remapped parameter slot ranges to their original values.
    for (const RemappedSlotRange& remapped : remappedSlotRanges) {
        if (remapped.fSlotRange.has_value()) {
            fProgramSlots.mapVariableToSlots(*remapped.fVariable, *remapped.fSlotRange);
        } else {
            fProgramSlots.unmapVariableSlots(*remapped.fVariable);
        }
    }
 
    return functionResult;
}

writeGlobals()

bool SkSL::RP::Generator::writeGlobals

(

)

Definition at line 1583 of file SkSLRasterPipelineCodeGenerator.cpp.

                             {
    for (const ProgramElement* e : fProgram.elements()) {
        if (e->is<GlobalVarDeclaration>()) {
            const GlobalVarDeclaration& gvd = e->as<GlobalVarDeclaration>();
            const VarDeclaration& decl = gvd.varDeclaration();
            const Variable* var = decl.var();
 
            if (var->type().isEffectChild()) {
                // Associate each child effect variable with its numeric index.
                SkASSERT(!fChildEffectMap.find(var));
                int childEffectIndex = fChildEffectMap.count();
                fChildEffectMap[var] = childEffectIndex;
                continue;
            }
 
            // Opaque types include child processors and GL objects (samplers, textures, etc).
            // Of those, only child processors are legal variables.
            SkASSERT(!var->type().isVoid());
            SkASSERT(!var->type().isOpaque());
 
            // Builtin variables are system-defined, with special semantics.
            if (int builtin = var->layout().fBuiltin; builtin >= 0) {
                if (builtin == SK_FRAGCOORD_BUILTIN) {
                    fBuilder.store_device_xy01(this->getVariableSlots(*var));
                    continue;
                }
                // The only builtin variable exposed to runtime effects is sk_FragCoord.
                return unsupported();
            }
 
            if (IsUniform(*var)) {
                // Create the uniform slot map in first-to-last order.
                SlotRange uniformSlotRange = this->getUniformSlots(*var);
 
                if (this->shouldWriteTraceOps()) {
                    // We expect uniform values to show up in the debug trace. To make this happen
                    // without updating the file format, we synthesize a value-slot range for the
                    // uniform here, and copy the uniform data into the value slots. This allows
                    // trace_var to work naturally. This wastes a bit of memory, but debug traces
                    // don't need to be hyper-efficient.
                    SlotRange copyRange = fProgramSlots.getVariableSlots(*var);
                    fBuilder.push_uniform(uniformSlotRange);
                    this->popToSlotRangeUnmasked(copyRange);
                }
 
                continue;
            }
 
            // Other globals are treated as normal variable declarations.
            if (!this->writeVarDeclaration(decl)) {
                return unsupported();
            }
        }
    }
 
    return true;
}

writeIfStatement()

bool SkSL::RP::Generator::writeIfStatement

(

const IfStatement &

i

)

Definition at line 2006 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                     {
    // If the test condition is known to be uniform, we can skip over the untrue portion entirely.
    if (Analysis::IsDynamicallyUniformExpression(*i.test())) {
        return this->writeDynamicallyUniformIfStatement(i);
    }
 
    // Save the current condition-mask.
    fBuilder.enableExecutionMaskWrites();
    fBuilder.push_condition_mask();
 
    // Push the test condition mask.
    if (!this->pushExpression(*i.test())) {
        return unsupported();
    }
 
    // Merge the current condition-mask with the test condition, then run the if-true branch.
    fBuilder.merge_condition_mask();
    if (!this->writeStatement(*i.ifTrue())) {
        return unsupported();
    }
 
    if (i.ifFalse()) {
        // Apply the inverse condition-mask. Then run the if-false branch.
        fBuilder.merge_inv_condition_mask();
        if (!this->writeStatement(*i.ifFalse())) {
            return unsupported();
        }
    }
 
    // Jettison the test-expression, and restore the the condition-mask.
    this->discardExpression(/*slots=*/1);
    fBuilder.pop_condition_mask();
    fBuilder.disableExecutionMaskWrites();
 
    return true;
}

writeImmutableVarDeclaration()

bool SkSL::RP::Generator::writeImmutableVarDeclaration

(

const VarDeclaration &

d

)

Definition at line 2126 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                    {
    // In a debugging session, we expect debug traces for a variable declaration to appear, even if
    // it's constant, so we don't use immutable slots for variables when tracing is on.
    if (this->shouldWriteTraceOps()) {
        return false;
    }
 
    // Find the constant value for this variable.
    const Expression* initialValue = ConstantFolder::GetConstantValueForVariable(*d.value());
    SkASSERT(initialValue);
 
    // For a variable to be immutable, it cannot be written-to besides its initial declaration.
    ProgramUsage::VariableCounts counts = fProgram.fUsage->get(*d.var());
    if (counts.fWrite != 1) {
        return false;
    }
 
    STArray<16, ImmutableBits> immutableValues;
    if (!this->getImmutableValueForExpression(*initialValue, &immutableValues)) {
        return false;
    }
 
    fImmutableVariables.add(d.var());
 
    std::optional<SlotRange> preexistingSlots = this->findPreexistingImmutableData(immutableValues);
    if (preexistingSlots.has_value()) {
        // Associate this variable with a preexisting range of immutable data (no new data or code).
        fImmutableSlots.mapVariableToSlots(*d.var(), *preexistingSlots);
    } else {
        // Write out the constant value back to immutable slots. (This generates data, but no
        // runtime code.)
        SlotRange slots = this->getImmutableSlots(*d.var());
        this->storeImmutableValueToSlots(immutableValues, slots);
    }
 
    return true;
}

writeMasklessForStatement()

bool SkSL::RP::Generator::writeMasklessForStatement

(

const ForStatement &

f

)

Definition at line 1788 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                               {
    SkASSERT(f.unrollInfo());
    SkASSERT(f.unrollInfo()->fCount > 0);
    SkASSERT(f.initializer());
    SkASSERT(f.test());
    SkASSERT(f.next());
 
    // We want the loop index to disappear at the end of the loop, so wrap the for statement in a
    // trace scope.
    this->pushTraceScopeMask();
    this->emitTraceScope(+1);
 
    // If no lanes are active, skip over the loop entirely. This guards against looping forever;
    // with no lanes active, we wouldn't be able to write the loop variable back to its slot, so
    // we'd never make forward progress.
    int loopExitID = fBuilder.nextLabelID();
    int loopBodyID = fBuilder.nextLabelID();
    fBuilder.branch_if_no_lanes_active(loopExitID);
 
    // Run the loop initializer.
    if (!this->writeStatement(*f.initializer())) {
        return unsupported();
    }
 
    // Write the for-loop body. We know the for-loop has a standard ES2 unrollable structure, and
    // that it runs for at least one iteration, so we can plow straight ahead into the loop body
    // instead of running the loop-test first.
    fBuilder.label(loopBodyID);
 
    if (!this->writeStatement(*f.statement())) {
        return unsupported();
    }
 
    // Point the debugger at the for-statement's next-expression before we run it, or as close as we
    // can reasonably get.
    if (f.next()) {
        this->emitTraceLine(f.next()->fPosition);
    } else if (f.test()) {
        this->emitTraceLine(f.test()->fPosition);
    } else {
        this->emitTraceLine(f.fPosition);
    }
 
    // If the loop only runs for a single iteration, we are already done. If not...
    if (f.unrollInfo()->fCount > 1) {
        // ... run the next-expression, and immediately discard its result.
        if (!this->pushExpression(*f.next(), /*usesResult=*/false)) {
            return unsupported();
        }
        this->discardExpression(f.next()->type().slotCount());
 
        // Run the test-expression, and repeat the loop until the test-expression evaluates false.
        if (!this->pushExpression(*f.test())) {
            return unsupported();
        }
        fBuilder.branch_if_no_active_lanes_on_stack_top_equal(0, loopBodyID);
 
        // Jettison the test-expression.
        this->discardExpression(/*slots=*/1);
    }
 
    fBuilder.label(loopExitID);
 
    this->emitTraceScope(-1);
    this->discardTraceScopeMask();
    return true;
}

writeProgram()

bool SkSL::RP::Generator::writeProgram

(

const FunctionDefinition &

function

)

Converts the SkSL main() function into a set of Instructions.

Definition at line 3975 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                               {
    fCurrentFunction = &function;
 
    if (fDebugTrace) {
        // Copy the program source into the debug info so that it will be written in the trace file.
        fDebugTrace->setSource(*fProgram.fSource);
 
        if (fWriteTraceOps) {
            // The Raster Pipeline blitter generates centered pixel coordinates. (0.5, 1.5, 2.5,
            // etc.) Add 0.5 to the requested trace coordinate to match this, then compare against
            // src.rg, which contains the shader's coordinates. We keep this result in a dedicated
            // trace-mask stack.
            fTraceMask.emplace(this);
            fTraceMask->enter();
            fBuilder.push_device_xy01();
            fBuilder.discard_stack(2);
            fBuilder.push_constant_f(fDebugTrace->fTraceCoord.fX + 0.5f);
            fBuilder.push_constant_f(fDebugTrace->fTraceCoord.fY + 0.5f);
            fBuilder.binary_op(BuilderOp::cmpeq_n_floats, 2);
            fBuilder.binary_op(BuilderOp::bitwise_and_n_ints, 1);
            fTraceMask->exit();
 
            // Assemble a position-to-line-number mapping for the debugger.
            this->calculateLineOffsets();
        }
    }
 
    // Assign slots to the parameters of main; copy src and dst into those slots as appropriate.
    const SkSL::Variable* mainCoordsParam = function.declaration().getMainCoordsParameter();
    const SkSL::Variable* mainInputColorParam = function.declaration().getMainInputColorParameter();
    const SkSL::Variable* mainDestColorParam = function.declaration().getMainDestColorParameter();
 
    for (const SkSL::Variable* param : function.declaration().parameters()) {
        if (param == mainCoordsParam) {
            // Coordinates are passed via RG.
            SlotRange fragCoord = this->getVariableSlots(*param);
            SkASSERT(fragCoord.count == 2);
            fBuilder.store_src_rg(fragCoord);
        } else if (param == mainInputColorParam) {
            // Input colors are passed via RGBA.
            SlotRange srcColor = this->getVariableSlots(*param);
            SkASSERT(srcColor.count == 4);
            fBuilder.store_src(srcColor);
        } else if (param == mainDestColorParam) {
            // Dest colors are passed via dRGBA.
            SlotRange destColor = this->getVariableSlots(*param);
            SkASSERT(destColor.count == 4);
            fBuilder.store_dst(destColor);
        } else {
            SkDEBUGFAIL("Invalid parameter to main()");
            return unsupported();
        }
    }
 
    // Initialize the program.
    fBuilder.init_lane_masks();
 
    // Emit global variables.
    if (!this->writeGlobals()) {
        return unsupported();
    }
 
    // Invoke main().
    std::optional<SlotRange> mainResult = this->writeFunction(function, function, /*arguments=*/{});
    if (!mainResult.has_value()) {
        return unsupported();
    }
 
    // Move the result of main() from slots into RGBA.
    SkASSERT(mainResult->count == 4);
    if (this->needsFunctionResultSlots(fCurrentFunction)) {
        fBuilder.load_src(*mainResult);
    } else {
        fBuilder.pop_src_rgba();
    }
 
    // Discard the trace mask.
    if (fTraceMask.has_value()) {
        fTraceMask->enter();
        fBuilder.discard_stack(1);
        fTraceMask->exit();
    }
 
    return true;
}

writeReturnStatement()

bool SkSL::RP::Generator::writeReturnStatement

(

const ReturnStatement &

r

)

Definition at line 2043 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                             {
    if (r.expression()) {
        if (!this->pushExpression(*r.expression())) {
            return unsupported();
        }
        if (this->needsFunctionResultSlots(fCurrentFunction)) {
            this->popToSlotRange(fCurrentFunctionResult);
        }
    }
    if (fBuilder.executionMaskWritesAreEnabled() && this->needsReturnMask(fCurrentFunction)) {
        fBuilder.mask_off_return_mask();
    }
    return true;
}

writeStatement()

bool SkSL::RP::Generator::writeStatement

(

const Statement &

s

)

Appends a statement to the program.

Definition at line 1641 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                 {
    switch (s.kind()) {
        case Statement::Kind::kBlock:
            // The debugger will stop on statements inside Blocks; there's no need for an additional
            // stop on the block's initial open-brace.
        case Statement::Kind::kFor:
            // The debugger will stop on the init-statement of a for statement, so we don't need to
            // stop on the outer for-statement itself as well.
            break;
 
        default:
            // The debugger should stop on other statements.
            this->emitTraceLine(s.fPosition);
            break;
    }
 
    switch (s.kind()) {
        case Statement::Kind::kBlock:
            return this->writeBlock(s.as<Block>());
 
        case Statement::Kind::kBreak:
            return this->writeBreakStatement(s.as<BreakStatement>());
 
        case Statement::Kind::kContinue:
            return this->writeContinueStatement(s.as<ContinueStatement>());
 
        case Statement::Kind::kDo:
            return this->writeDoStatement(s.as<DoStatement>());
 
        case Statement::Kind::kExpression:
            return this->writeExpressionStatement(s.as<ExpressionStatement>());
 
        case Statement::Kind::kFor:
            return this->writeForStatement(s.as<ForStatement>());
 
        case Statement::Kind::kIf:
            return this->writeIfStatement(s.as<IfStatement>());
 
        case Statement::Kind::kNop:
            return true;
 
        case Statement::Kind::kReturn:
            return this->writeReturnStatement(s.as<ReturnStatement>());
 
        case Statement::Kind::kSwitch:
            return this->writeSwitchStatement(s.as<SwitchStatement>());
 
        case Statement::Kind::kVarDeclaration:
            return this->writeVarDeclaration(s.as<VarDeclaration>());
 
        default:
            return unsupported();
    }
}

writeSwitchStatement()

bool SkSL::RP::Generator::writeSwitchStatement

(

const SwitchStatement &

s

)

Definition at line 2058 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                             {
    const StatementArray& cases = s.cases();
    SkASSERT(std::all_of(cases.begin(), cases.end(), [](const std::unique_ptr<Statement>& stmt) {
        return stmt->is<SwitchCase>();
    }));
 
    // Set up a break target.
    AutoLoopTarget breakTarget(this, &fCurrentBreakTarget);
 
    // Save off the original loop mask.
    fBuilder.enableExecutionMaskWrites();
    fBuilder.push_loop_mask();
 
    // Push the switch-case value, and write a default-mask that enables every lane which already
    // has an active loop mask. As we match cases, the default mask will get pared down.
    if (!this->pushExpression(*s.value())) {
        return unsupported();
    }
    fBuilder.push_loop_mask();
 
    // Zero out the loop mask; each case op will re-enable it as we go.
    fBuilder.mask_off_loop_mask();
 
    // Write each switch-case.
    bool foundDefaultCase = false;
    for (const std::unique_ptr<Statement>& stmt : cases) {
        int skipLabelID = fBuilder.nextLabelID();
 
        const SwitchCase& sc = stmt->as<SwitchCase>();
        if (sc.isDefault()) {
            foundDefaultCase = true;
            if (stmt.get() != cases.back().get()) {
                // We only support a default case when it is the very last case. If that changes,
                // this logic will need to be updated.
                return unsupported();
            }
            // Keep whatever lanes are executing now, and also enable any lanes in the default mask.
            fBuilder.pop_and_reenable_loop_mask();
            // Execute the switch-case block, if any lanes are alive to see it.
            fBuilder.branch_if_no_lanes_active(skipLabelID);
            if (!this->writeStatement(*sc.statement())) {
                return unsupported();
            }
        } else {
            // The case-op will enable the loop mask if the switch-value matches, and mask off lanes
            // from the default-mask.
            fBuilder.case_op(sc.value());
            // Execute the switch-case block, if any lanes are alive to see it.
            fBuilder.branch_if_no_lanes_active(skipLabelID);
            if (!this->writeStatement(*sc.statement())) {
                return unsupported();
            }
        }
        fBuilder.label(skipLabelID);
    }
 
    // Jettison the switch value, and the default case mask if it was never consumed above.
    this->discardExpression(/*slots=*/foundDefaultCase ? 1 : 2);
 
    // If we hit a break statement on all lanes, we will branch here to escape from the switch.
    fBuilder.label(breakTarget.labelID());
 
    // Restore the loop mask.
    fBuilder.pop_loop_mask();
    fBuilder.disableExecutionMaskWrites();
    return true;
}

writeVarDeclaration()

bool SkSL::RP::Generator::writeVarDeclaration

(

const VarDeclaration &

v

)

Definition at line 2164 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                           {
    if (v.value()) {
        // If a variable never actually changes, we can make it immutable.
        if (this->writeImmutableVarDeclaration(v)) {
            return true;
        }
        // This is a real variable which can change over the course of execution.
        if (!this->pushExpression(*v.value())) {
            return unsupported();
        }
        this->popToSlotRangeUnmasked(this->getVariableSlots(*v.var()));
    } else {
        this->zeroSlotRangeUnmasked(this->getVariableSlots(*v.var()));
    }
    return true;
}

zeroSlotRangeUnmasked()

void SkSL::RP::Generator::zeroSlotRangeUnmasked ( SlotRange  r )

inline

Zeroes out a range of slots.

Definition at line 374 of file SkSLRasterPipelineCodeGenerator.cpp.

                                            {
        fBuilder.zero_slots_unmasked(r);
        if (this->shouldWriteTraceOps()) {
            fBuilder.trace_var(fTraceMask->stackID(), r);
        }
    }

Friends And Related Function Documentation

AutoContinueMask

friend class AutoContinueMask

friend

Definition at line 561 of file SkSLRasterPipelineCodeGenerator.cpp.

---

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

• third_party/skia/src/sksl/codegen/SkSLRasterPipelineCodeGenerator.cpp