SkSL::Variable Class Reference

#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.

{}

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.

{ 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.

{ 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.

{ SkUNREACHABLE; }

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