#include <SkSLVariable.h>

Inheritance diagram for SkSL::Variable:

Classes
struct	ScratchVariable

Public Types
using	Storage = VariableStorage

Public Types inherited from SkSL::Symbol
using	Kind = SymbolKind

Public Member Functions
	Variable (Position pos, Position modifiersPosition, ModifierFlags modifierFlags, std::string_view name, const Type *type, bool builtin, Storage storage)

	~Variable () override

ModifierFlags	modifierFlags () const

virtual const Layout &	layout () const

Position	modifiersPosition () const

bool	isBuiltin () const

Storage	storage () const

const Expression *	initialValue () const

VarDeclaration *	varDeclaration () const

void	setVarDeclaration (VarDeclaration *declaration)

GlobalVarDeclaration *	globalVarDeclaration () const

void	setGlobalVarDeclaration (GlobalVarDeclaration *global)

void	detachDeadVarDeclaration ()

virtual InterfaceBlock *	interfaceBlock () const

virtual void	setInterfaceBlock (InterfaceBlock *)

virtual void	detachDeadInterfaceBlock ()

virtual std::string_view	mangledName () const

std::string	description () const override

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 ()

virtual std::string	description () const =0

	IRNode (const IRNode &)=delete

IRNode &	operator= (const IRNode &)=delete

Position	position () const

void	setPosition (Position p)

template<typename T >
bool	is () const

template<typename T >
const T &	as () const

template<typename T >
T &	as ()

Static Public Member Functions
static std::unique_ptr< Variable >	Convert (const Context &context, Position pos, Position modifiersPos, const Layout &layout, ModifierFlags flags, const Type *type, Position namePos, std::string_view name, Storage storage)

static std::unique_ptr< Variable >	Make (Position pos, Position modifiersPosition, const Layout &layout, ModifierFlags flags, const Type *type, std::string_view name, std::string mangledName, bool builtin, Storage storage)

static ScratchVariable	MakeScratchVariable (const Context &context, Mangler &mangler, std::string_view baseName, const Type type, SymbolTable symbolTable, std::unique_ptr< Expression > initialValue)

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::kVariable

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

Represents a variable, whether local, global, or a function parameter. This represents the variable itself (the storage location), which is shared between all VariableReferences which read or write that storage location.

Definition at line 48 of file SkSLVariable.h.

Member Typedef Documentation

◆ Storage

using SkSL::Variable::Storage = VariableStorage

Definition at line 50 of file SkSLVariable.h.

Constructor & Destructor Documentation

◆ Variable()

SkSL::Variable::Variable	(	Position	pos,
		Position	modifiersPosition,
		ModifierFlags	modifierFlags,
		std::string_view	name,
		const Type *	type,
		bool	builtin,
		Storage	storage
	)

inline

Definition at line 54 of file SkSLVariable.h.

            : INHERITED(pos, kIRNodeKind, name, type)
            , fModifierFlags(modifierFlags)
            , fModifiersPosition(modifiersPosition)
            , fStorage(storage)
            , fBuiltin(builtin) {}

◆ ~Variable()

SkSL::Variable::~Variable ( )

override

Definition at line 31 of file SkSLVariable.cpp.

                    {
    // Unhook this Variable from its associated VarDeclaration, since we're being deleted.
    if (VarDeclaration* declaration = this->varDeclaration()) {
        declaration->detachDeadVariable();
    }
}

Member Function Documentation

◆ Convert()

std::unique_ptr< Variable > SkSL::Variable::Convert	(	const Context &	context,
		Position	pos,
		Position	modifiersPos,
		const Layout &	layout,
		ModifierFlags	flags,
		const Type *	type,
		Position	namePos,
		std::string_view	name,
		Storage	storage
	)

static

Definition at line 92 of file SkSLVariable.cpp.

                                                             {
    if (layout.fLocation == 0 &&
        layout.fIndex == 0 &&
        (flags & ModifierFlag::kOut) &&
        ProgramConfig::IsFragment(context.fConfig->fKind) &&
        name != Compiler::FRAGCOLOR_NAME) {
        context.fErrors->error(modifiersPos,
                               "out location=0, index=0 is reserved for sk_FragColor");
    }
    if (type->isUnsizedArray() && storage != Variable::Storage::kInterfaceBlock) {
        context.fErrors->error(pos, "unsized arrays are not permitted here");
    }
    if (ProgramConfig::IsCompute(context.fConfig->fKind) && layout.fBuiltin == -1) {
        if (storage == Variable::Storage::kGlobal) {
            if (flags & ModifierFlag::kIn) {
                context.fErrors->error(pos, "pipeline inputs not permitted in compute shaders");
            } else if (flags & ModifierFlag::kOut) {
                context.fErrors->error(pos, "pipeline outputs not permitted in compute shaders");
            }
        }
    }
    if (storage == Variable::Storage::kParameter) {
        // The `in` modifier on function parameters is implicit, so we can replace `in float x` with
        // `float x`. This prevents any ambiguity when matching a function by its param types.
        if ((flags & (ModifierFlag::kOut | ModifierFlag::kIn)) == ModifierFlag::kIn) {
            flags &= ~(ModifierFlag::kOut | ModifierFlag::kIn);
        }
    }
 
    // Invent a mangled name for the variable, if it needs one.
    std::string mangledName;
    if (skstd::starts_with(name, '$')) {
        // The $ prefix will fail to compile in GLSL, so replace it with `sk_Priv`.
        mangledName = "sk_Priv" + std::string(name.substr(1));
    } else if (FindIntrinsicKind(name) != kNotIntrinsic) {
        // Having a variable name overlap an intrinsic name will prevent us from calling the
        // intrinsic, but it's not illegal for user names to shadow a global symbol.
        // Mangle the name to avoid a possible collision.
        mangledName = Mangler{}.uniqueName(name, context.fSymbolTable);
    }
 
    return Make(pos, modifiersPos, layout, flags, type, name, std::move(mangledName),
                context.fConfig->fIsBuiltinCode, storage);
}

