SkSL::FunctionDeclaration Class Reference

#include <SkSLFunctionDeclaration.h>

Inheritance diagram for SkSL::FunctionDeclaration:

Public Types
using	ParamTypes = skia_private::STArray< 8, const Type * >
Public Types inherited from SkSL::Symbol
using	Kind = SymbolKind

Public Member Functions
	FunctionDeclaration (const Context &context, Position pos, ModifierFlags modifierFlags, std::string_view name, skia_private::TArray< Variable * > parameters, const Type *returnType, IntrinsicKind intrinsicKind)
ModifierFlags	modifierFlags () const
void	setModifierFlags (ModifierFlags m)
const FunctionDefinition *	definition () const
void	setDefinition (const FunctionDefinition *definition)
void	setNextOverload (FunctionDeclaration *overload)
SkSpan< Variable *const >	parameters () const
const Type &	returnType () const
bool	isBuiltin () const
bool	isMain () const
IntrinsicKind	intrinsicKind () const
bool	isIntrinsic () const
const FunctionDeclaration *	nextOverload () const
FunctionDeclaration *	mutableNextOverload () const
std::string	mangledName () const
std::string	description () const override
bool	matches (const FunctionDeclaration &f) const
const Variable *	getMainCoordsParameter () const
const Variable *	getMainInputColorParameter () const
const Variable *	getMainDestColorParameter () const
bool	determineFinalTypes (const ExpressionArray &arguments, ParamTypes *outParameterTypes, const Type **outReturnType) const
Public Member Functions inherited from SkSL::Symbol
	Symbol (Position pos, Kind kind, std::string_view name, const Type *type=nullptr)
	~Symbol () override
std::unique_ptr< Expression >	instantiate (const Context &context, Position pos) const
const Type &	type () const
Kind	kind () const
std::string_view	name () const
void	setName (std::string_view newName)
Public Member Functions inherited from SkSL::IRNode
virtual	~IRNode ()
	IRNode (const IRNode &)=delete
IRNode &	operator= (const IRNode &)=delete
Position	position () const
void	setPosition (Position p)
template<typename T >
bool	is () const
template<typename T >
const T &	as () const
template<typename T >
T &	as ()

Static Public Member Functions
static FunctionDeclaration *	Convert (const Context &context, Position pos, const Modifiers &modifiers, std::string_view name, skia_private::TArray< std::unique_ptr< Variable > > parameters, Position returnTypePos, const Type *returnType)
Static Public Member Functions inherited from SkSL::Poolable
static void *	operator new (const size_t size)
static void	operator delete (void *ptr)

Static Public Attributes
static constexpr Kind	kIRNodeKind = Kind::kFunctionDeclaration

Additional Inherited Members
Public Attributes inherited from SkSL::IRNode
Position	fPosition
Protected Member Functions inherited from SkSL::IRNode
	IRNode (Position position, int kind)
Protected Attributes inherited from SkSL::IRNode
int	fKind

Detailed Description

A function declaration (not a definition – does not contain a body).

Definition at line 36 of file SkSLFunctionDeclaration.h.

Member Typedef Documentation

ParamTypes

using SkSL::FunctionDeclaration::ParamTypes = skia_private::STArray<8, const Type*>

Determine the effective types of this function's parameters and return value when called with the given arguments. This is relevant for functions with generic parameter types, where this will collapse the generic types down into specific concrete types.

Returns true if it was able to select a concrete set of types for the generic function, false if there is no possible way this can match the argument types. Note that even a true return does not guarantee that the function can be successfully called with those arguments, merely indicates that an attempt should be made. If false is returned, the state of outParameterTypes and outReturnType are undefined.

This always assumes narrowing conversions are allowed. The calling code needs to verify that each argument can actually be coerced to the final parameter type, respecting the narrowing-conversions flag. This is handled in callCost(), or in convertCall() (via coerce).

Definition at line 147 of file SkSLFunctionDeclaration.h.

Constructor & Destructor Documentation

FunctionDeclaration()

SkSL::FunctionDeclaration::FunctionDeclaration	(	const Context &	context,
		Position	pos,
		ModifierFlags	modifierFlags,
		std::string_view	name,
		skia_private::TArray< Variable * >	parameters,
		const Type *	returnType,
		IntrinsicKind	intrinsicKind
	)

