SkSL::RP::SlotManager Class Reference

Public Member Functions
	SlotManager (std::vector< SlotDebugInfo > *i)
void	addSlotDebugInfoForGroup (const std::string &varName, const Type &type, Position pos, int *groupIndex, bool isFunctionReturnValue)
void	addSlotDebugInfo (const std::string &varName, const Type &type, Position pos, bool isFunctionReturnValue)
SlotRange	createSlots (std::string name, const Type &type, Position pos, bool isFunctionReturnValue)
std::optional< SlotRange >	mapVariableToSlots (const Variable &v, SlotRange range)
void	unmapVariableSlots (const Variable &v)
SlotRange	getVariableSlots (const Variable &v)
SlotRange	getFunctionSlots (const IRNode &callSite, const FunctionDeclaration &f)
int	slotCount () const

Detailed Description

Definition at line 95 of file SkSLRasterPipelineCodeGenerator.cpp.

Constructor & Destructor Documentation

SlotManager()

SkSL::RP::SlotManager::SlotManager ( std::vector< SlotDebugInfo > *  i )

inline

Definition at line 97 of file SkSLRasterPipelineCodeGenerator.cpp.

: fSlotDebugInfo(i) {}

Member Function Documentation

addSlotDebugInfo()

void SkSL::RP::SlotManager::addSlotDebugInfo	(	const std::string &	varName,
		const Type &	type,
		Position	pos,
		bool	isFunctionReturnValue
	)

Definition at line 1160 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                               {
    int groupIndex = 0;
    this->addSlotDebugInfoForGroup(varName, type, pos, &groupIndex, isFunctionReturnValue);
    SkASSERT((size_t)groupIndex == type.slotCount());
}

addSlotDebugInfoForGroup()

void SkSL::RP::SlotManager::addSlotDebugInfoForGroup	(	const std::string &	varName,
		const Type &	type,
		Position	pos,
		int *	groupIndex,
		bool	isFunctionReturnValue
	)

Used by createSlots to add this variable to SlotDebugInfo inside the DebugTrace.

Definition at line 1109 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                       {
    SkASSERT(fSlotDebugInfo);
    switch (type.typeKind()) {
        case Type::TypeKind::kArray: {
            int nslots = type.columns();
            const Type& elemType = type.componentType();
            for (int slot = 0; slot < nslots; ++slot) {
                this->addSlotDebugInfoForGroup(varName + "[" + std::to_string(slot) + "]", elemType,
                                               pos, groupIndex, isFunctionReturnValue);
            }
            break;
        }
        case Type::TypeKind::kStruct: {
            for (const Field& field : type.fields()) {
                this->addSlotDebugInfoForGroup(varName + "." + std::string(field.fName),
                                               *field.fType, pos, groupIndex,
                                               isFunctionReturnValue);
            }
            break;
        }
        default:
            SkASSERTF(0, "unsupported slot type %d", (int)type.typeKind());
            [[fallthrough]];
 
        case Type::TypeKind::kScalar:
        case Type::TypeKind::kVector:
        case Type::TypeKind::kMatrix: {
            Type::NumberKind numberKind = type.componentType().numberKind();
            int nslots = type.slotCount();
 
            for (int slot = 0; slot < nslots; ++slot) {
                SlotDebugInfo slotInfo;
                slotInfo.name = varName;
                slotInfo.columns = type.columns();
                slotInfo.rows = type.rows();
                slotInfo.componentIndex = slot;
                slotInfo.groupIndex = (*groupIndex)++;
                slotInfo.numberKind = numberKind;
                slotInfo.pos = pos;
                slotInfo.fnReturnValue = isFunctionReturnValue ? 1 : -1;
                fSlotDebugInfo->push_back(std::move(slotInfo));
            }
            break;
        }
    }
}

createSlots()

SlotRange SkSL::RP::SlotManager::createSlots	(	std::string	name,
		const Type &	type,
		Position	pos,
		bool	isFunctionReturnValue
	)

Creates slots associated with an SkSL variable or return value.

Definition at line 1169 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                               {
    size_t nslots = type.slotCount();
    if (nslots == 0) {
        return {};
    }
    if (fSlotDebugInfo) {
        // Our debug slot-info table should have the same length as the actual slot table.
        SkASSERT(fSlotDebugInfo->size() == (size_t)fSlotCount);
 
        // Append slot names and types to our debug slot-info table.
        fSlotDebugInfo->reserve(fSlotCount + nslots);
        this->addSlotDebugInfo(name, type, pos, isFunctionReturnValue);
 
        // Confirm that we added the expected number of slots.
        SkASSERT(fSlotDebugInfo->size() == (size_t)(fSlotCount + nslots));
    }
 
    SlotRange result = {fSlotCount, (int)nslots};
    fSlotCount += nslots;
    return result;
}

getFunctionSlots()

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

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 1220 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                            {
    SlotRange* entry = fSlotMap.find(&callSite);
    if (entry != nullptr) {
        return *entry;
    }
    SlotRange range = this->createSlots("[" + std::string(f.name()) + "].result",
                                        f.returnType(),
                                        f.fPosition,
                                        /*isFunctionReturnValue=*/true);
    fSlotMap.set(&callSite, range);
    return range;
}

getVariableSlots()

SlotRange SkSL::RP::SlotManager::getVariableSlots

(

const Variable &

v

)

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

Definition at line 1207 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                         {
    SlotRange* entry = fSlotMap.find(&v);
    if (entry != nullptr) {
        return *entry;
    }
    SlotRange range = this->createSlots(std::string(v.name()),
                                        v.type(),
                                        v.fPosition,
                                        /*isFunctionReturnValue=*/false);
    this->mapVariableToSlots(v, range);
    return range;
}

mapVariableToSlots()

std::optional< SlotRange > SkSL::RP::SlotManager::mapVariableToSlots	(	const Variable &	v,
		SlotRange	range
	)

Associates previously-created slots with an SkSL variable; this can allow multiple variables to share overlapping ranges. If the variable was already associated with a slot range, returns the previously associated range.

Definition at line 1194 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                                         {
    SkASSERT(v.type().slotCount() == SkToSizeT(range.count));
    const SlotRange* existingEntry = fSlotMap.find(&v);
    std::optional<SlotRange> originalRange = existingEntry ? std::optional(*existingEntry)
                                                           : std::nullopt;
    fSlotMap.set(&v, range);
    return originalRange;
}

slotCount()

int SkSL::RP::SlotManager::slotCount ( ) const

inline

Returns the total number of slots consumed.

Definition at line 140 of file SkSLRasterPipelineCodeGenerator.cpp.

{ return fSlotCount; }

unmapVariableSlots()

void SkSL::RP::SlotManager::unmapVariableSlots

(

const Variable &

v

)

Deletes the existing mapping between a variable and its slots; a future call to getVariableSlots will see this as a brand new variable and associate new slots.

Definition at line 1203 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                      {
    fSlotMap.remove(&v);
}

---

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

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