◆ description()

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

inlineoverridevirtual

Implements SkSL::IRNode.

Definition at line 134 of file SkSLVariable.h.

                                           {
        return this->layout().paddedDescription() + this->modifierFlags().paddedDescription() +
               this->type().displayName() + " " + std::string(this->name());
    }

◆ detachDeadInterfaceBlock()

virtual void SkSL::Variable::detachDeadInterfaceBlock ( )

inlinevirtual

Reimplemented in SkSL::ExtendedVariable.

Definition at line 129 of file SkSLVariable.h.

129{}

◆ detachDeadVarDeclaration()

void SkSL::Variable::detachDeadVarDeclaration ( )

inline

Definition at line 117 of file SkSLVariable.h.

                                    {
        // The VarDeclaration is being deleted, so our reference to it has become stale.
        fDeclaringElement = nullptr;
    }

◆ globalVarDeclaration()

GlobalVarDeclaration * SkSL::Variable::globalVarDeclaration ( ) const

Definition at line 61 of file SkSLVariable.cpp.

                                                           {
    if (!fDeclaringElement) {
        return nullptr;
    }
    SkASSERT(fDeclaringElement->is<VarDeclaration>() ||
             fDeclaringElement->is<GlobalVarDeclaration>());
    return fDeclaringElement->is<GlobalVarDeclaration>()
               ? &fDeclaringElement->as<GlobalVarDeclaration>()
               : nullptr;
}

◆ initialValue()

const Expression * SkSL::Variable::initialValue ( ) const

Definition at line 45 of file SkSLVariable.cpp.

                                               {
    VarDeclaration* declaration = this->varDeclaration();
    return declaration ? declaration->value().get() : nullptr;
}

◆ interfaceBlock()

virtual InterfaceBlock * SkSL::Variable::interfaceBlock ( ) const

inlinevirtual

Reimplemented in SkSL::ExtendedVariable.

Definition at line 125 of file SkSLVariable.h.

125{ return nullptr; }

◆ isBuiltin()

bool SkSL::Variable::isBuiltin ( ) const

inline

Definition at line 99 of file SkSLVariable.h.

                           {
        return fBuiltin;
    }

◆ layout()

const Layout & SkSL::Variable::layout ( ) const

virtual

Reimplemented in SkSL::ExtendedVariable.

Definition at line 84 of file SkSLVariable.cpp.

                                     {
    return kDefaultLayout;
}

◆ Make()

std::unique_ptr< Variable > SkSL::Variable::Make	(	Position	pos,
		Position	modifiersPosition,
		const Layout &	layout,
		ModifierFlags	flags,
		const Type *	type,
		std::string_view	name,
		std::string	mangledName,
		bool	builtin,
		Variable::Storage	storage
	)

static

Definition at line 145 of file SkSLVariable.cpp.

                                                                  {
    // the `in` modifier on function parameters is implicit and should have been removed
    SkASSERT(!(storage == Variable::Storage::kParameter &&
               (flags & (ModifierFlag::kOut | ModifierFlag::kIn)) == ModifierFlag::kIn));
 
    if (type->componentType().isInterfaceBlock() || !mangledName.empty() ||
        layout != kDefaultLayout) {
        return std::make_unique<ExtendedVariable>(pos,
                                                  modifiersPosition,
                                                  layout,
                                                  flags,
                                                  name,
                                                  type,
                                                  builtin,
                                                  storage,
                                                  std::move(mangledName));
    } else {
        return std::make_unique<Variable>(pos,
                                          modifiersPosition,
                                          flags,
                                          name,
                                          type,
                                          builtin,
                                          storage);
    }
}

◆ MakeScratchVariable()

Variable::ScratchVariable SkSL::Variable::MakeScratchVariable	(	const Context &	context,
		Mangler &	mangler,
		std::string_view	baseName,
		const Type *	type,
		SymbolTable *	symbolTable,
		std::unique_ptr< Expression >	initialValue
	)

static