Definition at line 415 of file SkSLFunctionDeclaration.cpp.

        : INHERITED(pos, kIRNodeKind, name, /*type=*/nullptr)
        , fDefinition(nullptr)
        , fParameters(std::move(parameters))
        , fReturnType(returnType)
        , fModifierFlags(modifierFlags)
        , fIntrinsicKind(intrinsicKind)
        , fBuiltin(context.fConfig->fIsBuiltinCode)
        , fIsMain(name == "main") {
    int builtinColorIndex = 0;
    for (const Variable* param : fParameters) {
        // None of the parameters are allowed to be be null.
        SkASSERT(param);
 
        // Keep track of arguments to main for runtime effects.
        if (fIsMain) {
            if (ProgramConfig::IsRuntimeShader(context.fConfig->fKind) ||
                ProgramConfig::IsFragment(context.fConfig->fKind)) {
                // If this is a runtime shader, a float2 param is supposed to be the coords.
                // For testing purposes, we have .sksl inputs that are treated as both runtime
                // effects and fragment shaders. To make that work, fragment shaders are allowed to
                // have a coords parameter as well.
                if (type_is_valid_for_coords(param->type())) {
                    fHasMainCoordsParameter = true;
                }
            } else if (ProgramConfig::IsRuntimeColorFilter(context.fConfig->fKind) ||
                       ProgramConfig::IsRuntimeBlender(context.fConfig->fKind)) {
                // If this is a runtime color filter or blender, the params are an input color,
                // followed by a destination color for blenders.
                if (type_is_valid_for_color(param->type())) {
                    switch (builtinColorIndex++) {
                        case 0:  fHasMainInputColorParameter = true; break;
                        case 1:  fHasMainDestColorParameter = true;  break;
                        default: /* unknown color parameter */       break;
                    }
                }
            }
        }
    }
}

Member Function Documentation

Convert()

FunctionDeclaration * SkSL::FunctionDeclaration::Convert ( const Context &  context, Position  pos, const Modifiers &  modifiers, std::string_view  name, skia_private::TArray< std::unique_ptr< Variable > >  parameters, Position  returnTypePos, const Type *  returnType  )

static

Definition at line 462 of file SkSLFunctionDeclaration.cpp.

                                                                          {
    // No layout flag is permissible on a function.
    modifiers.fLayout.checkPermittedLayout(context, pos,
                                           /*permittedLayoutFlags=*/LayoutFlag::kNone);
 
    // If requested, apply the `noinline` modifier to every function. This allows us to test Runtime
    // Effects without any inlining, even when the code is later added to a paint.
    ModifierFlags modifierFlags = modifiers.fFlags;
    if (context.fConfig->fSettings.fForceNoInline) {
        modifierFlags &= ~ModifierFlag::kInline;
        modifierFlags |= ModifierFlag::kNoInline;
    }
 
    bool isMain = (name == "main");
    IntrinsicKind intrinsicKind = context.fConfig->fIsBuiltinCode ? FindIntrinsicKind(name)
                                                                  : kNotIntrinsic;
    FunctionDeclaration* decl = nullptr;
    if (!check_modifiers(context, modifiers.fPosition, modifierFlags) ||
        !check_return_type(context, returnTypePos, *returnType) ||
        !check_parameters(context, parameters, modifierFlags, intrinsicKind) ||
        (isMain && !check_main_signature(context, pos, *returnType, parameters)) ||
        !find_existing_declaration(context, pos, modifierFlags, intrinsicKind, name, parameters,
                                   returnTypePos, returnType, &decl)) {
        return nullptr;
    }
    TArray<Variable*> finalParameters;
    finalParameters.reserve_exact(parameters.size());
    for (std::unique_ptr<Variable>& param : parameters) {
        finalParameters.push_back(context.fSymbolTable->takeOwnershipOfSymbol(std::move(param)));
    }
    if (decl) {
        return decl;
    }
    return context.fSymbolTable->add(
            context,
            std::make_unique<FunctionDeclaration>(context,
                                                  pos,
                                                  modifierFlags,
                                                  name,
                                                  std::move(finalParameters),
                                                  returnType,
                                                  intrinsicKind));
}

definition()

const FunctionDefinition * SkSL::FunctionDeclaration::definition ( ) const

inline

Definition at line 64 of file SkSLFunctionDeclaration.h.

                                                 {
        return fDefinition;
    }

description()

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

overridevirtual

Implements SkSL::IRNode.

Definition at line 534 of file SkSLFunctionDeclaration.cpp.

                                                 {
    std::string result = (fModifierFlags ? fModifierFlags.description() + " " : std::string()) +
                         this->returnType().displayName() + " " + std::string(this->name()) + "(";
    auto separator = SkSL::String::Separator();
    for (const Variable* p : this->parameters()) {
        result += separator();
        result += p->description();
    }
    result += ")";
    return result;
}

determineFinalTypes()

bool SkSL::FunctionDeclaration::determineFinalTypes	(	const ExpressionArray &	arguments,
		ParamTypes *	outParameterTypes,
		const Type **	outReturnType
	)		const

Definition at line 563 of file SkSLFunctionDeclaration.cpp.

                                                                                {
    SkSpan<Variable* const> parameters = this->parameters();
    SkASSERT(SkToSizeT(arguments.size()) == parameters.size());
 
    outParameterTypes->reserve_exact(arguments.size());
    int genericIndex = -1;
    for (int i = 0; i < arguments.size(); i++) {
        // Non-generic parameters are final as-is.
        const Type& parameterType = parameters[i]->type();
        if (!parameterType.isGeneric()) {
            outParameterTypes->push_back(&parameterType);
            continue;
        }
        // We use the first generic parameter we find to lock in the generic index;
        // e.g. if we find `float3` here, all `$genType`s will be assumed to be `float3`.
        if (genericIndex == -1) {
            genericIndex = find_generic_index(arguments[i]->type(), parameterType,
                                              /*allowNarrowing=*/true);
            if (genericIndex == -1) {
                // The passed-in type wasn't a match for ANY of the generic possibilities.
                // This function isn't a match at all.
                return false;
            }
        }
        outParameterTypes->push_back(parameterType.coercibleTypes()[genericIndex]);
    }
    // Apply the generic index to our return type.
    const Type& returnType = this->returnType();
    if (returnType.isGeneric()) {
        if (genericIndex == -1) {
            // We don't support functions with a generic return type and no other generics.
            return false;
        }
        *outReturnType = returnType.coercibleTypes()[genericIndex];
    } else {
        *outReturnType = &returnType;
    }
    return true;
}

getMainCoordsParameter()

const Variable * SkSL::FunctionDeclaration::getMainCoordsParameter ( ) const

inline

If this function is main(), and it has the requested parameter, returns that parameter. For instance, only a runtime-blend program will have a dest-color parameter, in parameter 1; getMainDestColorParameter will return that parameter if this is a runtime-blend main() function. Otherwise, null is returned.

Definition at line 122 of file SkSLFunctionDeclaration.h.

                                                   {
        return fHasMainCoordsParameter ? fParameters[0] : nullptr;
    }

getMainDestColorParameter()

const Variable * SkSL::FunctionDeclaration::getMainDestColorParameter ( ) const

inline

Definition at line 128 of file SkSLFunctionDeclaration.h.

                                                      {
        return fHasMainDestColorParameter ? fParameters[1] : nullptr;
    }

getMainInputColorParameter()

const Variable * SkSL::FunctionDeclaration::getMainInputColorParameter ( ) const

inline

Definition at line 125 of file SkSLFunctionDeclaration.h.

                                                       {
        return fHasMainInputColorParameter ? fParameters[0] : nullptr;
    }

intrinsicKind()

IntrinsicKind SkSL::FunctionDeclaration::intrinsicKind ( ) const

inline

Definition at line 94 of file SkSLFunctionDeclaration.h.

                                        {
        return fIntrinsicKind;
    }

isBuiltin()

bool SkSL::FunctionDeclaration::isBuiltin ( ) const

inline

Definition at line 86 of file SkSLFunctionDeclaration.h.

                           {
        return fBuiltin;
    }

isIntrinsic()

bool SkSL::FunctionDeclaration::isIntrinsic ( ) const

inline