Definition at line 180 of file SkSLVariable.cpp.

                                                                                                {
    // $floatLiteral or $intLiteral aren't real types that we can use for scratch variables, so
    // replace them if they ever appear here. If this happens, we likely forgot to coerce a type
    // somewhere during compilation.
    if (type->isLiteral()) {
        SkDEBUGFAIL("found a $literal type in MakeScratchVariable");
        type = &type->scalarTypeForLiteral();
    }
 
    // Provide our new variable with a unique name, and add it to our symbol table.
    const std::string* name =
            symbolTable->takeOwnershipOfString(mangler.uniqueName(baseName, symbolTable));
 
    // Create our new variable and add it to the symbol table.
    ScratchVariable result;
    auto var = std::make_unique<Variable>(initialValue ? initialValue->fPosition : Position(),
                                          /*modifiersPosition=*/Position(),
                                          ModifierFlag::kNone,
                                          name->c_str(),
                                          type,
                                          symbolTable->isBuiltin(),
                                          Variable::Storage::kLocal);
 
    // If we are creating an array type, reduce it to base type plus array-size.
    int arraySize = 0;
    if (type->isArray()) {
        arraySize = type->columns();
        type = &type->componentType();
    }
    // Create our variable declaration.
    result.fVarDecl = VarDeclaration::Make(context, var.get(), type, arraySize,
                                           std::move(initialValue));
    result.fVarSymbol = symbolTable->add(context, std::move(var));
    return result;
}

◆ mangledName()

virtual std::string_view SkSL::Variable::mangledName ( ) const

inlinevirtual

Reimplemented in SkSL::ExtendedVariable.

Definition at line 132 of file SkSLVariable.h.

132{ return this->name(); }

◆ modifierFlags()

ModifierFlags SkSL::Variable::modifierFlags ( ) const

inline

Definition at line 89 of file SkSLVariable.h.

                                        {
        return fModifierFlags;
    }

◆ modifiersPosition()

Position SkSL::Variable::modifiersPosition ( ) const

inline

Definition at line 95 of file SkSLVariable.h.

                                       {
        return fModifiersPosition;
    }

◆ setGlobalVarDeclaration()

void SkSL::Variable::setGlobalVarDeclaration ( GlobalVarDeclaration * global )

Definition at line 79 of file SkSLVariable.cpp.

                                                                   {
    SkASSERT(!fDeclaringElement || this == global->varDeclaration().var());
    fDeclaringElement = global;
}

◆ setInterfaceBlock()

virtual void SkSL::Variable::setInterfaceBlock ( InterfaceBlock * )

inlinevirtual

Reimplemented in SkSL::ExtendedVariable.

Definition at line 127 of file SkSLVariable.h.

127{ SkUNREACHABLE; }

SkUNREACHABLE

#define SkUNREACHABLE

Definition: SkAssert.h:135

◆ setVarDeclaration()

void SkSL::Variable::setVarDeclaration ( VarDeclaration * declaration )

Definition at line 72 of file SkSLVariable.cpp.

                                                            {
    SkASSERT(!fDeclaringElement || this == declaration->var());
    if (!fDeclaringElement) {
        fDeclaringElement = declaration;
    }
}

◆ storage()

Storage SkSL::Variable::storage ( ) const

inline

Definition at line 103 of file SkSLVariable.h.

                            {
        return fStorage;
    }

◆ varDeclaration()

VarDeclaration * SkSL::Variable::varDeclaration ( ) const

Definition at line 50 of file SkSLVariable.cpp.

                                               {
    if (!fDeclaringElement) {
        return nullptr;
    }
    SkASSERT(fDeclaringElement->is<VarDeclaration>() ||
             fDeclaringElement->is<GlobalVarDeclaration>());
    return fDeclaringElement->is<GlobalVarDeclaration>()
               ? &fDeclaringElement->as<GlobalVarDeclaration>().varDeclaration()
               : &fDeclaringElement->as<VarDeclaration>();
}

Member Data Documentation

◆ kIRNodeKind

constexpr Kind SkSL::Variable::kIRNodeKind = Kind::kVariable

inlinestaticconstexpr

Definition at line 52 of file SkSLVariable.h.

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

third_party/skia/src/sksl/ir/SkSLVariable.h
third_party/skia/src/sksl/ir/SkSLVariable.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Storage

Constructor & Destructor Documentation

◆ Variable()

◆ ~Variable()

Member Function Documentation

◆ Convert()

◆ description()

◆ detachDeadInterfaceBlock()

◆ detachDeadVarDeclaration()

◆ globalVarDeclaration()

◆ initialValue()

◆ interfaceBlock()

◆ isBuiltin()

◆ layout()

◆ Make()

◆ MakeScratchVariable()

◆ mangledName()

◆ modifierFlags()

◆ modifiersPosition()

◆ setGlobalVarDeclaration()

◆ setInterfaceBlock()

◆ setVarDeclaration()

◆ storage()

◆ varDeclaration()

Member Data Documentation

◆ kIRNodeKind