Definition at line 98 of file SkSLFunctionDeclaration.h.

                             {
        return this->intrinsicKind() != kNotIntrinsic;
    }

isMain()

bool SkSL::FunctionDeclaration::isMain ( ) const

inline

Definition at line 90 of file SkSLFunctionDeclaration.h.

                        {
        return fIsMain;
    }

mangledName()

std::string SkSL::FunctionDeclaration::mangledName

(

)

const

Definition at line 512 of file SkSLFunctionDeclaration.cpp.

                                                 {
    if ((this->isBuiltin() && !this->definition()) || this->isMain()) {
        // Builtins without a definition (like `sin` or `sqrt`) must use their real names.
        return std::string(this->name());
    }
    // Built-in functions can have a $ prefix, which will fail to compile in GLSL. Remove the
    // $ and add a unique mangling specifier, so user code can't conflict with the name.
    std::string_view name = this->name();
    const char* builtinMarker = "";
    if (skstd::starts_with(name, '$')) {
        name.remove_prefix(1);
        builtinMarker = "Q";  // a unique, otherwise-unused mangle character
    }
    // Rename function to `funcname_returntypeparamtypes`.
    std::string result = std::string(name) + "_" + builtinMarker +
                         this->returnType().abbreviatedName();
    for (const Variable* p : this->parameters()) {
        result += p->type().abbreviatedName();
    }
    return result;
}

matches()

bool SkSL::FunctionDeclaration::matches

(

const FunctionDeclaration &

f

)

const

Definition at line 546 of file SkSLFunctionDeclaration.cpp.

                                                                    {
    if (this->name() != f.name()) {
        return false;
    }
    SkSpan<Variable* const> parameters = this->parameters();
    SkSpan<Variable* const> otherParameters = f.parameters();
    if (parameters.size() != otherParameters.size()) {
        return false;
    }
    for (size_t i = 0; i < parameters.size(); i++) {
        if (!parameters[i]->type().matches(otherParameters[i]->type())) {
            return false;
        }
    }
    return true;
}

modifierFlags()

ModifierFlags SkSL::FunctionDeclaration::modifierFlags ( ) const

inline

Definition at line 56 of file SkSLFunctionDeclaration.h.

                                        {
        return fModifierFlags;
    }

mutableNextOverload()

FunctionDeclaration * SkSL::FunctionDeclaration::mutableNextOverload ( ) const

inline

Definition at line 106 of file SkSLFunctionDeclaration.h.

                                                     {
        return fNextOverload;
    }

nextOverload()

const FunctionDeclaration * SkSL::FunctionDeclaration::nextOverload ( ) const

inline

Definition at line 102 of file SkSLFunctionDeclaration.h.

                                                    {
        return fNextOverload;
    }

parameters()

SkSpan< Variable *const > SkSL::FunctionDeclaration::parameters ( ) const

inline

Definition at line 78 of file SkSLFunctionDeclaration.h.

                                               {
        return fParameters;
    }

returnType()

const Type & SkSL::FunctionDeclaration::returnType ( ) const

inline

Definition at line 82 of file SkSLFunctionDeclaration.h.

                                   {
        return *fReturnType;
    }

setDefinition()

void SkSL::FunctionDeclaration::setDefinition ( const FunctionDefinition *  definition )

inline

Definition at line 68 of file SkSLFunctionDeclaration.h.

                                                             {
        fDefinition = definition;
        fIntrinsicKind = kNotIntrinsic;
    }

setModifierFlags()

void SkSL::FunctionDeclaration::setModifierFlags ( ModifierFlags  m )

inline

Definition at line 60 of file SkSLFunctionDeclaration.h.

                                           {
        fModifierFlags = m;
    }

setNextOverload()

void SkSL::FunctionDeclaration::setNextOverload ( FunctionDeclaration *  overload )

inline

Definition at line 73 of file SkSLFunctionDeclaration.h.

                                                        {
        SkASSERT(!overload || overload->name() == this->name());
        fNextOverload = overload;
    }

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::FunctionDeclaration::kIRNodeKind = Kind::kFunctionDeclaration

inlinestaticconstexpr

Definition at line 38 of file SkSLFunctionDeclaration.h.

---

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

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