Namespaces
namespace	Analysis

namespace	Constructor

namespace	Intrinsics

namespace	PipelineStage

namespace	RP

namespace	String

namespace	SwizzleComponent

namespace	Transform

Classes
class	AliasType

class	AnyConstructor

class	ArrayType

class	AtomicType

class	AutoAttachPoolToThread

class	AutoOutputStream

class	AutoProgramConfig

class	BinaryExpression

class	Block

class	BreakStatement

class	BuiltinTypes

class	ChildCall

class	CodeGenerator

struct	CoercionCost

struct	CompactEntry

class	Compiler

class	ConstantFolder

class	ConstructorArray

class	ConstructorArrayCast

class	ConstructorCompound

class	ConstructorCompoundCast

class	ConstructorDiagonalMatrix

class	ConstructorMatrixResize

class	ConstructorScalarCast

class	ConstructorSplat

class	ConstructorStruct

class	Context

class	ContinueStatement

class	CountReturnsWithLimit

class	DebugTrace

class	DebugTracePriv

class	DiscardStatement

class	DoStatement

class	EmptyExpression

class	ErrorReporter

class	Expression

class	ExpressionArray

class	ExpressionStatement

class	ExtendedVariable

class	Extension

struct	Field

class	FieldAccess

class	FieldSymbol

class	FileOutputStream

struct	ForLoopPositions

class	ForStatement

struct	FullEntry

class	FunctionCall

struct	FunctionDebugInfo

class	FunctionDeclaration

class	FunctionDefinition

class	FunctionPrototype

class	FunctionReference

class	GenericType

class	GlobalVarDeclaration

class	GLSLCodeGenerator

class	IfStatement

class	IndexExpression

struct	InlineCandidate

class	InlineCandidateAnalyzer

struct	InlineCandidateList

class	Inliner

class	InterfaceBlock

struct	IRHelpers

class	IRNode

struct	Layout

class	Lexer

class	Literal

class	LiteralType

struct	LoopUnrollInfo

class	Mangler

class	MatrixType

class	MemoryLayout

class	MemoryPool

class	MetalCodeGenerator

class	MethodReference

class	ModifierFlags

struct	Modifiers

class	ModifiersDeclaration

struct	Module

class	ModuleLoader

class	MultiArgumentConstructor

class	NoOpErrorReporter

class	Nop

class	Operator

class	OutputStream

class	Parser

class	PointerLValue

class	Poison

class	Pool

class	Poolable

class	Position

class	PostfixExpression

class	PrefixExpression

struct	Program

struct	ProgramConfig

class	ProgramElement

struct	ProgramInterface

struct	ProgramSettings

class	ProgramUsage

class	ProgramVisitor

struct	ProgramVisitorTypes

class	ProgramWriter

struct	ProgramWriterTypes

class	ReturnStatement

class	SamplerType

class	SampleUsage

class	ScalarType

class	Setting

struct	ShaderCaps

class	ShaderCapsFactory

class	SingleArgumentConstructor

class	SkSLDebugTracePlayer

struct	SlotDebugInfo

class	SPIRVCodeGenerator

class	Statement

class	StringStream

class	StructDefinition

class	StructType

class	SwitchCase

class	SwitchStatement

class	Swizzle

class	SwizzleLValue

class	Symbol

class	SymbolTable

class	TernaryExpression

class	TestingOnly_AbortErrorReporter

class	TextureType

struct	Token

class	TProgramVisitor

class	TraceHook

struct	TraceInfo

class	Tracer

class	Type

class	TypeReference

struct	UniformInfo

class	VarDeclaration

class	Variable

class	VariableReference

class	VectorType

class	WGSLCodeGenerator

Typedefs
using	IntrinsicArguments = std::array< const Expression *, 3 >

using	CoalesceFn = double(*)(double, double, double)

using	FinalizeFn = double(*)(double)

using	CompareFn = bool(*)(double, double)

using	EvaluateFn = double(*)(double, double, double)

using	LayoutFlags = SkEnumBitMask< SkSL::LayoutFlag >

using	ComponentArray = skia_private::FixedArray< 4, int8_t >

using	StatementArray = skia_private::STArray< 2, std::unique_ptr< Statement > >

using	IntrinsicMap = skia_private::THashMap< std::string_view, IntrinsicKind >

using	State = uint16_t

using	IndexEntry = int16_t

using	BuiltinTypePtr = const std::unique_ptr< Type > BuiltinTypes::*

Enumerations
enum class	Version { k100 , k300 }

enum class	FieldAccessOwnerKind : int8_t { kDefault , kAnonymousInterfaceBlock }

enum class	ProgramElementKind { kExtension = 0 , kFunction , kFunctionPrototype , kGlobalVar , kInterfaceBlock , kModifiers , kStructDefinition , kFirst = kExtension , kLast = kStructDefinition }

enum class	SymbolKind { kExternal = (int) ProgramElementKind::kLast + 1 , kField , kFunctionDeclaration , kType , kVariable , kFirst = kExternal , kLast = kVariable }

enum class	StatementKind { kBlock = (int) SymbolKind::kLast + 1 , kBreak , kContinue , kDiscard , kDo , kExpression , kFor , kIf , kNop , kReturn , kSwitch , kSwitchCase , kVarDeclaration , kFirst = kBlock , kLast = kVarDeclaration }

enum class	ExpressionKind { kBinary = (int) StatementKind::kLast + 1 , kChildCall , kConstructorArray , kConstructorArrayCast , kConstructorCompound , kConstructorCompoundCast , kConstructorDiagonalMatrix , kConstructorMatrixResize , kConstructorScalarCast , kConstructorSplat , kConstructorStruct , kEmpty , kFieldAccess , kFunctionReference , kFunctionCall , kIndex , kLiteral , kMethodReference , kPoison , kPostfix , kPrefix , kSetting , kSwizzle , kTernary , kTypeReference , kVariableReference , kFirst = kBinary , kLast = kVariableReference }

enum class	LayoutFlag : int { kNone = 0 , kAll = ~0 , kOriginUpperLeft = 1 << 0 , kPushConstant = 1 << 1 , kBlendSupportAllEquations = 1 << 2 , kColor = 1 << 3 , kLocation = 1 << 4 , kOffset = 1 << 5 , kBinding = 1 << 6 , kTexture = 1 << 7 , kSampler = 1 << 8 , kIndex = 1 << 9 , kSet = 1 << 10 , kBuiltin = 1 << 11 , kInputAttachmentIndex = 1 << 12 , kVulkan = 1 << 13 , kMetal = 1 << 14 , kWebGPU = 1 << 15 , kDirect3D = 1 << 16 , kAllBackends = kVulkan \| kMetal \| kWebGPU \| kDirect3D , kRGBA8 = 1 << 17 , kRGBA32F = 1 << 18 , kR32F = 1 << 19 , kAllPixelFormats = kRGBA8 \| kRGBA32F \| kR32F , kLocalSizeX = 1 << 20 , kLocalSizeY = 1 << 21 , kLocalSizeZ = 1 << 22 }

enum class	ModifierFlag : int { kNone = 0 , kFlat = 1 << 0 , kNoPerspective = 1 << 1 , kConst = 1 << 2 , kUniform = 1 << 3 , kIn = 1 << 4 , kOut = 1 << 5 , kHighp = 1 << 6 , kMediump = 1 << 7 , kLowp = 1 << 8 , kReadOnly = 1 << 9 , kWriteOnly = 1 << 10 , kBuffer = 1 << 11 , kPixelLocal = 1 << 12 , kWorkgroup = 1 << 13 , kExport = 1 << 14 , kES3 = 1 << 15 , kPure = 1 << 16 , kInline = 1 << 17 , kNoInline = 1 << 18 }

enum class	VariableStorage : int8_t { kGlobal , kInterfaceBlock , kLocal , kParameter }

enum class	VariableRefKind : int8_t { kRead , kWrite , kReadWrite , kPointer }

enum class	GLSLGeneration { k110 , k100es = k110 , k130 , k140 , k150 , k330 , k300es = k330 , k400 , k420 , k310es , k320es }

enum	IntrinsicKind : int8_t { kNotIntrinsic = -1 , SKSL_INTRINSIC_LIST }

enum class	ModuleName { sksl_shared , sksl_compute , sksl_frag , sksl_gpu , sksl_public , sksl_rt_shader , sksl_vert , sksl_graphite_frag , sksl_graphite_frag_es2 , sksl_graphite_vert , sksl_graphite_vert_es2 }

enum class	OperatorKind : uint8_t { PLUS , MINUS , STAR , SLASH , PERCENT , SHL , SHR , LOGICALNOT , LOGICALAND , LOGICALOR , LOGICALXOR , BITWISENOT , BITWISEAND , BITWISEOR , BITWISEXOR , EQ , EQEQ , NEQ , LT , GT , LTEQ , GTEQ , PLUSEQ , MINUSEQ , STAREQ , SLASHEQ , PERCENTEQ , SHLEQ , SHREQ , BITWISEANDEQ , BITWISEOREQ , BITWISEXOREQ , PLUSPLUS , MINUSMINUS , COMMA }

enum class	OperatorPrecedence : uint8_t { kParentheses = 1 , kPostfix = 2 , kPrefix = 3 , kMultiplicative = 4 , kAdditive = 5 , kShift = 6 , kRelational = 7 , kEquality = 8 , kBitwiseAnd = 9 , kBitwiseXor = 10 , kBitwiseOr = 11 , kLogicalAnd = 12 , kLogicalXor = 13 , kLogicalOr = 14 , kTernary = 15 , kAssignment = 16 , kSequence = 17 , kExpression = kSequence , kStatement = 18 }

enum class	ProgramKind : int8_t { kFragment , kVertex , kCompute , kGraphiteFragment , kGraphiteVertex , kGraphiteFragmentES2 , kGraphiteVertexES2 , kRuntimeColorFilter , kRuntimeShader , kRuntimeBlender , kPrivateRuntimeColorFilter , kPrivateRuntimeShader , kPrivateRuntimeBlender , kMeshVertex , kMeshFragment }

Functions
static int	calculate_count (double start, double end, double delta, bool forwards, bool inclusive)

static int	count_returns_at_end_of_control_flow (const FunctionDefinition &funcDef)

static bool	contains_matching_data (const ProgramUsage &a, const ProgramUsage &b)

static bool	is_abs (Expression &expr)

bool	is_sk_position (const Expression &expr)

bool	is_sk_samplemask (const Expression &expr)

bool	ToGLSL (Program &program, const ShaderCaps *caps, OutputStream &out)

bool	ToGLSL (Program &program, const ShaderCaps caps, std::string out)

bool	ToHLSL (Program &program, const ShaderCaps *caps, OutputStream &out)

bool	ToHLSL (Program &program, const ShaderCaps caps, std::string out)

static const char *	operator_name (Operator op)

static bool	pass_by_reference (const Type &type, ModifierFlags flags)

static bool	needs_address_space (const Type &type, ModifierFlags modifiers)

static bool	is_buffer (const InterfaceBlock &block)

static bool	is_readonly (const InterfaceBlock &block)

static bool	is_compute_builtin (const Variable &var)

static bool	is_input (const Variable &var)

static bool	is_output (const Variable &var)

static bool	is_uniforms (const Variable &var)

static bool	is_threadgroup (const Variable &var)

static bool	is_in_globals (const Variable &var)

static bool	is_block_ending_with_return (const Statement *stmt)

bool	ToMetal (Program &program, const ShaderCaps *caps, OutputStream &out)

bool	ToMetal (Program &program, const ShaderCaps caps, std::string out)

std::unique_ptr< RP::Program >	MakeRasterPipelineProgram (const SkSL::Program &program, const FunctionDefinition &function, DebugTracePriv *debugTrace, bool writeTraceOps)

static bool	is_float (const Type &type)

static bool	is_signed (const Type &type)

static bool	is_unsigned (const Type &type)

static bool	is_bool (const Type &type)

template<typename T >
static T	pick_by_type (const Type &type, T ifFloat, T ifInt, T ifUInt, T ifBool)

static bool	is_out (ModifierFlags f)

static bool	is_in (ModifierFlags f)

static bool	is_control_flow_op (SpvOp_ op)

static bool	is_globally_reachable_op (SpvOp_ op)

static SpvImageFormat	layout_flags_to_image_format (LayoutFlags flags)

static SpvStorageClass_	get_storage_class_for_global_variable (const Variable &var, SpvStorageClass_ fallbackStorageClass)

static SpvStorageClass_	get_storage_class (const Expression &expr)

static bool	types_match (const Type &a, const Type &b)

static bool	is_vardecl_compile_time_constant (const VarDeclaration &varDecl)

static SymbolTable *	get_top_level_symbol_table (const FunctionDeclaration &anyFunc)

bool	ToSPIRV (Program &program, const ShaderCaps *caps, OutputStream &out)

bool	ToSPIRV (Program &program, const ShaderCaps caps, std::string out)

bool	SPIRVtoHLSL (const std::string &, std::string *)

static bool	is_nontrivial_expression (const Expression &expr)

static bool	binary_op_is_ambiguous_in_wgsl (Operator op)

static bool	all_arguments_constant (const ExpressionArray &arguments)

bool	ToWGSL (Program &program, const ShaderCaps *caps, OutputStream &out)

bool	ToWGSL (Program &program, const ShaderCaps caps, std::string out)

static bool	call_signature_is_valid (const Context &context, const Variable &child, const ExpressionArray &arguments)

static std::unique_ptr< Expression >	convert_compound_constructor (const Context &context, Position pos, const Type &type, ExpressionArray args)

static std::unique_ptr< Expression >	cast_constant_array (const Context &context, Position pos, const Type &destType, std::unique_ptr< Expression > constCtor)

static bool	is_safe_to_eliminate (const Type &type, const Expression &arg)

static const Expression *	make_splat_from_arguments (const Type &type, const ExpressionArray &args)

static std::unique_ptr< Expression >	cast_constant_composite (const Context &context, Position pos, const Type &destType, std::unique_ptr< Expression > constCtor)

static bool	arguments_match_field_types (const ExpressionArray &args, const Type &type)

static std::unique_ptr< Expression >	extract_field (Position pos, const ConstructorStruct &ctor, int fieldIndex)

static bool	is_vardecl_block_initializer (const Statement *stmt)

static bool	is_simple_initializer (const Statement *stmt)

static void	hoist_vardecl_symbols_into_outer_scope (const Context &context, const Block &initBlock, SymbolTable innerSymbols, SymbolTable hoistedSymbols)

static bool	has_compile_time_constant_arguments (const ExpressionArray &arguments)

template<typename T >
static void	type_check_expression (const Expression &expr)

template<>
void	type_check_expression< float > (const Expression &expr)

template<>
void	type_check_expression< SKSL_INT > (const Expression &expr)

template<>
void	type_check_expression< bool > (const Expression &expr)

static std::unique_ptr< Expression >	coalesce_n_way_vector (const Expression arg0, const Expression arg1, double startingState, const Type &returnType, CoalesceFn coalesce, FinalizeFn finalize)

template<typename T >
static std::unique_ptr< Expression >	coalesce_vector (const IntrinsicArguments &arguments, double startingState, const Type &returnType, CoalesceFn coalesce, FinalizeFn finalize)

template<typename T >
static std::unique_ptr< Expression >	coalesce_pairwise_vectors (const IntrinsicArguments &arguments, double startingState, const Type &returnType, CoalesceFn coalesce, FinalizeFn finalize)

static std::unique_ptr< Expression >	optimize_comparison (const Context &context, const IntrinsicArguments &arguments, CompareFn compare)

static std::unique_ptr< Expression >	evaluate_n_way_intrinsic (const Context &context, const Expression arg0, const Expression arg1, const Expression *arg2, const Type &returnType, EvaluateFn eval)

template<typename T >
static std::unique_ptr< Expression >	evaluate_intrinsic (const Context &context, const IntrinsicArguments &arguments, const Type &returnType, EvaluateFn eval)

static std::unique_ptr< Expression >	evaluate_intrinsic_numeric (const Context &context, const IntrinsicArguments &arguments, const Type &returnType, EvaluateFn eval)

static std::unique_ptr< Expression >	evaluate_pairwise_intrinsic (const Context &context, const IntrinsicArguments &arguments, const Type &returnType, EvaluateFn eval)

static std::unique_ptr< Expression >	evaluate_3_way_intrinsic (const Context &context, const IntrinsicArguments &arguments, const Type &returnType, EvaluateFn eval)

template<typename T1 , typename T2 >
static double	pun_value (double val)

static void	extract_matrix (const Expression *expr, float mat[16])

static std::unique_ptr< Expression >	optimize_intrinsic_call (const Context &context, Position pos, IntrinsicKind intrinsic, const ExpressionArray &argArray, const Type &returnType)

static bool	argument_and_parameter_flags_match (const Expression &argument, const Variable &parameter)

static CoercionCost	call_cost (const Context &context, const FunctionDeclaration &function, const ExpressionArray &arguments)

static std::string	build_argument_type_list (SkSpan< const std::unique_ptr< Expression > > arguments)

static bool	check_modifiers (const Context &context, Position pos, ModifierFlags modifierFlags)

static bool	check_return_type (const Context &context, Position pos, const Type &returnType)

static bool	check_parameters (const Context &context, TArray< std::unique_ptr< Variable > > &parameters, ModifierFlags modifierFlags, IntrinsicKind intrinsicKind)

static bool	type_is_valid_for_color (const Type &type)

static bool	type_is_valid_for_coords (const Type &type)

static bool	check_main_signature (const Context &context, Position pos, const Type &returnType, TArray< std::unique_ptr< Variable > > &parameters)

static int	find_generic_index (const Type &concreteType, const Type &genericType, bool allowNarrowing)

static bool	type_generically_matches (const Type &concreteType, const Type &maybeGenericType)

static bool	parameters_match (SkSpan< const std::unique_ptr< Variable > > params, SkSpan< Variable *const > otherParams)

static bool	find_existing_declaration (const Context &context, Position pos, ModifierFlags modifierFlags, IntrinsicKind intrinsicKind, std::string_view name, TArray< std::unique_ptr< Variable > > &parameters, Position returnTypePos, const Type returnType, FunctionDeclaration *outExistingDecl)

static void	append_rtadjust_fixup_to_vertex_main (const Context &context, const FunctionDeclaration &decl, Block &body)

static std::unique_ptr< Statement >	replace_empty_with_nop (std::unique_ptr< Statement > stmt, bool isEmpty)

static bool	index_out_of_range (const Context &context, Position pos, SKSL_INT index, const Expression &base)

static std::optional< int >	find_rt_adjust_index (SkSpan< const Field > fields)

static ExpressionArray	negate_operands (const Context &context, Position pos, const ExpressionArray &operands)

static double	negate_value (double value)

static double	bitwise_not_value (double value)

static std::unique_ptr< Expression >	apply_to_elements (const Context &context, Position pos, const Expression &expr, double(*fn)(double))

static std::unique_ptr< Expression >	simplify_negation (const Context &context, Position pos, const Expression &originalExpr)

static std::unique_ptr< Expression >	negate_operand (const Context &context, Position pos, std::unique_ptr< Expression > value)

static std::unique_ptr< Expression >	logical_not_operand (const Context &context, Position pos, std::unique_ptr< Expression > operand)

static std::unique_ptr< Expression >	bitwise_not_operand (const Context &context, Position pos, std::unique_ptr< Expression > operand)

static TArray< const SwitchCase * >	find_duplicate_case_values (const StatementArray &cases)

static void	remove_break_statements (std::unique_ptr< Statement > &stmt)

static bool	block_for_case (Statement caseBlock, SwitchCase caseToCapture)

static bool	validate_swizzle_domain (const ComponentArray &fields)

static char	mask_char (int8_t component)

static std::unique_ptr< Expression >	optimize_constructor_swizzle (const Context &context, Position pos, const ConstructorCompound &base, ComponentArray components)

static bool	is_vec_or_mat (const Type &type)

static std::unique_ptr< Expression >	eliminate_no_op_boolean (Position pos, const Expression &left, Operator op, const Expression &right)

static std::unique_ptr< Expression >	short_circuit_boolean (Position pos, const Expression &left, Operator op, const Expression &right)

static std::unique_ptr< Expression >	simplify_constant_equality (const Context &context, Position pos, const Expression &left, Operator op, const Expression &right)

static std::unique_ptr< Expression >	simplify_matrix_multiplication (const Context &context, Position pos, const Expression &left, const Expression &right, int leftColumns, int leftRows, int rightColumns, int rightRows)

static std::unique_ptr< Expression >	simplify_matrix_times_matrix (const Context &context, Position pos, const Expression &left, const Expression &right)

static std::unique_ptr< Expression >	simplify_vector_times_matrix (const Context &context, Position pos, const Expression &left, const Expression &right)

static std::unique_ptr< Expression >	simplify_matrix_times_vector (const Context &context, Position pos, const Expression &left, const Expression &right)

static std::unique_ptr< Expression >	simplify_componentwise (const Context &context, Position pos, const Expression &left, Operator op, const Expression &right)

static std::unique_ptr< Expression >	splat_scalar (const Context &context, const Expression &scalar, const Type &type)

static std::unique_ptr< Expression >	cast_expression (const Context &context, Position pos, const Expression &expr, const Type &type)

static std::unique_ptr< Expression >	zero_expression (const Context &context, Position pos, const Type &type)

static std::unique_ptr< Expression >	negate_expression (const Context &context, Position pos, const Expression &expr, const Type &type)

static bool	contains_constant_zero (const Expression &expr)

static bool	is_constant_diagonal (const Expression &expr, double value)

static bool	is_constant_value (const Expression &expr, double value)

static std::unique_ptr< Expression >	make_reciprocal_expression (const Context &context, const Expression &right)

static bool	error_on_divide_by_zero (const Context &context, Position pos, Operator op, const Expression &right)

static bool	is_scalar_op_matrix (const Expression &left, const Expression &right)

static bool	is_matrix_op_scalar (const Expression &left, const Expression &right)

static std::unique_ptr< Expression >	simplify_arithmetic (const Context &context, Position pos, const Expression &left, Operator op, const Expression &right, const Type &resultType)

static std::unique_ptr< Expression >	one_over_scalar (const Context &context, const Expression &right)

static std::unique_ptr< Expression >	simplify_matrix_division (const Context &context, Position pos, const Expression &left, Operator op, const Expression &right, const Type &resultType)

static std::unique_ptr< Expression >	fold_expression (Position pos, double result, const Type *resultType)

static std::unique_ptr< Expression >	fold_two_constants (const Context &context, Position pos, const Expression left, Operator op, const Expression right, const Type &resultType)

static bool	argument_needs_scratch_variable (const Expression arg, const Variable param, const ProgramUsage &usage)

static const FunctionDeclaration &	candidate_func (const InlineCandidate &candidate)

const IntrinsicMap &	GetIntrinsicMap ()

IntrinsicKind	FindIntrinsicKind (std::string_view functionName)

static State	get_transition (uint8_t transition, State state)

std::string	GetModuleData (ModuleName name, const char *filename)

static std::unique_ptr< Module >	compile_and_shrink (SkSL::Compiler compiler, ProgramKind kind, const char moduleName, std::string moduleSource, const Module *parent)

static ModifierFlags	parse_modifier_token (Token::Kind token)

static bool	is_whitespace (Token::Kind kind)

static Position	range_of_at_least_one_char (int start, int end)

static MemoryPool *	get_thread_local_memory_pool ()

static void	set_thread_local_memory_pool (MemoryPool *memPool)

bool	stod (std::string_view s, SKSL_FLOAT *value)

bool	stoi (std::string_view s, SKSL_INT *value)

void	write_stringstream (const StringStream &s, OutputStream &out)

bool	type_to_sksltype (const Context &context, const Type &type, SkSLType *outType)

static bool	dead_function_predicate (const ProgramElement element, ProgramUsage usage)

static bool	is_dead_variable (const ProgramElement &element, ProgramUsage *usage, bool onlyPrivateGlobals)

static bool	eliminate_dead_local_variables (const Context &context, SkSpan< std::unique_ptr< ProgramElement > > elements, ProgramUsage *usage)

static void	eliminate_empty_statements (SkSpan< std::unique_ptr< ProgramElement > > elements)

static void	eliminate_unnecessary_braces (SkSpan< std::unique_ptr< ProgramElement > > elements)

static void	eliminate_unreachable_code (SkSpan< std::unique_ptr< ProgramElement > > elements, ProgramUsage *usage)

static bool	contains_builtin_struct (const ProgramUsage &usage)

static void	get_struct_definitions_from_module (Program &program, const Module &module, std::vector< const ProgramElement * > *addedStructDefs)

static void	strip_export_flag (Context &context, const FunctionDeclaration funcDecl, SymbolTable symbols)

Variables
static constexpr int	kLoopTerminationLimit = 100000

static constexpr char	kDeterminant2 []

static constexpr char	kDeterminant3 []

static constexpr char	kDeterminant4 []

static constexpr char	kInverse2 []

static constexpr char	kInverse3 []

static constexpr char	kInverse4 []

static constexpr char	kInverse2x2 []

static constexpr char	kInverse3x3 []

static constexpr char	kInverse4x4 []

static const int32_t	SKSL_MAGIC = 0x001F0000

static constexpr char	kInverse2x2 []

static constexpr char	kInverse3x3 []

static constexpr char	kInverse4x4 []

static constexpr int	kMaxStructDepth = 8

static constexpr Layout	kDefaultLayout

static constexpr int	kDefaultInlineThreshold = 50

static constexpr int	kVariableSlotLimit = 100000

static constexpr uint8_t	kInvalidChar = 18

static constexpr uint8_t	kMappings [118]

static constexpr FullEntry	kFull []

static constexpr CompactEntry	kCompact []

static constexpr IndexEntry	kIndices []

static const uint8_t	kAccepts [427]

static constexpr BuiltinTypePtr	kRootTypes []

static constexpr BuiltinTypePtr	kPrivateTypes []

static constexpr int	kMaxParseDepth = 50

static thread_local MemoryPool *	sMemPool = nullptr

Typedef Documentation

◆ BuiltinTypePtr

using SkSL::BuiltinTypePtr = typedef const std::unique_ptr<Type> BuiltinTypes::*

Definition at line 20 of file SkSLModuleLoader.h.

◆ CoalesceFn

using SkSL::CoalesceFn = typedef double (*)(double, double, double)

Definition at line 81 of file SkSLFunctionCall.cpp.

◆ CompareFn

using SkSL::CompareFn = typedef bool (*)(double, double)

Definition at line 174 of file SkSLFunctionCall.cpp.

◆ ComponentArray

using SkSL::ComponentArray = typedef skia_private::FixedArray<4, int8_t>

Represents the components of a vector swizzle.

Definition at line 46 of file SkSLSwizzle.h.

◆ EvaluateFn

using SkSL::EvaluateFn = typedef double (*)(double, double, double)

Definition at line 204 of file SkSLFunctionCall.cpp.

◆ FinalizeFn

using SkSL::FinalizeFn = typedef double (*)(double)

Definition at line 82 of file SkSLFunctionCall.cpp.

◆ IndexEntry

using SkSL::IndexEntry = typedef int16_t

Definition at line 24 of file SkSLLexer.cpp.

◆ IntrinsicArguments

using SkSL::IntrinsicArguments = typedef std::array<const Expression*, 3>

Definition at line 51 of file SkSLFunctionCall.cpp.

◆ IntrinsicMap

using SkSL::IntrinsicMap = typedef skia_private::THashMap<std::string_view, IntrinsicKind>

Definition at line 135 of file SkSLIntrinsicList.h.

◆ LayoutFlags

using SkSL::LayoutFlags = typedef SkEnumBitMask<SkSL::LayoutFlag>

Definition at line 68 of file SkSLLayout.h.

◆ State

using SkSL::State = typedef uint16_t

Definition at line 14 of file SkSLLexer.cpp.

◆ StatementArray

using SkSL::StatementArray = typedef skia_private::STArray<2, std::unique_ptr<Statement> >

Definition at line 32 of file SkSLDefines.h.

Enumeration Type Documentation

◆ ExpressionKind

enum class SkSL::ExpressionKind

strong

Enumerator
kBinary
kChildCall
kConstructorArray
kConstructorArrayCast
kConstructorCompound
kConstructorCompoundCast
kConstructorDiagonalMatrix
kConstructorMatrixResize
kConstructorScalarCast
kConstructorSplat
kConstructorStruct
kEmpty
kFieldAccess
kFunctionReference
kFunctionCall
kIndex
kLiteral
kMethodReference
kPoison
kPostfix
kPrefix
kSetting
kSwizzle
kTernary
kTypeReference
kVariableReference
kFirst
kLast

Definition at line 62 of file SkSLIRNode.h.

                          {
    kBinary = (int) StatementKind::kLast + 1,
    kChildCall,
    kConstructorArray,
    kConstructorArrayCast,
    kConstructorCompound,
    kConstructorCompoundCast,
    kConstructorDiagonalMatrix,
    kConstructorMatrixResize,
    kConstructorScalarCast,
    kConstructorSplat,
    kConstructorStruct,
    kEmpty,
    kFieldAccess,
    kFunctionReference,
    kFunctionCall,
    kIndex,
    kLiteral,
    kMethodReference,
    kPoison,
    kPostfix,
    kPrefix,
    kSetting,
    kSwizzle,
    kTernary,
    kTypeReference,
    kVariableReference,
 
    kFirst = kBinary,
    kLast = kVariableReference
};

◆ FieldAccessOwnerKind

enum class SkSL::FieldAccessOwnerKind : int8_t

strong

Enumerator
kDefault
kAnonymousInterfaceBlock

Definition at line 29 of file SkSLFieldAccess.h.

                                : int8_t {
    kDefault,
    // this field access is to a field of an anonymous interface block (and thus, the field name
    // is actually in global scope, so only the field name needs to be written in GLSL)
    kAnonymousInterfaceBlock
};

◆ GLSLGeneration

enum class SkSL::GLSLGeneration

strong

Enumerator
k110	Desktop GLSL 1.10 and ES2 shading language (based on desktop GLSL 1.20)
k100es
k130	Desktop GLSL 1.30
k140	Desktop GLSL 1.40
k150	Desktop GLSL 1.50
k330	Desktop GLSL 3.30, and ES GLSL 3.00
k300es
k400	Desktop GLSL 4.00
k420	Desktop GLSL 4.20
k310es	ES GLSL 3.10 only TODO Make GLSLCap objects to make this more granular
k320es	ES GLSL 3.20

Definition at line 15 of file SkSLGLSL.h.

                          {
    /**
     * Desktop GLSL 1.10 and ES2 shading language (based on desktop GLSL 1.20)
     */
    k110,
    k100es = k110,
    /**
     * Desktop GLSL 1.30
     */
    k130,
    /**
     * Desktop GLSL 1.40
     */
    k140,
    /**
     * Desktop GLSL 1.50
     */
    k150,
    /**
     * Desktop GLSL 3.30, and ES GLSL 3.00
     */
    k330,
    k300es = k330,
    /**
     * Desktop GLSL 4.00
     */
    k400,
    /**
     * Desktop GLSL 4.20
     */
    k420,
    /**
     * ES GLSL 3.10 only TODO Make GLSLCap objects to make this more granular
     */
    k310es,
    /**
     * ES GLSL 3.20
     */
    k320es,
};

◆ IntrinsicKind

enum SkSL::IntrinsicKind : int8_t

Enumerator
kNotIntrinsic
SKSL_INTRINSIC_LIST

Definition at line 128 of file SkSLIntrinsicList.h.

                   : int8_t {
    kNotIntrinsic = -1,
    SKSL_INTRINSIC_LIST
};

◆ LayoutFlag

enum class SkSL::LayoutFlag : int

strong

Enumerator
kNone
kAll
kOriginUpperLeft
kPushConstant
kBlendSupportAllEquations
kColor
kLocation
kOffset
kBinding
kTexture
kSampler
kIndex
kSet
kBuiltin
kInputAttachmentIndex
kVulkan
kMetal
kWebGPU
kDirect3D
kAllBackends
kRGBA8
kRGBA32F
kR32F
kAllPixelFormats
kLocalSizeX
kLocalSizeY
kLocalSizeZ

Definition at line 20 of file SkSLLayout.h.

                      : int {
    kNone                       = 0,
    kAll                        = ~0,
 
    kOriginUpperLeft            = 1 <<  0,
    kPushConstant               = 1 <<  1,
    kBlendSupportAllEquations   = 1 <<  2,
    kColor                      = 1 <<  3,
 
    // These flags indicate if the qualifier appeared, regardless of the accompanying value.
    kLocation                   = 1 <<  4,
    kOffset                     = 1 <<  5,
    kBinding                    = 1 <<  6,
    kTexture                    = 1 <<  7,
    kSampler                    = 1 <<  8,
    kIndex                      = 1 <<  9,
    kSet                        = 1 << 10,
    kBuiltin                    = 1 << 11,
    kInputAttachmentIndex       = 1 << 12,
 
    // These flags indicate the backend type; only one at most can be set.
    kVulkan                     = 1 << 13,
    kMetal                      = 1 << 14,
    kWebGPU                     = 1 << 15,
    kDirect3D                   = 1 << 16,
 
    kAllBackends                = kVulkan | kMetal | kWebGPU | kDirect3D,
 
    // These flags indicate the pixel format; only one at most can be set.
    // (https://www.khronos.org/opengl/wiki/Layout_Qualifier_(GLSL)#Image_formats)
    kRGBA8                      = 1 << 17,
    kRGBA32F                    = 1 << 18,
    kR32F                       = 1 << 19,
 
    kAllPixelFormats            = kRGBA8 | kRGBA32F | kR32F,
 
    // The local invocation size of a compute program.
    kLocalSizeX                 = 1 << 20,
    kLocalSizeY                 = 1 << 21,
    kLocalSizeZ                 = 1 << 22,
};

◆ ModifierFlag

enum class SkSL::ModifierFlag : int

strong

Enumerator
kNone
kFlat
kNoPerspective
kConst
kUniform
kIn
kOut
kHighp
kMediump
kLowp
kReadOnly
kWriteOnly
kBuffer
kPixelLocal
kWorkgroup
kExport
kES3
kPure
kInline
kNoInline

Definition at line 21 of file SkSLModifierFlags.h.

                        : int {
    kNone           =       0,
    // Real GLSL modifiers
    kFlat           = 1 <<  0,
    kNoPerspective  = 1 <<  1,
    kConst          = 1 <<  2,
    kUniform        = 1 <<  3,
    kIn             = 1 <<  4,
    kOut            = 1 <<  5,
    kHighp          = 1 <<  6,
    kMediump        = 1 <<  7,
    kLowp           = 1 <<  8,
    kReadOnly       = 1 <<  9,
    kWriteOnly      = 1 << 10,
    kBuffer         = 1 << 11,
    kPixelLocal     = 1 << 12,
    // Corresponds to the GLSL 'shared' modifier. Only allowed in a compute program.
    kWorkgroup      = 1 << 13,
    // SkSL extensions, not present in GLSL
    kExport         = 1 << 14,
    kES3            = 1 << 15,
    kPure           = 1 << 16,
    kInline         = 1 << 17,
    kNoInline       = 1 << 18,
};

◆ ModuleName

enum class SkSL::ModuleName

strong

Enumerator
sksl_shared
sksl_compute
sksl_frag
sksl_gpu
sksl_public
sksl_rt_shader
sksl_vert
sksl_graphite_frag
sksl_graphite_frag_es2
sksl_graphite_vert
sksl_graphite_vert_es2

Definition at line 15 of file SkSLModuleData.h.

                      {
    sksl_shared,
    sksl_compute,
    sksl_frag,
    sksl_gpu,
    sksl_public,
    sksl_rt_shader,
    sksl_vert,
    sksl_graphite_frag,
    sksl_graphite_frag_es2,
    sksl_graphite_vert,
    sksl_graphite_vert_es2,
};

◆ OperatorKind

enum class SkSL::OperatorKind : uint8_t

strong

Enumerator
PLUS
MINUS
STAR
SLASH
PERCENT
SHL
SHR
LOGICALNOT
LOGICALAND
LOGICALOR
LOGICALXOR
BITWISENOT
BITWISEAND
BITWISEOR
BITWISEXOR
EQ
EQEQ
NEQ
LT
GT
LTEQ
GTEQ
PLUSEQ
MINUSEQ
STAREQ
SLASHEQ
PERCENTEQ
SHLEQ
SHREQ
BITWISEANDEQ
BITWISEOREQ
BITWISEXOREQ
PLUSPLUS
MINUSMINUS
COMMA

Definition at line 19 of file SkSLOperator.h.

                        : uint8_t {
    PLUS,
    MINUS,
    STAR,
    SLASH,
    PERCENT,
    SHL,
    SHR,
    LOGICALNOT,
    LOGICALAND,
    LOGICALOR,
    LOGICALXOR,
    BITWISENOT,
    BITWISEAND,
    BITWISEOR,
    BITWISEXOR,
    EQ,
    EQEQ,
    NEQ,
    LT,
    GT,
    LTEQ,
    GTEQ,
    PLUSEQ,
    MINUSEQ,
    STAREQ,
    SLASHEQ,
    PERCENTEQ,
    SHLEQ,
    SHREQ,
    BITWISEANDEQ,
    BITWISEOREQ,
    BITWISEXOREQ,
    PLUSPLUS,
    MINUSMINUS,
    COMMA
};

◆ OperatorPrecedence

enum class SkSL::OperatorPrecedence : uint8_t

strong

Enumerator
kParentheses
kPostfix
kPrefix
kMultiplicative
kAdditive
kShift
kRelational
kEquality
kBitwiseAnd
kBitwiseXor
kBitwiseOr
kLogicalAnd
kLogicalXor
kLogicalOr
kTernary
kAssignment
kSequence
kExpression
kStatement

Definition at line 57 of file SkSLOperator.h.

                              : uint8_t {
    kParentheses    =  1,
    kPostfix        =  2,
    kPrefix         =  3,
    kMultiplicative =  4,
    kAdditive       =  5,
    kShift          =  6,
    kRelational     =  7,
    kEquality       =  8,
    kBitwiseAnd     =  9,
    kBitwiseXor     = 10,
    kBitwiseOr      = 11,
    kLogicalAnd     = 12,
    kLogicalXor     = 13,
    kLogicalOr      = 14,
    kTernary        = 15,
    kAssignment     = 16,
    kSequence       = 17,        // a comma-separated sequence
    kExpression     = kSequence, // a top-level expression, anywhere in a statement
    kStatement      = 18,        // a standalone expression-statement
};

◆ ProgramElementKind

enum class SkSL::ProgramElementKind

strong

Enumerator
kExtension
kFunction
kFunctionPrototype
kGlobalVar
kInterfaceBlock
kModifiers
kStructDefinition
kFirst
kLast

Definition at line 19 of file SkSLIRNode.h.

                              {
    kExtension = 0,
    kFunction,
    kFunctionPrototype,
    kGlobalVar,
    kInterfaceBlock,
    kModifiers,
    kStructDefinition,
 
    kFirst = kExtension,
    kLast = kStructDefinition
};

◆ ProgramKind

enum class SkSL::ProgramKind : int8_t

strong

SkSL supports several different program kinds.

Enumerator
kFragment
kVertex
kCompute
kGraphiteFragment
kGraphiteVertex
kGraphiteFragmentES2
kGraphiteVertexES2
kRuntimeColorFilter
kRuntimeShader
kRuntimeBlender
kPrivateRuntimeColorFilter
kPrivateRuntimeShader
kPrivateRuntimeBlender
kMeshVertex
kMeshFragment

Definition at line 18 of file SkSLProgramKind.h.

                       : int8_t {
    kFragment,
    kVertex,
    kCompute,
    kGraphiteFragment,
    kGraphiteVertex,
    kGraphiteFragmentES2,
    kGraphiteVertexES2,
    kRuntimeColorFilter,        // Runtime effect only suitable as SkColorFilter
    kRuntimeShader,             //   "       "     "      "     "  SkShader
    kRuntimeBlender,            //   "       "     "      "     "  SkBlender
    kPrivateRuntimeColorFilter, // Runtime color filter with public restrictions lifted
    kPrivateRuntimeShader,      // Runtime shader        "     "         "         "
    kPrivateRuntimeBlender,     // Runtime blender       "     "         "         "
    kMeshVertex,                // Vertex   portion of a custom mesh
    kMeshFragment,              // Fragment  "      "  "   "     "
};

◆ StatementKind

enum class SkSL::StatementKind

strong

Enumerator
kBlock
kBreak
kContinue
kDiscard
kDo
kExpression
kFor
kIf
kNop
kReturn
kSwitch
kSwitchCase
kVarDeclaration
kFirst
kLast

Definition at line 43 of file SkSLIRNode.h.

                         {
    kBlock = (int) SymbolKind::kLast + 1,
    kBreak,
    kContinue,
    kDiscard,
    kDo,
    kExpression,
    kFor,
    kIf,
    kNop,
    kReturn,
    kSwitch,
    kSwitchCase,
    kVarDeclaration,
 
    kFirst = kBlock,
    kLast = kVarDeclaration,
};

◆ SymbolKind

enum class SkSL::SymbolKind

strong

Enumerator
kExternal
kField
kFunctionDeclaration
kType
kVariable
kFirst
kLast

Definition at line 32 of file SkSLIRNode.h.

                      {
    kExternal = (int) ProgramElementKind::kLast + 1,
    kField,
    kFunctionDeclaration,
    kType,
    kVariable,
 
    kFirst = kExternal,
    kLast = kVariable
};

◆ VariableRefKind

enum class SkSL::VariableRefKind : int8_t

strong

Enumerator
kRead
kWrite
kReadWrite
kPointer

Definition at line 25 of file SkSLVariableReference.h.

                           : int8_t {
    kRead,
    kWrite,
    kReadWrite,
    // taking the address of a variable - we consider this a read & write but don't complain if
    // the variable was not previously assigned
    kPointer
};

◆ VariableStorage

enum class SkSL::VariableStorage : int8_t

strong

Enumerator
kGlobal
kInterfaceBlock
kLocal
kParameter

Definition at line 36 of file SkSLVariable.h.

                           : int8_t {
    kGlobal,
    kInterfaceBlock,
    kLocal,
    kParameter,
};

◆ Version

enum class SkSL::Version

strong

Enumerator
k100	Desktop GLSL 1.10, GLSL ES 1.00, WebGL 1.0
k300	Desktop GLSL 3.30, GLSL ES 3.00, WebGL 2.0

Definition at line 13 of file SkSLVersion.h.

                   {
    /**
     * Desktop GLSL 1.10, GLSL ES 1.00, WebGL 1.0
     */
    k100,
 
    /**
     * Desktop GLSL 3.30, GLSL ES 3.00, WebGL 2.0
     */
    k300,
};

Function Documentation

◆ all_arguments_constant()

static bool SkSL::all_arguments_constant ( const ExpressionArray & arguments )

static

Definition at line 2820 of file SkSLWGSLCodeGenerator.cpp.

                                                                     {
    // Returns true if all arguments in the ExpressionArray are compile-time constants. If we are
    // calling an intrinsic and all of its inputs are constant, but we didn't constant-fold it, this
    // generally indicates that constant-folding resulted in an infinity or nan. The WGSL compiler
    // will reject such an expression with a compile-time error. We can dodge the error, taking on
    // the risk of indeterminate behavior instead, by replacing one of the constant values with a
    // scratch let-variable. (skia:14385)
    for (const std::unique_ptr<Expression>& arg : arguments) {
        if (!ConstantFolder::GetConstantValueOrNull(*arg)) {
            return false;
        }
    }
    return true;
}

◆ append_rtadjust_fixup_to_vertex_main()

static void SkSL::append_rtadjust_fixup_to_vertex_main	(	const Context &	context,
		const FunctionDeclaration &	decl,
		Block &	body
	)

static

Definition at line 43 of file SkSLFunctionDefinition.cpp.

                                                              {
    // If this program uses RTAdjust...
    if (const SkSL::Symbol* rtAdjust = context.fSymbolTable->find(Compiler::RTADJUST_NAME)) {
        // ...append a line to the end of the function body which fixes up sk_Position.
        struct AppendRTAdjustFixupHelper : public IRHelpers {
            AppendRTAdjustFixupHelper(const Context& ctx, const SkSL::Symbol* rtAdjust)
                    : IRHelpers(ctx)
                    , fRTAdjust(rtAdjust) {
                fSkPositionField = &fContext.fSymbolTable->find(Compiler::POSITION_NAME)
                                                         ->as<FieldSymbol>();
            }
 
            std::unique_ptr<Expression> Pos() const {
                return Field(&fSkPositionField->owner(), fSkPositionField->fieldIndex());
            }
 
            std::unique_ptr<Expression> Adjust() const {
                return fRTAdjust->instantiate(fContext, Position());
            }
 
            std::unique_ptr<Statement> makeFixupStmt() const {
                // sk_Position = float4(sk_Position.xy * rtAdjust.xz + sk_Position.ww * rtAdjust.yw,
                //                      0,
                //                      sk_Position.w);
                return Assign(
                   Pos(),
                   CtorXYZW(Add(Mul(Swizzle(Pos(),    {SwizzleComponent::X, SwizzleComponent::Y}),
                                    Swizzle(Adjust(), {SwizzleComponent::X, SwizzleComponent::Z})),
                                Mul(Swizzle(Pos(),    {SwizzleComponent::W, SwizzleComponent::W}),
                                    Swizzle(Adjust(), {SwizzleComponent::Y, SwizzleComponent::W}))),
                            Float(0.0),
                            Swizzle(Pos(), {SwizzleComponent::W})));
            }
 
            const FieldSymbol* fSkPositionField;
            const SkSL::Symbol* fRTAdjust;
        };
 
        AppendRTAdjustFixupHelper helper(context, rtAdjust);
        body.children().push_back(helper.makeFixupStmt());
    }
}

◆ apply_to_elements()

static std::unique_ptr< Expression > SkSL::apply_to_elements	(	const Context &	context,
		Position	pos,
		const Expression &	expr,
		double(*)(double)	fn
	)

static

Definition at line 43 of file SkSLPrefixExpression.cpp.

                                                                           {
    const Type& elementType = expr.type().componentType();
 
    double values[16];
    size_t numSlots = expr.type().slotCount();
    if (numSlots > std::size(values)) {
        // The expression has more slots than we expected.
        return nullptr;
    }
 
    for (size_t index = 0; index < numSlots; ++index) {
        if (std::optional<double> slotValue = expr.getConstantValue(index)) {
            values[index] = fn(*slotValue);
            if (elementType.checkForOutOfRangeLiteral(context, values[index], pos)) {
                // We can't simplify the expression if the new value is out-of-range for the type.
                return nullptr;
            }
        } else {
            // There's a non-constant element; we can't simplify this expression.
            return nullptr;
        }
    }
    return ConstructorCompound::MakeFromConstants(context, pos, expr.type(), values);
}

◆ argument_and_parameter_flags_match()

static bool SkSL::argument_and_parameter_flags_match	(	const Expression &	argument,
		const Variable &	parameter
	)

static

Definition at line 1021 of file SkSLFunctionCall.cpp.

                                                                          {
    // If the function parameter has a pixel format, the argument being passed in must have a
    // matching pixel format.
    LayoutFlags paramPixelFormat = parameter.layout().fFlags & LayoutFlag::kAllPixelFormats;
    if (paramPixelFormat != LayoutFlag::kNone) {
        // The only SkSL type that supports pixel-format qualifiers is a storage texture.
        if (parameter.type().isStorageTexture()) {
            // Storage textures are opaquely typed, so there's no way to specify one other than by
            // directly accessing a variable.
            if (!argument.is<VariableReference>()) {
                return false;
            }
 
            // The variable's pixel-format flags must match. (Only one pixel-format bit can be set.)
            const Variable& var = *argument.as<VariableReference>().variable();
            if ((var.layout().fFlags & LayoutFlag::kAllPixelFormats) != paramPixelFormat) {
                return false;
            }
        }
    }
 
    // The only other supported parameter flags are `const` and `in/out`, which do not allow
    // multiple overloads.
    return true;
}

◆ argument_needs_scratch_variable()

static bool SkSL::argument_needs_scratch_variable	(	const Expression *	arg,
		const Variable *	param,
		const ProgramUsage &	usage
	)

static

Definition at line 518 of file SkSLInliner.cpp.

                                                                       {
    // If the parameter isn't written to within the inline function ...
    const ProgramUsage::VariableCounts& paramUsage = usage.get(*param);
    if (!paramUsage.fWrite) {
        // ... and can be inlined trivially (e.g. a swizzle, or a constant array index),
        // or any expression without side effects that is only accessed at most once...
        if ((paramUsage.fRead > 1) ? Analysis::IsTrivialExpression(*arg)
                                   : !Analysis::HasSideEffects(*arg)) {
            // ... we don't need to copy it at all! We can just use the existing expression.
            return false;
        }
    }
    // We need a scratch variable.
    return true;
}

◆ arguments_match_field_types()

static bool SkSL::arguments_match_field_types	(	const ExpressionArray &	args,
		const Type &	type
	)

static

Definition at line 62 of file SkSLConstructorStruct.cpp.

                                                                           {
    SkASSERT(type.fields().size() == SkToSizeT(args.size()));
 
    for (int index = 0; index < args.size(); ++index) {
        const std::unique_ptr<Expression>& argument = args[index];
        const Field& field = type.fields()[index];
        if (!argument->type().matches(*field.fType)) {
            return false;
        }
    }
 
    return true;
}

◆ binary_op_is_ambiguous_in_wgsl()

static bool SkSL::binary_op_is_ambiguous_in_wgsl ( Operator op )

static

Definition at line 2536 of file SkSLWGSLCodeGenerator.cpp.

                                                        {
    // WGSL always requires parentheses for some operators which are deemed to be ambiguous.
    // (8.19. Operator Precedence and Associativity)
    switch (op.kind()) {
        case OperatorKind::LOGICALOR:
        case OperatorKind::LOGICALAND:
        case OperatorKind::BITWISEOR:
        case OperatorKind::BITWISEAND:
        case OperatorKind::BITWISEXOR:
        case OperatorKind::SHL:
        case OperatorKind::SHR:
        case OperatorKind::LT:
        case OperatorKind::GT:
        case OperatorKind::LTEQ:
        case OperatorKind::GTEQ:
            return true;
 
        default:
            return false;
    }
}

◆ bitwise_not_operand()

static std::unique_ptr< Expression > SkSL::bitwise_not_operand	(	const Context &	context,
		Position	pos,
		std::unique_ptr< Expression >	operand
	)

static

Definition at line 198 of file SkSLPrefixExpression.cpp.

                                                                                          {
    SkASSERT(operand->type().componentType().isInteger());
 
    const Expression* value = ConstantFolder::GetConstantValueForVariable(*operand);
 
    switch (value->kind()) {
        case Expression::Kind::kLiteral:
        case Expression::Kind::kConstructorSplat:
        case Expression::Kind::kConstructorCompound: {
            // Convert ~vecN(1, 2, ...) to vecN(~1, ~2, ...).
            if (std::unique_ptr<Expression> expr = apply_to_elements(context, pos, *value,
                                                                     bitwise_not_value)) {
                return expr;
            }
            break;
        }
        case Expression::Kind::kPrefix: {
            // Convert `~(~expression)` into `expression`.
            PrefixExpression& prefix = operand->as<PrefixExpression>();
            if (prefix.getOperator().kind() == Operator::Kind::BITWISENOT) {
                prefix.operand()->fPosition = pos;
                return std::move(prefix.operand());
            }
            break;
        }
        default:
            break;
    }
 
    // No simplified form; convert expression to Prefix(BITWISENOT, expression).
    return std::make_unique<PrefixExpression>(pos, Operator::Kind::BITWISENOT, std::move(operand));
}

◆ bitwise_not_value()

static double SkSL::bitwise_not_value ( double value )

static

Definition at line 39 of file SkSLPrefixExpression.cpp.

                                              {
    return ~static_cast<SKSL_INT>(value);
}

◆ block_for_case()

static bool SkSL::block_for_case	(	Statement *	caseBlock,
		SwitchCase *	caseToCapture
	)

static

Definition at line 84 of file SkSLSwitchStatement.cpp.

                                                                            {
    // This function reduces a switch to the matching case (or cases, if fallthrough occurs) when
    // the switch-value is known and no conditional breaks exist. If conversion is not possible,
    // false is returned and no changes are made. Conversion can fail if the switch contains
    // conditional breaks.
    //
    // We have to be careful to not move any of the pointers until after we're sure we're going to
    // succeed, so before we make any changes at all, we check the switch-cases to decide on a plan
    // of action.
    //
    // First, we identify the code that would be run if the switch's value matches `caseToCapture`.
    StatementArray& cases = caseBlock->as<Block>().children();
    auto iter = cases.begin();
    for (; iter != cases.end(); ++iter) {
        const SwitchCase& sc = (*iter)->as<SwitchCase>();
        if (&sc == caseToCapture) {
            break;
        }
    }
 
    // Next, walk forward through the rest of the switch. If we find a conditional break, we're
    // stuck and can't simplify at all. If we find an unconditional break, we have a range of
    // statements that we can use for simplification.
    auto startIter = iter;
    bool removeBreakStatements = false;
    for (; iter != cases.end(); ++iter) {
        std::unique_ptr<Statement>& stmt = (*iter)->as<SwitchCase>().statement();
        if (Analysis::SwitchCaseContainsConditionalExit(*stmt)) {
            // We can't reduce switch-cases to a block when they have conditional exits.
            return false;
        }
        if (Analysis::SwitchCaseContainsUnconditionalExit(*stmt)) {
            // We found an unconditional exit. We can use this block, but we'll need to strip
            // out the break statement if there is one.
            removeBreakStatements = true;
            ++iter;
            break;
        }
    }
 
    // We fell off the bottom of the switch or encountered a break. Next, we must strip down
    // `caseBlock` to hold only the statements needed to execute `caseToCapture`. To do this, we
    // eliminate the SwitchCase elements. This converts each `case n: stmt;` element into just
    // `stmt;`. While doing this, we also move the elements to the front of the array if they
    // weren't already there.
    int numElements = SkToInt(std::distance(startIter, iter));
    for (int index = 0; index < numElements; ++index, ++startIter) {
        cases[index] = std::move((*startIter)->as<SwitchCase>().statement());
    }
 
    // Next, we shrink the statement array to destroy the excess statements.
    cases.pop_back_n(cases.size() - numElements);
 
    // If we found an unconditional break at the end, we need to eliminate that break.
    if (removeBreakStatements) {
        remove_break_statements(cases.back());
    }
 
    // We've stripped down `caseBlock` to contain only the captured case. Return true.
    return true;
}

◆ build_argument_type_list()

static std::string SkSL::build_argument_type_list ( SkSpan< const std::unique_ptr< Expression > > arguments )

static

Definition at line 1107 of file SkSLFunctionCall.cpp.

                                                                                             {
    std::string result = "(";
    auto separator = SkSL::String::Separator();
    for (const std::unique_ptr<Expression>& arg : arguments) {
        result += separator();
        result += arg->type().displayName();
    }
    return result + ")";
}

◆ calculate_count()

static int SkSL::calculate_count	(	double	start,
		double	end,
		double	delta,
		bool	forwards,
		bool	inclusive
	)

static

Definition at line 38 of file SkSLGetLoopUnrollInfo.cpp.

                                                                                                  {
    if ((forwards && start > end) || (!forwards && start < end)) {
        // The loop starts in a completed state (the start has already advanced past the end).
        return 0;
    }
    if ((delta == 0.0) || forwards != (delta > 0.0)) {
        // The loop does not progress toward a completed state, and will never terminate.
        return kLoopTerminationLimit;
    }
    double iterations = sk_ieee_double_divide(end - start, delta);
    double count = std::ceil(iterations);
    if (inclusive && (count == iterations)) {
        count += 1.0;
    }
    if (count > kLoopTerminationLimit || !std::isfinite(count)) {
        // The loop runs for more iterations than we can safely unroll.
        return kLoopTerminationLimit;
    }
    return (int)count;
}

◆ call_cost()

static CoercionCost SkSL::call_cost	(	const Context &	context,
		const FunctionDeclaration &	function,
		const ExpressionArray &	arguments
	)

static

Used to determine the best overload for a function call by calculating the cost of coercing the arguments of the function to the required types. Cost has no particular meaning other than "lower costs are preferred". Returns CoercionCost::Impossible() if the call is not valid. This is never called for functions with only one definition.

Definition at line 1054 of file SkSLFunctionCall.cpp.

                                                                {
    // Strict-ES2 programs can never call an `$es3` function.
    if (context.fConfig->strictES2Mode() && function.modifierFlags().isES3()) {
        return CoercionCost::Impossible();
    }
    // Functions with the wrong number of parameters are never a match.
    if (function.parameters().size() != SkToSizeT(arguments.size())) {
        return CoercionCost::Impossible();
    }
    // If the arguments cannot be coerced to the parameter types, the function is never a match.
    FunctionDeclaration::ParamTypes types;
    const Type* ignored;
    if (!function.determineFinalTypes(arguments, &types, &ignored)) {
        return CoercionCost::Impossible();
    }
    // If the arguments do not match the parameter types due to mismatched modifiers, the function
    // is never a match.
    for (int i = 0; i < arguments.size(); i++) {
        const Expression& arg = *arguments[i];
        const Variable& param = *function.parameters()[i];
        if (!argument_and_parameter_flags_match(arg, param)) {
            return CoercionCost::Impossible();
        }
    }
    // Return the sum of coercion costs of each argument.
    CoercionCost total = CoercionCost::Free();
    for (int i = 0; i < arguments.size(); i++) {
        total = total + arguments[i]->coercionCost(*types[i]);
    }
    return total;
}

◆ call_signature_is_valid()

static bool SkSL::call_signature_is_valid	(	const Context &	context,
		const Variable &	child,
		const ExpressionArray &	arguments
	)

static

Definition at line 39 of file SkSLChildCall.cpp.

                                                                                       {
    const Type* half4 = context.fTypes.fHalf4.get();
    const Type* float2 = context.fTypes.fFloat2.get();
 
    auto params = [&]() -> STArray<2, const Type*> {
        switch (child.type().typeKind()) {
            case Type::TypeKind::kBlender:     return { half4, half4 };
            case Type::TypeKind::kColorFilter: return { half4 };
            case Type::TypeKind::kShader:      return { float2 };
            default:
                SkUNREACHABLE;
        }
    }();
 
    if (params.size() != arguments.size()) {
        return false;
    }
    for (int i = 0; i < arguments.size(); i++) {
        if (!arguments[i]->type().matches(*params[i])) {
            return false;
        }
    }
    return true;
}

◆ candidate_func()

static const FunctionDeclaration & SkSL::candidate_func ( const InlineCandidate & candidate )

static

Definition at line 964 of file SkSLInliner.cpp.

                                                                                   {
    return (*candidate.fCandidateExpr)->as<FunctionCall>().function();
}

◆ cast_constant_array()

static std::unique_ptr< Expression > SkSL::cast_constant_array	(	const Context &	context,
		Position	pos,
		const Type &	destType,
		std::unique_ptr< Expression >	constCtor
	)

static

Definition at line 22 of file SkSLConstructorArrayCast.cpp.

                                                                                            {
    const Type& scalarType = destType.componentType();
 
    // Create a ConstructorArray(...) which typecasts each argument inside.
    auto inputArgs = constCtor->as<ConstructorArray>().argumentSpan();
    ExpressionArray typecastArgs;
    typecastArgs.reserve_exact(inputArgs.size());
    for (std::unique_ptr<Expression>& arg : inputArgs) {
        Position argPos = arg->fPosition;
        if (arg->type().isScalar()) {
            typecastArgs.push_back(ConstructorScalarCast::Make(context, argPos, scalarType,
                                                               std::move(arg)));
        } else {
            typecastArgs.push_back(ConstructorCompoundCast::Make(context, argPos, scalarType,
                                                                 std::move(arg)));
        }
    }
 
    return ConstructorArray::Make(context, pos, destType, std::move(typecastArgs));
}

◆ cast_constant_composite()

static std::unique_ptr< Expression > SkSL::cast_constant_composite	(	const Context &	context,
		Position	pos,
		const Type &	destType,
		std::unique_ptr< Expression >	constCtor
	)

static

Definition at line 25 of file SkSLConstructorCompoundCast.cpp.

                                                                                                {
    const Type& scalarType = destType.componentType();
 
    // We generate nicer code for splats and diagonal matrices by handling them separately instead
    // of relying on the constant-subexpression code below. This is not truly necessary but it makes
    // our output look a little better; human beings prefer `half4(0)` to `half4(0, 0, 0, 0)`.
    if (constCtor->is<ConstructorSplat>()) {
        // This is a typecast of a splat containing a constant value, e.g. `half4(7)`. We can
        // replace it with a splat of a different type, e.g. `int4(7)`.
        ConstructorSplat& splat = constCtor->as<ConstructorSplat>();
        return ConstructorSplat::Make(
                context, pos, destType,
                ConstructorScalarCast::Make(context, pos, scalarType, std::move(splat.argument())));
    }
 
    if (constCtor->is<ConstructorDiagonalMatrix>() && destType.isMatrix()) {
        // This is a typecast of a constant diagonal matrix, e.g. `float3x3(2)`. We can replace it
        // with a diagonal matrix of a different type, e.g. `half3x3(2)`.
        ConstructorDiagonalMatrix& matrixCtor = constCtor->as<ConstructorDiagonalMatrix>();
        return ConstructorDiagonalMatrix::Make(
                context, pos, destType,
                ConstructorScalarCast::Make(context, pos, scalarType,
                                            std::move(matrixCtor.argument())));
    }
 
    // Create a compound Constructor(literal, ...) which typecasts each scalar value inside.
    size_t numSlots = destType.slotCount();
    SkASSERT(numSlots == constCtor->type().slotCount());
 
    double typecastArgs[16];
    SkASSERT(numSlots <= std::size(typecastArgs));
    for (size_t index = 0; index < numSlots; ++index) {
        std::optional<double> slotVal = constCtor->getConstantValue(index);
        if (scalarType.checkForOutOfRangeLiteral(context, *slotVal, constCtor->fPosition)) {
            // We've reported an error because the literal is out of range for this type. Zero out
            // the value to avoid a cascade of errors.
            *slotVal = 0.0;
        }
        typecastArgs[index] = *slotVal;
    }
 
    return ConstructorCompound::MakeFromConstants(context, pos, destType, typecastArgs);
}

◆ cast_expression()

static std::unique_ptr< Expression > SkSL::cast_expression	(	const Context &	context,
		Position	pos,
		const Expression &	expr,
		const Type &	type
	)

static

Definition at line 279 of file SkSLConstantFolder.cpp.

                                                                     {
    SkASSERT(type.componentType().matches(expr.type().componentType()));
    if (expr.type().isScalar()) {
        if (type.isMatrix()) {
            return ConstructorDiagonalMatrix::Make(context, pos, type, expr.clone());
        }
        if (type.isVector()) {
            return ConstructorSplat::Make(context, pos, type, expr.clone());
        }
    }
    if (type.matches(expr.type())) {
        return expr.clone(pos);
    }
    // We can't cast matrices into vectors or vice-versa.
    return nullptr;
}

◆ check_main_signature()

static bool SkSL::check_main_signature	(	const Context &	context,
		Position	pos,
		const Type &	returnType,
		TArray< std::unique_ptr< Variable > > &	parameters
	)

static

Definition at line 132 of file SkSLFunctionDeclaration.cpp.

                                                                              {
    ErrorReporter& errors = *context.fErrors;
    ProgramKind kind = context.fConfig->fKind;
 
    auto typeIsValidForAttributes = [](const Type& type) {
        return type.isStruct() && type.name() == "Attributes";
    };
 
    auto typeIsValidForVaryings = [](const Type& type) {
        return type.isStruct() && type.name() == "Varyings";
    };
 
    auto paramIsCoords = [&](int idx) {
        const Variable& p = *parameters[idx];
        return type_is_valid_for_coords(p.type()) && p.modifierFlags() == ModifierFlag::kNone;
    };
 
    auto paramIsColor = [&](int idx) {
        const Variable& p = *parameters[idx];
        return type_is_valid_for_color(p.type()) && p.modifierFlags() == ModifierFlag::kNone;
    };
 
    auto paramIsConstInAttributes = [&](int idx) {
        const Variable& p = *parameters[idx];
        return typeIsValidForAttributes(p.type()) && p.modifierFlags() == ModifierFlag::kConst;
    };
 
    auto paramIsConstInVaryings = [&](int idx) {
        const Variable& p = *parameters[idx];
        return typeIsValidForVaryings(p.type()) && p.modifierFlags() == ModifierFlag::kConst;
    };
 
    auto paramIsOutColor = [&](int idx) {
        const Variable& p = *parameters[idx];
        return type_is_valid_for_color(p.type()) && p.modifierFlags() == ModifierFlag::kOut;
    };
 
    switch (kind) {
        case ProgramKind::kRuntimeColorFilter:
        case ProgramKind::kPrivateRuntimeColorFilter: {
            // (half4|float4) main(half4|float4)
            if (!type_is_valid_for_color(returnType)) {
                errors.error(pos, "'main' must return: 'vec4', 'float4', or 'half4'");
                return false;
            }
            bool validParams = (parameters.size() == 1 && paramIsColor(0));
            if (!validParams) {
                errors.error(pos, "'main' parameter must be 'vec4', 'float4', or 'half4'");
                return false;
            }
            break;
        }
        case ProgramKind::kRuntimeShader:
        case ProgramKind::kPrivateRuntimeShader: {
            // (half4|float4) main(float2)
            if (!type_is_valid_for_color(returnType)) {
                errors.error(pos, "'main' must return: 'vec4', 'float4', or 'half4'");
                return false;
            }
            if (!(parameters.size() == 1 && paramIsCoords(0))) {
                errors.error(pos, "'main' parameter must be 'float2' or 'vec2'");
                return false;
            }
            break;
        }
        case ProgramKind::kRuntimeBlender:
        case ProgramKind::kPrivateRuntimeBlender: {
            // (half4|float4) main(half4|float4, half4|float4)
            if (!type_is_valid_for_color(returnType)) {
                errors.error(pos, "'main' must return: 'vec4', 'float4', or 'half4'");
                return false;
            }
            if (!(parameters.size() == 2 && paramIsColor(0) && paramIsColor(1))) {
                errors.error(pos, "'main' parameters must be (vec4|float4|half4, "
                                  "vec4|float4|half4)");
                return false;
            }
            break;
        }
        case ProgramKind::kMeshVertex: {
            // Varyings main(const Attributes)
            if (!typeIsValidForVaryings(returnType)) {
                errors.error(pos, "'main' must return 'Varyings'.");
                return false;
            }
            if (!(parameters.size() == 1 && paramIsConstInAttributes(0))) {
                errors.error(pos, "'main' parameter must be 'const Attributes'.");
                return false;
            }
            break;
        }
        case ProgramKind::kMeshFragment: {
            // float2 main(const Varyings) -or- float2 main(const Varyings, out half4|float4)
            if (!type_is_valid_for_coords(returnType)) {
                errors.error(pos, "'main' must return: 'vec2' or 'float2'");
                return false;
            }
            if (!((parameters.size() == 1 && paramIsConstInVaryings(0)) ||
                  (parameters.size() == 2 && paramIsConstInVaryings(0) && paramIsOutColor(1)))) {
                errors.error(pos,
                             "'main' parameters must be (const Varyings, (out (half4|float4))?)");
                return false;
            }
            break;
        }
        case ProgramKind::kFragment:
        case ProgramKind::kGraphiteFragment:
        case ProgramKind::kGraphiteFragmentES2: {
            bool validParams = (parameters.size() == 0) ||
                               (parameters.size() == 1 && paramIsCoords(0));
            if (!validParams) {
                errors.error(pos, "shader 'main' must be main() or main(float2)");
                return false;
            }
            break;
        }
        case ProgramKind::kVertex:
        case ProgramKind::kGraphiteVertex:
        case ProgramKind::kGraphiteVertexES2:
        case ProgramKind::kCompute:
            if (!returnType.matches(*context.fTypes.fVoid)) {
                errors.error(pos, "'main' must return 'void'");
                return false;
            }
            if (parameters.size()) {
                errors.error(pos, "shader 'main' must have zero parameters");
                return false;
            }
            break;
    }
    return true;
}

◆ check_modifiers()

static bool SkSL::check_modifiers	(	const Context &	context,
		Position	pos,
		ModifierFlags	modifierFlags
	)

static

Definition at line 38 of file SkSLFunctionDeclaration.cpp.

                                                                                               {
    const ModifierFlags permitted = ModifierFlag::kInline |
                                    ModifierFlag::kNoInline |
                                    (context.fConfig->fIsBuiltinCode ? ModifierFlag::kES3 |
                                                                       ModifierFlag::kPure |
                                                                       ModifierFlag::kExport
                                                                     : ModifierFlag::kNone);
    modifierFlags.checkPermittedFlags(context, pos, permitted);
    if (modifierFlags.isInline() && modifierFlags.isNoInline()) {
        context.fErrors->error(pos, "functions cannot be both 'inline' and 'noinline'");
        return false;
    }
    return true;
}

◆ check_parameters()

static bool SkSL::check_parameters	(	const Context &	context,
		TArray< std::unique_ptr< Variable > > &	parameters,
		ModifierFlags	modifierFlags,
		IntrinsicKind	intrinsicKind
	)

static

Definition at line 71 of file SkSLFunctionDeclaration.cpp.

                                                          {
    // Check modifiers on each function parameter.
    for (auto& param : parameters) {
        const Type& type = param->type();
        ModifierFlags permittedFlags = ModifierFlag::kConst | ModifierFlag::kIn;
        LayoutFlags permittedLayoutFlags = LayoutFlag::kNone;
        if (!type.isOpaque()) {
            permittedFlags |= ModifierFlag::kOut;
        }
        if (type.isStorageTexture()) {
            // We allow `readonly`, `writeonly` and `layout(pixel-format)` on storage textures.
            permittedFlags |= ModifierFlag::kReadOnly | ModifierFlag::kWriteOnly;
            permittedLayoutFlags |= LayoutFlag::kAllPixelFormats;
 
            // Intrinsics are allowed to accept any pixel format, but user code must explicitly
            // specify a pixel format like `layout(rgba32f)`.
            if (intrinsicKind == kNotIntrinsic &&
                !(param->layout().fFlags & LayoutFlag::kAllPixelFormats)) {
                context.fErrors->error(param->fPosition, "storage texture parameters must specify "
                                                         "a pixel format layout-qualifier");
                return false;
            }
        }
        param->modifierFlags().checkPermittedFlags(context, param->modifiersPosition(),
                                                   permittedFlags);
        param->layout().checkPermittedLayout(context, param->modifiersPosition(),
                                             permittedLayoutFlags);
        // Only the (builtin) declarations of 'sample' are allowed to have shader/colorFilter or FP
        // parameters. You can pass other opaque types to functions safely; this restriction is
        // specific to "child" objects.
        if (type.isEffectChild() && !context.fConfig->fIsBuiltinCode) {
            context.fErrors->error(param->fPosition, "parameters of type '" + type.displayName() +
                                                     "' not allowed");
            return false;
        }
 
        // Pure functions should not change any state, and should be safe to eliminate if their
        // result is not used; this is incompatible with out-parameters, so we forbid it here.
        // (We don't exhaustively guard against pure functions changing global state in other ways,
        // though, since they aren't allowed in user code.)
        if (modifierFlags.isPure() && (param->modifierFlags() & ModifierFlag::kOut)) {
            context.fErrors->error(param->modifiersPosition(),
                                   "pure functions cannot have out parameters");
            return false;
        }
    }
    return true;
}

◆ check_return_type()

static bool SkSL::check_return_type	(	const Context &	context,
		Position	pos,
		const Type &	returnType
	)

static

Definition at line 53 of file SkSLFunctionDeclaration.cpp.

                                                                                            {
    ErrorReporter& errors = *context.fErrors;
    if (returnType.isArray()) {
        errors.error(pos, "functions may not return type '" + returnType.displayName() + "'");
        return false;
    }
    if (context.fConfig->strictES2Mode() && returnType.isOrContainsArray()) {
        errors.error(pos, "functions may not return structs containing arrays");
        return false;
    }
    if (!context.fConfig->fIsBuiltinCode && returnType.componentType().isOpaque()) {
        errors.error(pos, "functions may not return opaque type '" + returnType.displayName() +
                "'");
        return false;
    }
    return true;
}

◆ coalesce_n_way_vector()

static std::unique_ptr< Expression > SkSL::coalesce_n_way_vector	(	const Expression *	arg0,
		const Expression *	arg1,
		double	startingState,
		const Type &	returnType,
		CoalesceFn	coalesce,
		FinalizeFn	finalize
	)

static

Definition at line 84 of file SkSLFunctionCall.cpp.

                                                                              {
    // Takes up to two vector or scalar arguments and coalesces them in sequence:
    //     scalar = startingState;
    //     scalar = coalesce(scalar, arg0.x, arg1.x);
    //     scalar = coalesce(scalar, arg0.y, arg1.y);
    //     scalar = coalesce(scalar, arg0.z, arg1.z);
    //     scalar = coalesce(scalar, arg0.w, arg1.w);
    //     scalar = finalize(scalar);
    //
    // If an argument is null, zero is passed to the coalesce function. If the arguments are a mix
    // of scalars and vectors, the scalars are interpreted as a vector containing the same value for
    // every component.
 
    Position pos = arg0->fPosition;
    double minimumValue = returnType.componentType().minimumValue();
    double maximumValue = returnType.componentType().maximumValue();
 
    const Type& vecType =          arg0->type().isVector()  ? arg0->type() :
                          (arg1 && arg1->type().isVector()) ? arg1->type() :
                                                              arg0->type();
    SkASSERT(         arg0->type().componentType().matches(vecType.componentType()));
    SkASSERT(!arg1 || arg1->type().componentType().matches(vecType.componentType()));
 
    double value = startingState;
    int arg0Index = 0;
    int arg1Index = 0;
    for (int index = 0; index < vecType.columns(); ++index) {
        std::optional<double> arg0Value = arg0->getConstantValue(arg0Index);
        arg0Index += arg0->type().isVector() ? 1 : 0;
        SkASSERT(arg0Value.has_value());
 
        std::optional<double> arg1Value = 0.0;
        if (arg1) {
            arg1Value = arg1->getConstantValue(arg1Index);
            arg1Index += arg1->type().isVector() ? 1 : 0;
            SkASSERT(arg1Value.has_value());
        }
 
        value = coalesce(value, *arg0Value, *arg1Value);
 
        if (value >= minimumValue && value <= maximumValue) {
            // This result will fit inside the return type.
        } else {
            // The value is outside the float range or is NaN (all if-checks fail); do not optimize.
            return nullptr;
        }
    }
 
    if (finalize) {
        value = finalize(value);
    }
 
    return Literal::Make(pos, value, &returnType);
}

◆ coalesce_pairwise_vectors()

template<typename T >

static std::unique_ptr< Expression > SkSL::coalesce_pairwise_vectors	(	const IntrinsicArguments &	arguments,
		double	startingState,
		const Type &	returnType,
		CoalesceFn	coalesce,
		FinalizeFn	finalize
	)

static

Definition at line 159 of file SkSLFunctionCall.cpp.

                                                                                  {
    SkASSERT(arguments[0]);
    SkASSERT(arguments[1]);
    SkASSERT(!arguments[2]);
    type_check_expression<T>(*arguments[0]);
    type_check_expression<T>(*arguments[1]);
 
    return coalesce_n_way_vector(arguments[0], arguments[1],
                                 startingState, returnType, coalesce, finalize);
}

◆ coalesce_vector()

template<typename T >

static std::unique_ptr< Expression > SkSL::coalesce_vector	(	const IntrinsicArguments &	arguments,
		double	startingState,
		const Type &	returnType,
		CoalesceFn	coalesce,
		FinalizeFn	finalize
	)

static

Definition at line 145 of file SkSLFunctionCall.cpp.

                                                                        {
    SkASSERT(arguments[0]);
    SkASSERT(!arguments[1]);
    type_check_expression<T>(*arguments[0]);
 
    return coalesce_n_way_vector(arguments[0], /*arg1=*/nullptr,
                                 startingState, returnType, coalesce, finalize);
}

◆ compile_and_shrink()

static std::unique_ptr< Module > SkSL::compile_and_shrink	(	SkSL::Compiler *	compiler,
		ProgramKind	kind,
		const char *	moduleName,
		std::string	moduleSource,
		const Module *	parent
	)

static

Definition at line 147 of file SkSLModuleLoader.cpp.

                                                                        {
    std::unique_ptr<Module> m = compiler->compileModule(kind,
                                                        moduleName,
                                                        std::move(moduleSource),
                                                        parent,
                                                        /*shouldInline=*/true);
    if (!m) {
        SK_ABORT("Unable to load module %s", moduleName);
    }
 
    // We can eliminate FunctionPrototypes without changing the meaning of the module; the function
    // declaration is still safely in the symbol table. This only impacts our ability to recreate
    // the input verbatim, which we don't care about at runtime.
    m->fElements.erase(std::remove_if(m->fElements.begin(), m->fElements.end(),
                                      [](const std::unique_ptr<ProgramElement>& element) {
                                          switch (element->kind()) {
                                              case ProgramElement::Kind::kFunction:
                                              case ProgramElement::Kind::kGlobalVar:
                                              case ProgramElement::Kind::kInterfaceBlock:
                                              case ProgramElement::Kind::kStructDefinition:
                                                  // We need to preserve these.
                                                  return false;
 
                                              case ProgramElement::Kind::kFunctionPrototype:
                                                  // These are already in the symbol table; the
                                                  // ProgramElement isn't needed anymore.
                                                  return true;
 
                                              default:
                                                  SkDEBUGFAILF("Unsupported element: %s\n",
                                                               element->description().c_str());
                                                  return false;
                                          }
                                      }),
                       m->fElements.end());
 
    m->fElements.shrink_to_fit();
    return m;
}

◆ contains_builtin_struct()

static bool SkSL::contains_builtin_struct ( const ProgramUsage & usage )

static

Definition at line 27 of file SkSLFindAndDeclareBuiltinStructs.cpp.

                                                               {
    for (const auto& [symbol, count] : usage.fStructCounts) {
        const Type& type = symbol->as<Type>();
        if (type.isBuiltin()) {
            return true;
        }
    }
    return false;
}

◆ contains_constant_zero()

static bool SkSL::contains_constant_zero ( const Expression & expr )

static

Definition at line 343 of file SkSLConstantFolder.cpp.

                                                           {
    int numSlots = expr.type().slotCount();
    for (int index = 0; index < numSlots; ++index) {
        std::optional<double> slotVal = expr.getConstantValue(index);
        if (slotVal.has_value() && *slotVal == 0.0) {
            return true;
        }
    }
    return false;
}

◆ contains_matching_data()

static bool SkSL::contains_matching_data	(	const ProgramUsage &	a,
		const ProgramUsage &	b
	)

static

Definition at line 220 of file SkSLProgramUsage.cpp.

                                                                                 {
    constexpr bool kReportMismatch = false;
 
    for (const auto& [varA, varCountA] : a.fVariableCounts) {
        // Skip variable entries with zero reported usage.
        if (!varCountA.fVarExists && !varCountA.fRead && !varCountA.fWrite) {
            continue;
        }
        // Find the matching variable in the other map and ensure that its counts match.
        const ProgramUsage::VariableCounts* varCountB = b.fVariableCounts.find(varA);
        if (!varCountB || 0 != memcmp(&varCountA, varCountB, sizeof(varCountA))) {
            if constexpr (kReportMismatch) {
                SkDebugf("VariableCounts mismatch: '%.*s' (E%d R%d W%d != E%d R%d W%d)\n",
                         (int)varA->name().size(), varA->name().data(),
                         varCountA.fVarExists,
                         varCountA.fRead,
                         varCountA.fWrite,
                         varCountB ? varCountB->fVarExists : 0,
                         varCountB ? varCountB->fRead : 0,
                         varCountB ? varCountB->fWrite : 0);
            }
            return false;
        }
    }
 
    for (const auto& [callA, callCountA] : a.fCallCounts) {
        // Skip function-call entries with zero reported usage.
        if (!callCountA) {
            continue;
        }
        // Find the matching function in the other map and ensure that its call-count matches.
        const int* callCountB = b.fCallCounts.find(callA);
        if (!callCountB || callCountA != *callCountB) {
            if constexpr (kReportMismatch) {
                SkDebugf("CallCounts mismatch: '%.*s' (%d != %d)\n",
                         (int)callA->name().size(), callA->name().data(),
                         callCountA,
                         callCountB ? *callCountB : 0);
            }
            return false;
        }
    }
 
    for (const auto& [structA, structCountA] : a.fStructCounts) {
        // Skip struct entries with zero reported usage.
        if (!structCountA) {
            continue;
        }
        // Find the matching struct in the other map and ensure that its usage-count matches.
        const int* structCountB = b.fStructCounts.find(structA);
        if (!structCountB || structCountA != *structCountB) {
            if constexpr (kReportMismatch) {
                SkDebugf("StructCounts mismatch: '%.*s' (%d != %d)\n",
                         (int)structA->name().size(), structA->name().data(),
                         structCountA,
                         structCountB ? *structCountB : 0);
            }
            return false;
        }
    }
 
    // Every non-zero entry in A has a matching non-zero entry in B.
    return true;
}

◆ convert_compound_constructor()

static std::unique_ptr< Expression > SkSL::convert_compound_constructor	(	const Context &	context,
		Position	pos,
		const Type &	type,
		ExpressionArray	args
	)

static

Definition at line 28 of file SkSLConstructor.cpp.

                                                                                      {
    SkASSERT(type.isVector() || type.isMatrix());
 
    // The meaning of a compound constructor containing a single argument varies significantly in
    // GLSL/SkSL, depending on the argument type.
    if (args.size() == 1) {
        std::unique_ptr<Expression>& argument = args.front();
        if (type.isVector() && argument->type().isVector() &&
            argument->type().componentType().matches(type.componentType()) &&
            argument->type().slotCount() > type.slotCount()) {
            // Casting a vector-type into a smaller matching vector-type is a slice in GLSL.
            // We don't allow those casts in SkSL; recommend a swizzle instead.
            // Only `.xy` and `.xyz` are valid recommendations here, because `.x` would imply a
            // scalar(vector) cast, and nothing has more slots than `.xyzw`.
            const char* swizzleHint;
            switch (type.slotCount()) {
                case 2:  swizzleHint = "; use '.xy' instead"; break;
                case 3:  swizzleHint = "; use '.xyz' instead"; break;
                default: swizzleHint = ""; SkDEBUGFAIL("unexpected slicing cast"); break;
            }
 
            context.fErrors->error(pos, "'" + argument->type().displayName() +
                    "' is not a valid parameter to '" + type.displayName() + "' constructor" +
                    swizzleHint);
            return nullptr;
        }
 
        if (argument->type().isScalar()) {
            // A constructor containing a single scalar is a splat (for vectors) or diagonal matrix
            // (for matrices). It's legal regardless of the scalar's type, so synthesize an explicit
            // conversion to the proper type. (This cast is a no-op if it's unnecessary; it can fail
            // if we're casting a literal that exceeds the limits of the type.)
            std::unique_ptr<Expression> typecast = ConstructorScalarCast::Convert(
                        context, pos, type.componentType(), std::move(args));
            if (!typecast) {
                return nullptr;
            }
 
            // Matrix-from-scalar creates a diagonal matrix; vector-from-scalar creates a splat.
            return type.isMatrix()
                       ? ConstructorDiagonalMatrix::Make(context, pos, type, std::move(typecast))
                       : ConstructorSplat::Make(context, pos, type, std::move(typecast));
        } else if (argument->type().isVector()) {
            // A vector constructor containing a single vector with the same number of columns is a
            // cast (e.g. float3 -> int3).
            if (type.isVector() && argument->type().columns() == type.columns()) {
                return ConstructorCompoundCast::Make(context, pos, type, std::move(argument));
            }
        } else if (argument->type().isMatrix()) {
            // A matrix constructor containing a single matrix can be a resize, typecast, or both.
            // GLSL lumps these into one category, but internally SkSL keeps them distinct.
            if (type.isMatrix()) {
                // First, handle type conversion. If the component types differ, synthesize the
                // destination type with the argument's rows/columns. (This will be a no-op if it's
                // already the right type.)
                const Type& typecastType = type.componentType().toCompound(
                        context,
                        argument->type().columns(),
                        argument->type().rows());
                argument = ConstructorCompoundCast::Make(context, pos, typecastType,
                                                         std::move(argument));
 
                // Casting a matrix type into another matrix type is a resize.
                return ConstructorMatrixResize::Make(context, pos, type,
                                                     std::move(argument));
            }
 
            // A vector constructor containing a single matrix can be compound construction if the
            // matrix is 2x2 and the vector is 4-slot.
            if (type.isVector() && type.columns() == 4 && argument->type().slotCount() == 4) {
                // Casting a 2x2 matrix to a vector is a form of compound construction.
                // First, reshape the matrix into a 4-slot vector of the same type.
                const Type& vectorType = argument->type().componentType().toCompound(context,
                                                                                     /*columns=*/4,
                                                                                     /*rows=*/1);
                std::unique_ptr<Expression> vecCtor =
                        ConstructorCompound::Make(context, pos, vectorType, std::move(args));
 
                // Then, add a typecast to the result expression to ensure the types match.
                // This will be a no-op if no typecasting is needed.
                return ConstructorCompoundCast::Make(context, pos, type, std::move(vecCtor));
            }
        }
    }
 
    // For more complex cases, we walk the argument list and fix up the arguments as needed.
    int expected = type.rows() * type.columns();
    int actual = 0;
    for (std::unique_ptr<Expression>& arg : args) {
        if (!arg->type().isScalar() && !arg->type().isVector()) {
            context.fErrors->error(pos, "'" + arg->type().displayName() +
                    "' is not a valid parameter to '" + type.displayName() + "' constructor");
            return nullptr;
        }
 
        // Rely on Constructor::Convert to force this subexpression to the proper type. If it's a
        // literal, this will make sure it's the right type of literal. If an expression of matching
        // type, the expression will be returned as-is. If it's an expression of mismatched type,
        // this adds a cast.
        const Type& ctorType = type.componentType().toCompound(context, arg->type().columns(),
                                                               /*rows=*/1);
        ExpressionArray ctorArg;
        ctorArg.push_back(std::move(arg));
        arg = Constructor::Convert(context, pos, ctorType, std::move(ctorArg));
        if (!arg) {
            return nullptr;
        }
        actual += ctorType.columns();
    }
 
    if (actual != expected) {
        context.fErrors->error(pos, "invalid arguments to '" + type.displayName() +
                                     "' constructor (expected " + std::to_string(expected) +
                                     " scalars, but found " + std::to_string(actual) + ")");
        return nullptr;
    }
 
    return ConstructorCompound::Make(context, pos, type, std::move(args));
}

◆ count_returns_at_end_of_control_flow()

static int SkSL::count_returns_at_end_of_control_flow ( const FunctionDefinition & funcDef )

static

Definition at line 23 of file SkSLGetReturnComplexity.cpp.

                                                                                   {
    class CountReturnsAtEndOfControlFlow : public ProgramVisitor {
    public:
        CountReturnsAtEndOfControlFlow(const FunctionDefinition& funcDef) {
            this->visitProgramElement(funcDef);
        }
 
        bool visitExpression(const Expression& expr) override {
            // Do not recurse into expressions.
            return false;
        }
 
        bool visitStatement(const Statement& stmt) override {
            switch (stmt.kind()) {
                case Statement::Kind::kBlock: {
                    // Check only the last statement of a block.
                    const auto& block = stmt.as<Block>();
                    return block.children().size() &&
                           this->visitStatement(*block.children().back());
                }
                case Statement::Kind::kSwitch:
                case Statement::Kind::kDo:
                case Statement::Kind::kFor:
                    // Don't introspect switches or loop structures at all.
                    return false;
 
                case Statement::Kind::kReturn:
                    ++fNumReturns;
                    [[fallthrough]];
 
                default:
                    return INHERITED::visitStatement(stmt);
            }
        }
 
        int fNumReturns = 0;
        using INHERITED = ProgramVisitor;
    };
 
    return CountReturnsAtEndOfControlFlow{funcDef}.fNumReturns;
}

◆ dead_function_predicate()

static bool SkSL::dead_function_predicate	(	const ProgramElement *	element,
		ProgramUsage *	usage
	)

static

Definition at line 25 of file SkSLEliminateDeadFunctions.cpp.

                                                                                        {
    if (!element->is<FunctionDefinition>()) {
        return false;
    }
    const FunctionDefinition& fn = element->as<FunctionDefinition>();
    if (fn.declaration().isMain() || usage->get(fn.declaration()) > 0) {
        return false;
    }
    // This function is about to be eliminated by remove_if; update ProgramUsage accordingly.
    usage->remove(*element);
    return true;
}

◆ eliminate_dead_local_variables()

static bool SkSL::eliminate_dead_local_variables	(	const Context &	context,
		SkSpan< std::unique_ptr< ProgramElement > >	elements,
		ProgramUsage *	usage
	)

static

Definition at line 39 of file SkSLEliminateDeadLocalVariables.cpp.

                                                                {
    class DeadLocalVariableEliminator : public ProgramWriter {
    public:
        DeadLocalVariableEliminator(const Context& context, ProgramUsage* usage)
                : fContext(context)
                , fUsage(usage) {}
 
        using ProgramWriter::visitProgramElement;
 
        bool visitExpressionPtr(std::unique_ptr<Expression>& expr) override {
            if (expr->is<BinaryExpression>()) {
                // Search for expressions of the form `deadVar = anyExpression`.
                BinaryExpression& binary = expr->as<BinaryExpression>();
                if (VariableReference* assignedVar = binary.isAssignmentIntoVariable()) {
                    if (fDeadVariables.contains(assignedVar->variable())) {
                        // Replace `deadVar = anyExpression` with `anyExpression`.
                        fUsage->remove(expr.get());
                        expr = std::move(binary.right());
                        fUsage->add(expr.get());
 
                        // If `anyExpression` is now a lone ExpressionStatement, it's highly likely
                        // that we can eliminate it entirely. This flag will let us know to check.
                        fAssignmentWasEliminated = true;
 
                        // Re-process the newly cleaned-up expression. This lets us fully clean up
                        // gnarly assignments like `a = b = 123;` where both `a` and `b` are dead,
                        // or silly double-assignments like `a = a = 123;`.
                        return this->visitExpressionPtr(expr);
                    }
                }
            }
            if (expr->is<VariableReference>()) {
                SkASSERT(!fDeadVariables.contains(expr->as<VariableReference>().variable()));
            }
            return INHERITED::visitExpressionPtr(expr);
        }
 
        bool visitStatementPtr(std::unique_ptr<Statement>& stmt) override {
            if (stmt->is<VarDeclaration>()) {
                VarDeclaration& varDecl = stmt->as<VarDeclaration>();
                const Variable* var = varDecl.var();
                ProgramUsage::VariableCounts* counts = fUsage->fVariableCounts.find(var);
                SkASSERT(counts);
                SkASSERT(counts->fVarExists);
                if (CanEliminate(var, *counts)) {
                    fDeadVariables.add(var);
                    if (var->initialValue()) {
                        // The variable has an initial-value expression, which might have side
                        // effects. ExpressionStatement::Make will preserve side effects, but
                        // replaces pure expressions with Nop.
                        fUsage->remove(stmt.get());
                        stmt = ExpressionStatement::Make(fContext, std::move(varDecl.value()));
                        fUsage->add(stmt.get());
                    } else {
                        // The variable has no initial-value and can be cleanly eliminated.
                        fUsage->remove(stmt.get());
                        stmt = Nop::Make();
                    }
                    fMadeChanges = true;
 
                    // Re-process the newly cleaned-up statement. This lets us fully clean up
                    // gnarly assignments like `a = b = 123;` where both `a` and `b` are dead,
                    // or silly double-assignments like `a = a = 123;`.
                    return this->visitStatementPtr(stmt);
                }
            }
 
            bool result = INHERITED::visitStatementPtr(stmt);
 
            // If we eliminated an assignment above, we may have left behind an inert
            // ExpressionStatement.
            if (fAssignmentWasEliminated) {
                fAssignmentWasEliminated = false;
                if (stmt->is<ExpressionStatement>()) {
                    ExpressionStatement& exprStmt = stmt->as<ExpressionStatement>();
                    if (!Analysis::HasSideEffects(*exprStmt.expression())) {
                        // The expression-statement was inert; eliminate it entirely.
                        fUsage->remove(&exprStmt);
                        stmt = Nop::Make();
                    }
                }
            }
 
            return result;
        }
 
        static bool CanEliminate(const Variable* var, const ProgramUsage::VariableCounts& counts) {
            return counts.fVarExists && !counts.fRead && var->storage() == VariableStorage::kLocal;
        }
 
        bool fMadeChanges = false;
        const Context& fContext;
        ProgramUsage* fUsage;
        THashSet<const Variable*> fDeadVariables;
        bool fAssignmentWasEliminated = false;
 
        using INHERITED = ProgramWriter;
    };
 
    DeadLocalVariableEliminator visitor{context, usage};
 
    for (auto& [var, counts] : usage->fVariableCounts) {
        if (DeadLocalVariableEliminator::CanEliminate(var, counts)) {
            // This program contains at least one dead local variable.
            // Scan the program for any dead local variables and eliminate them all.
            for (std::unique_ptr<ProgramElement>& pe : elements) {
                if (pe->is<FunctionDefinition>()) {
                    visitor.visitProgramElement(*pe);
                }
            }
            break;
        }
    }
 
    return visitor.fMadeChanges;
}

◆ eliminate_empty_statements()

static void SkSL::eliminate_empty_statements ( SkSpan< std::unique_ptr< ProgramElement > > elements )

static

Definition at line 27 of file SkSLEliminateEmptyStatements.cpp.

                                                                                       {
    class EmptyStatementEliminator : public ProgramWriter {
    public:
        bool visitExpressionPtr(std::unique_ptr<Expression>& expr) override {
            // We don't need to look inside expressions at all.
            return false;
        }
 
        bool visitStatementPtr(std::unique_ptr<Statement>& stmt) override {
            // Work from the innermost blocks to the outermost.
            INHERITED::visitStatementPtr(stmt);
 
            if (stmt->is<Block>()) {
                StatementArray& children = stmt->as<Block>().children();
                auto iter = std::remove_if(children.begin(), children.end(),
                                           [](std::unique_ptr<Statement>& stmt) {
                                               return stmt->isEmpty();
                                           });
                children.resize(std::distance(children.begin(), iter));
            }
 
            // We always check the entire program.
            return false;
        }
 
        using INHERITED = ProgramWriter;
    };
 
    for (std::unique_ptr<ProgramElement>& pe : elements) {
        if (pe->is<FunctionDefinition>()) {
            EmptyStatementEliminator visitor;
            visitor.visitStatementPtr(pe->as<FunctionDefinition>().body());
        }
    }
}

◆ eliminate_no_op_boolean()

static std::unique_ptr< Expression > SkSL::eliminate_no_op_boolean	(	Position	pos,
		const Expression &	left,
		Operator	op,
		const Expression &	right
	)

static

Definition at line 52 of file SkSLConstantFolder.cpp.

                                                                                    {
    bool rightVal = right.as<Literal>().boolValue();
 
    // Detect no-op Boolean expressions and optimize them away.
    if ((op.kind() == Operator::Kind::LOGICALAND && rightVal)  ||  // (expr && true)  -> (expr)
        (op.kind() == Operator::Kind::LOGICALOR  && !rightVal) ||  // (expr || false) -> (expr)
        (op.kind() == Operator::Kind::LOGICALXOR && !rightVal) ||  // (expr ^^ false) -> (expr)
        (op.kind() == Operator::Kind::EQEQ       && rightVal)  ||  // (expr == true)  -> (expr)
        (op.kind() == Operator::Kind::NEQ        && !rightVal)) {  // (expr != false) -> (expr)
 
        return left.clone(pos);
    }
 
    return nullptr;
}

◆ eliminate_unnecessary_braces()

static void SkSL::eliminate_unnecessary_braces ( SkSpan< std::unique_ptr< ProgramElement > > elements )

static

Definition at line 31 of file SkSLEliminateUnnecessaryBraces.cpp.

                                                                                         {
    class UnnecessaryBraceEliminator : public ProgramWriter {
    public:
        bool visitExpressionPtr(std::unique_ptr<Expression>& expr) override {
            // We don't need to look inside expressions at all.
            return false;
        }
 
        bool visitStatementPtr(std::unique_ptr<Statement>& stmt) override {
            // Work from the innermost blocks to the outermost.
            INHERITED::visitStatementPtr(stmt);
 
            switch (stmt->kind()) {
                case StatementKind::kIf: {
                    IfStatement& ifStmt = stmt->as<IfStatement>();
                    EliminateBracesFrom(ifStmt.ifTrue());
                    EliminateBracesFrom(ifStmt.ifFalse());
                    break;
                }
                case StatementKind::kFor: {
                    ForStatement& forStmt = stmt->as<ForStatement>();
                    EliminateBracesFrom(forStmt.statement());
                    break;
                }
                case StatementKind::kDo: {
                    DoStatement& doStmt = stmt->as<DoStatement>();
                    EliminateBracesFrom(doStmt.statement());
                    break;
                }
                default:
                    break;
            }
 
            // We always check the entire program.
            return false;
        }
 
        static void EliminateBracesFrom(std::unique_ptr<Statement>& stmt) {
            if (!stmt || !stmt->is<Block>()) {
                return;
            }
            Block& block = stmt->as<Block>();
            std::unique_ptr<Statement>* usefulStmt = nullptr;
            for (std::unique_ptr<Statement>& childStmt : block.children()) {
                if (childStmt->isEmpty()) {
                    continue;
                }
                if (usefulStmt) {
                    // We found two non-empty statements. We can't eliminate braces from
                    // this block.
                    return;
                }
                // We found one non-empty statement.
                usefulStmt = &childStmt;
            }
 
            if (!usefulStmt) {
                // This block held zero useful statements. Replace the block with a nop.
                stmt = Nop::Make();
            } else {
                // This block held one useful statement. Replace the block with that statement.
                stmt = std::move(*usefulStmt);
            }
        }
 
        using INHERITED = ProgramWriter;
    };
 
    for (std::unique_ptr<ProgramElement>& pe : elements) {
        if (pe->is<FunctionDefinition>()) {
            UnnecessaryBraceEliminator visitor;
            visitor.visitStatementPtr(pe->as<FunctionDefinition>().body());
        }
    }
}

◆ eliminate_unreachable_code()

static void SkSL::eliminate_unreachable_code	(	SkSpan< std::unique_ptr< ProgramElement > >	elements,
		ProgramUsage *	usage
	)

static

Definition at line 35 of file SkSLEliminateUnreachableCode.cpp.

                                                            {
    class UnreachableCodeEliminator : public ProgramWriter {
    public:
        UnreachableCodeEliminator(ProgramUsage* usage) : fUsage(usage) {
            fFoundFunctionExit.push_back(false);
            fFoundBlockExit.push_back(false);
        }
 
        bool visitExpressionPtr(std::unique_ptr<Expression>& expr) override {
            // We don't need to look inside expressions at all.
            return false;
        }
 
        bool visitStatementPtr(std::unique_ptr<Statement>& stmt) override {
            if (fFoundFunctionExit.back() || fFoundBlockExit.back()) {
                // If we already found an exit in this section, anything beyond it is dead code.
                if (!stmt->is<Nop>()) {
                    // Eliminate the dead statement by substituting a Nop.
                    fUsage->remove(stmt.get());
                    stmt = Nop::Make();
                }
                return false;
            }
 
            switch (stmt->kind()) {
                case Statement::Kind::kReturn:
                case Statement::Kind::kDiscard:
                    // We found a function exit on this path.
                    fFoundFunctionExit.back() = true;
                    break;
 
                case Statement::Kind::kBreak:
                    // A `break` statement can either be breaking out of a loop or terminating an
                    // individual switch case. We treat both cases the same way: they only apply
                    // to the statements associated with the parent statement (i.e. enclosing loop
                    // block / preceding case label).
                case Statement::Kind::kContinue:
                    fFoundBlockExit.back() = true;
                    break;
 
                case Statement::Kind::kExpression:
                case Statement::Kind::kNop:
                case Statement::Kind::kVarDeclaration:
                    // These statements don't affect control flow.
                    break;
 
                case Statement::Kind::kBlock:
                    // Blocks are on the straight-line path and don't affect control flow.
                    return INHERITED::visitStatementPtr(stmt);
 
                case Statement::Kind::kDo: {
                    // Function-exits are allowed to propagate outside of a do-loop, because it
                    // always executes its body at least once.
                    fFoundBlockExit.push_back(false);
                    bool result = INHERITED::visitStatementPtr(stmt);
                    fFoundBlockExit.pop_back();
                    return result;
                }
                case Statement::Kind::kFor: {
                    // Function-exits are not allowed to propagate out, because a for-loop or while-
                    // loop could potentially run zero times.
                    fFoundFunctionExit.push_back(false);
                    fFoundBlockExit.push_back(false);
                    bool result = INHERITED::visitStatementPtr(stmt);
                    fFoundBlockExit.pop_back();
                    fFoundFunctionExit.pop_back();
                    return result;
                }
                case Statement::Kind::kIf: {
                    // This statement is conditional and encloses two inner sections of code.
                    // If both sides contain a function-exit or loop-exit, that exit is allowed to
                    // propagate out.
                    IfStatement& ifStmt = stmt->as<IfStatement>();
 
                    fFoundFunctionExit.push_back(false);
                    fFoundBlockExit.push_back(false);
                    bool result = (ifStmt.ifTrue() && this->visitStatementPtr(ifStmt.ifTrue()));
                    bool foundFunctionExitOnTrue = fFoundFunctionExit.back();
                    bool foundLoopExitOnTrue = fFoundBlockExit.back();
                    fFoundFunctionExit.pop_back();
                    fFoundBlockExit.pop_back();
 
                    fFoundFunctionExit.push_back(false);
                    fFoundBlockExit.push_back(false);
                    result |= (ifStmt.ifFalse() && this->visitStatementPtr(ifStmt.ifFalse()));
                    bool foundFunctionExitOnFalse = fFoundFunctionExit.back();
                    bool foundLoopExitOnFalse = fFoundBlockExit.back();
                    fFoundFunctionExit.pop_back();
                    fFoundBlockExit.pop_back();
 
                    fFoundFunctionExit.back() |= foundFunctionExitOnTrue &&
                                                 foundFunctionExitOnFalse;
                    fFoundBlockExit.back() |= foundLoopExitOnTrue &&
                                              foundLoopExitOnFalse;
                    return result;
                }
                case Statement::Kind::kSwitch: {
                    // In switch statements we consider unreachable code on a per-case basis.
                    SwitchStatement& sw = stmt->as<SwitchStatement>();
                    bool result = false;
 
                    // Tracks whether we found at least one case that doesn't lead to a return
                    // statement (potentially via fallthrough).
                    bool foundCaseWithoutReturn = false;
                    bool hasDefault = false;
                    for (std::unique_ptr<Statement>& c : sw.cases()) {
                        // We eliminate unreachable code within the statements of the individual
                        // case. Breaks are not allowed to propagate outside the case statement
                        // itself. Function returns are allowed to propagate out only if all cases
                        // have a return AND one of the cases is default (so that we know at least
                        // one of the branches will be taken). This is similar to how we handle if
                        // statements above.
                        fFoundFunctionExit.push_back(false);
                        fFoundBlockExit.push_back(false);
 
                        SwitchCase& sc = c->as<SwitchCase>();
                        result |= this->visitStatementPtr(sc.statement());
 
                        // When considering whether a case has a return we can propagate, we
                        // assume the following:
                        //     1. The default case is always placed last in a switch statement and
                        //        it is the last possible label reachable via fallthrough. Thus if
                        //        it does not contain a return statement, then we don't propagate a
                        //        function return.
                        //     2. In all other cases we prevent the return from propagating only if
                        //        we encounter a break statement. If no return or break is found,
                        //        we defer the decision to the fallthrough case. We won't propagate
                        //        a return unless we eventually encounter a default label.
                        //
                        // See resources/sksl/shared/SwitchWithEarlyReturn.sksl for test cases that
                        // exercise this.
                        if (sc.isDefault()) {
                            foundCaseWithoutReturn |= !fFoundFunctionExit.back();
                            hasDefault = true;
                        } else {
                            // We can only be sure that a case does not lead to a return if it
                            // doesn't fallthrough.
                            foundCaseWithoutReturn |=
                                    (!fFoundFunctionExit.back() && fFoundBlockExit.back());
                        }
 
                        fFoundFunctionExit.pop_back();
                        fFoundBlockExit.pop_back();
                    }
 
                    fFoundFunctionExit.back() |= !foundCaseWithoutReturn && hasDefault;
                    return result;
                }
                case Statement::Kind::kSwitchCase:
                    // We should never hit this case as switch cases are handled in the previous
                    // case.
                    SkUNREACHABLE;
            }
 
            return false;
        }
 
        ProgramUsage* fUsage;
        STArray<32, bool> fFoundFunctionExit;
        STArray<32, bool> fFoundBlockExit;
 
        using INHERITED = ProgramWriter;
    };
 
    for (std::unique_ptr<ProgramElement>& pe : elements) {
        if (pe->is<FunctionDefinition>()) {
            UnreachableCodeEliminator visitor{usage};
            visitor.visitStatementPtr(pe->as<FunctionDefinition>().body());
        }
    }
}

◆ error_on_divide_by_zero()

static bool SkSL::error_on_divide_by_zero	(	const Context &	context,
		Position	pos,
		Operator	op,
		const Expression &	right
	)

static

Definition at line 423 of file SkSLConstantFolder.cpp.

                                                             {
    switch (op.kind()) {
        case Operator::Kind::SLASH:
        case Operator::Kind::SLASHEQ:
        case Operator::Kind::PERCENT:
        case Operator::Kind::PERCENTEQ:
            if (contains_constant_zero(right)) {
                context.fErrors->error(pos, "division by zero");
                return true;
            }
            return false;
        default:
            return false;
    }
}

◆ evaluate_3_way_intrinsic()

static std::unique_ptr< Expression > SkSL::evaluate_3_way_intrinsic	(	const Context &	context,
		const IntrinsicArguments &	arguments,
		const Type &	returnType,
		EvaluateFn	eval
	)

static

Definition at line 319 of file SkSLFunctionCall.cpp.

                                                                             {
    SkASSERT(arguments[0]);
    SkASSERT(arguments[1]);
    SkASSERT(arguments[2]);
    const Type& type = arguments[0]->type().componentType();
 
    if (type.isFloat()) {
        type_check_expression<float>(*arguments[0]);
        type_check_expression<float>(*arguments[1]);
        type_check_expression<float>(*arguments[2]);
    } else if (type.isInteger()) {
        type_check_expression<SKSL_INT>(*arguments[0]);
        type_check_expression<SKSL_INT>(*arguments[1]);
        type_check_expression<SKSL_INT>(*arguments[2]);
    } else {
        SkDEBUGFAILF("unsupported type %s", type.description().c_str());
        return nullptr;
    }
 
    return evaluate_n_way_intrinsic(context, arguments[0], arguments[1], arguments[2],
                                    returnType, eval);
}

◆ evaluate_intrinsic()

template<typename T >

static std::unique_ptr< Expression > SkSL::evaluate_intrinsic	(	const Context &	context,
		const IntrinsicArguments &	arguments,
		const Type &	returnType,
		EvaluateFn	eval
	)

static

Definition at line 264 of file SkSLFunctionCall.cpp.

                                                                       {
    SkASSERT(arguments[0]);
    SkASSERT(!arguments[1]);
    type_check_expression<T>(*arguments[0]);
 
    return evaluate_n_way_intrinsic(context, arguments[0], /*arg1=*/nullptr, /*arg2=*/nullptr,
                                    returnType, eval);
}

◆ evaluate_intrinsic_numeric()

static std::unique_ptr< Expression > SkSL::evaluate_intrinsic_numeric	(	const Context &	context,
		const IntrinsicArguments &	arguments,
		const Type &	returnType,
		EvaluateFn	eval
	)

static

Definition at line 276 of file SkSLFunctionCall.cpp.

                                                                               {
    SkASSERT(arguments[0]);
    SkASSERT(!arguments[1]);
    const Type& type = arguments[0]->type().componentType();
 
    if (type.isFloat()) {
        return evaluate_intrinsic<float>(context, arguments, returnType, eval);
    }
    if (type.isInteger()) {
        return evaluate_intrinsic<SKSL_INT>(context, arguments, returnType, eval);
    }
 
    SkDEBUGFAILF("unsupported type %s", type.description().c_str());
    return nullptr;
}

◆ evaluate_n_way_intrinsic()

static std::unique_ptr< Expression > SkSL::evaluate_n_way_intrinsic	(	const Context &	context,
		const Expression *	arg0,
		const Expression *	arg1,
		const Expression *	arg2,
		const Type &	returnType,
		EvaluateFn	eval
	)

static

Definition at line 206 of file SkSLFunctionCall.cpp.

                                                                             {
    // Takes up to three arguments and evaluates all of them, left-to-right, in tandem.
    // Equivalent to constructing a new compound value containing the results from:
    //     eval(arg0.x, arg1.x, arg2.x),
    //     eval(arg0.y, arg1.y, arg2.y),
    //     eval(arg0.z, arg1.z, arg2.z),
    //     eval(arg0.w, arg1.w, arg2.w)
    //
    // If an argument is null, zero is passed to the evaluation function. If the arguments are a mix
    // of scalars and compounds, scalars are interpreted as a compound containing the same value for
    // every component.
 
    double minimumValue = returnType.componentType().minimumValue();
    double maximumValue = returnType.componentType().maximumValue();
    int slots = returnType.slotCount();
    double array[16];
 
    int arg0Index = 0;
    int arg1Index = 0;
    int arg2Index = 0;
    for (int index = 0; index < slots; ++index) {
        std::optional<double> arg0Value = arg0->getConstantValue(arg0Index);
        arg0Index += arg0->type().isScalar() ? 0 : 1;
        SkASSERT(arg0Value.has_value());
 
        std::optional<double> arg1Value = 0.0;
        if (arg1) {
            arg1Value = arg1->getConstantValue(arg1Index);
            arg1Index += arg1->type().isScalar() ? 0 : 1;
            SkASSERT(arg1Value.has_value());
        }
 
        std::optional<double> arg2Value = 0.0;
        if (arg2) {
            arg2Value = arg2->getConstantValue(arg2Index);
            arg2Index += arg2->type().isScalar() ? 0 : 1;
            SkASSERT(arg2Value.has_value());
        }
 
        array[index] = eval(*arg0Value, *arg1Value, *arg2Value);
 
        if (array[index] >= minimumValue && array[index] <= maximumValue) {
            // This result will fit inside the return type.
        } else {
            // The value is outside the float range or is NaN (all if-checks fail); do not optimize.
            return nullptr;
        }
    }
 
    return ConstructorCompound::MakeFromConstants(context, arg0->fPosition, returnType, array);
}

◆ evaluate_pairwise_intrinsic()

static std::unique_ptr< Expression > SkSL::evaluate_pairwise_intrinsic	(	const Context &	context,
		const IntrinsicArguments &	arguments,
		const Type &	returnType,
		EvaluateFn	eval
	)

static

Definition at line 295 of file SkSLFunctionCall.cpp.

                                                                                {
    SkASSERT(arguments[0]);
    SkASSERT(arguments[1]);
    SkASSERT(!arguments[2]);
    const Type& type = arguments[0]->type().componentType();
 
    if (type.isFloat()) {
        type_check_expression<float>(*arguments[0]);
        type_check_expression<float>(*arguments[1]);
    } else if (type.isInteger()) {
        type_check_expression<SKSL_INT>(*arguments[0]);
        type_check_expression<SKSL_INT>(*arguments[1]);
    } else {
        SkDEBUGFAILF("unsupported type %s", type.description().c_str());
        return nullptr;
    }
 
    return evaluate_n_way_intrinsic(context, arguments[0], arguments[1], /*arg2=*/nullptr,
                                    returnType, eval);
}

◆ extract_field()

static std::unique_ptr< Expression > SkSL::extract_field	(	Position	pos,
		const ConstructorStruct &	ctor,
		int	fieldIndex
	)

static

Definition at line 65 of file SkSLFieldAccess.cpp.

                                                                 {
    // Confirm that the fields that are being removed are side-effect free.
    const ExpressionArray& args = ctor.arguments();
    int numFields = args.size();
    for (int index = 0; index < numFields; ++index) {
        if (fieldIndex == index) {
            continue;
        }
        if (Analysis::HasSideEffects(*args[index])) {
            return nullptr;
        }
    }
 
    // Return the desired field.
    return args[fieldIndex]->clone(pos);
}

◆ extract_matrix()

static void SkSL::extract_matrix	(	const Expression *	expr,
		float	mat[16]
	)

static

Definition at line 628 of file SkSLFunctionCall.cpp.

                                                                  {
    size_t numSlots = expr->type().slotCount();
    for (size_t index = 0; index < numSlots; ++index) {
        mat[index] = *expr->getConstantValue(index);
    }
}

◆ find_duplicate_case_values()

static TArray< const SwitchCase * > SkSL::find_duplicate_case_values ( const StatementArray & cases )

static

Definition at line 40 of file SkSLSwitchStatement.cpp.

                                                                                         {
    TArray<const SwitchCase*> duplicateCases;
    THashSet<SKSL_INT> intValues;
    bool foundDefault = false;
 
    for (const std::unique_ptr<Statement>& stmt : cases) {
        const SwitchCase* sc = &stmt->as<SwitchCase>();
        if (sc->isDefault()) {
            if (foundDefault) {
                duplicateCases.push_back(sc);
                continue;
            }
            foundDefault = true;
        } else {
            SKSL_INT value = sc->value();
            if (intValues.contains(value)) {
                duplicateCases.push_back(sc);
                continue;
            }
            intValues.add(value);
        }
    }
 
    return duplicateCases;
}

◆ find_existing_declaration()

static bool SkSL::find_existing_declaration	(	const Context &	context,
		Position	pos,
		ModifierFlags	modifierFlags,
		IntrinsicKind	intrinsicKind,
		std::string_view	name,
		TArray< std::unique_ptr< Variable > > &	parameters,
		Position	returnTypePos,
		const Type *	returnType,
		FunctionDeclaration **	outExistingDecl
	)

static

Checks for a previously existing declaration of this function, reporting errors if there is an incompatible symbol. Returns true and sets outExistingDecl to point to the existing declaration (or null if none) on success, returns false on error.

Definition at line 346 of file SkSLFunctionDeclaration.cpp.

                                                                             {
    auto invalidDeclDescription = [&]() -> std::string {
        TArray<Variable*> paramPtrs;
        paramPtrs.reserve_exact(parameters.size());
        for (std::unique_ptr<Variable>& param : parameters) {
            paramPtrs.push_back(param.get());
        }
        return FunctionDeclaration(context,
                                   pos,
                                   modifierFlags,
                                   name,
                                   std::move(paramPtrs),
                                   returnType,
                                   intrinsicKind)
                .description();
    };
 
    ErrorReporter& errors = *context.fErrors;
    Symbol* entry = context.fSymbolTable->findMutable(name);
    *outExistingDecl = nullptr;
    if (entry) {
        if (!entry->is<FunctionDeclaration>()) {
            errors.error(pos, "symbol '" + std::string(name) + "' was already defined");
            return false;
        }
        for (FunctionDeclaration* other = &entry->as<FunctionDeclaration>(); other;
             other = other->mutableNextOverload()) {
            SkASSERT(name == other->name());
            if (!parameters_match(parameters, other->parameters())) {
                continue;
            }
            if (!type_generically_matches(*returnType, other->returnType())) {
                errors.error(returnTypePos, "functions '" + invalidDeclDescription() + "' and '" +
                                            other->description() + "' differ only in return type");
                return false;
            }
            for (int i = 0; i < parameters.size(); i++) {
                if (parameters[i]->modifierFlags() != other->parameters()[i]->modifierFlags() ||
                    parameters[i]->layout() != other->parameters()[i]->layout()) {
                    errors.error(parameters[i]->fPosition,
                                 "modifiers on parameter " + std::to_string(i + 1) +
                                 " differ between declaration and definition");
                    return false;
                }
            }
            if (other->definition() || other->isIntrinsic() ||
                modifierFlags != other->modifierFlags()) {
                errors.error(pos, "duplicate definition of '" + invalidDeclDescription() + "'");
                return false;
            }
            *outExistingDecl = other;
            break;
        }
        if (!*outExistingDecl && entry->as<FunctionDeclaration>().isMain()) {
            errors.error(pos, "duplicate definition of 'main'");
            return false;
        }
    }
    return true;
}

◆ find_generic_index()

static int SkSL::find_generic_index	(	const Type &	concreteType,
		const Type &	genericType,
		bool	allowNarrowing
	)

static

Given a concrete type (float3) and a generic type ($genType), returns the index of the concrete type within the generic type's typelist. Returns -1 if there is no match.

Definition at line 270 of file SkSLFunctionDeclaration.cpp.

                                                   {
    SkSpan<const Type* const> genericTypes = genericType.coercibleTypes();
    for (size_t index = 0; index < genericTypes.size(); ++index) {
        if (concreteType.canCoerceTo(*genericTypes[index], allowNarrowing)) {
            return index;
        }
    }
    return -1;
}

◆ find_rt_adjust_index()

static std::optional< int > SkSL::find_rt_adjust_index ( SkSpan< const Field > fields )

static

Definition at line 41 of file SkSLInterfaceBlock.cpp.

                                                                         {
    for (size_t index = 0; index < fields.size(); ++index) {
        const SkSL::Field& f = fields[index];
        if (f.fName == SkSL::Compiler::RTADJUST_NAME) {
            return index;
        }
    }
 
    return std::nullopt;
}

◆ FindIntrinsicKind()

IntrinsicKind SkSL::FindIntrinsicKind ( std::string_view functionName )

Definition at line 26 of file SkSLIntrinsicList.cpp.

                                                             {
    if (skstd::starts_with(functionName, '$')) {
        functionName.remove_prefix(1);
    }
 
    const IntrinsicMap& intrinsicMap = GetIntrinsicMap();
    IntrinsicKind* kind = intrinsicMap.find(functionName);
    return kind ? *kind : kNotIntrinsic;
}

◆ fold_expression()

static std::unique_ptr< Expression > SkSL::fold_expression	(	Position	pos,
		double	result,
		const Type *	resultType
	)

static

Definition at line 653 of file SkSLConstantFolder.cpp.

                                                                           {
    if (resultType->isNumber()) {
        if (result >= resultType->minimumValue() && result <= resultType->maximumValue()) {
            // This result will fit inside its type.
        } else {
            // The value is outside the range or is NaN (all if-checks fail); do not optimize.
            return nullptr;
        }
    }
 
    return Literal::Make(pos, result, resultType);
}

◆ fold_two_constants()

static std::unique_ptr< Expression > SkSL::fold_two_constants	(	const Context &	context,
		Position	pos,
		const Expression *	left,
		Operator	op,
		const Expression *	right,
		const Type &	resultType
	)

static

Definition at line 668 of file SkSLConstantFolder.cpp.

                                                                              {
    SkASSERT(Analysis::IsCompileTimeConstant(*left));
    SkASSERT(Analysis::IsCompileTimeConstant(*right));
    const Type& leftType = left->type();
    const Type& rightType = right->type();
 
    // Handle pairs of integer literals.
    if (left->isIntLiteral() && right->isIntLiteral()) {
        using SKSL_UINT = uint64_t;
        SKSL_INT leftVal  = left->as<Literal>().intValue();
        SKSL_INT rightVal = right->as<Literal>().intValue();
 
        // Note that fold_expression returns null if the result would overflow its type.
        #define RESULT(Op)   fold_expression(pos, (SKSL_INT)(leftVal) Op \
                                                  (SKSL_INT)(rightVal), &resultType)
        #define URESULT(Op)  fold_expression(pos, (SKSL_INT)((SKSL_UINT)(leftVal) Op \
                                                  (SKSL_UINT)(rightVal)), &resultType)
        switch (op.kind()) {
            case Operator::Kind::PLUS:       return URESULT(+);
            case Operator::Kind::MINUS:      return URESULT(-);
            case Operator::Kind::STAR:       return URESULT(*);
            case Operator::Kind::SLASH:
                if (leftVal == std::numeric_limits<SKSL_INT>::min() && rightVal == -1) {
                    context.fErrors->error(pos, "arithmetic overflow");
                    return nullptr;
                }
                return RESULT(/);
 
            case Operator::Kind::PERCENT:
                if (leftVal == std::numeric_limits<SKSL_INT>::min() && rightVal == -1) {
                    context.fErrors->error(pos, "arithmetic overflow");
                    return nullptr;
                }
                return RESULT(%);
 
            case Operator::Kind::BITWISEAND: return RESULT(&);
            case Operator::Kind::BITWISEOR:  return RESULT(|);
            case Operator::Kind::BITWISEXOR: return RESULT(^);
            case Operator::Kind::EQEQ:       return RESULT(==);
            case Operator::Kind::NEQ:        return RESULT(!=);
            case Operator::Kind::GT:         return RESULT(>);
            case Operator::Kind::GTEQ:       return RESULT(>=);
            case Operator::Kind::LT:         return RESULT(<);
            case Operator::Kind::LTEQ:       return RESULT(<=);
            case Operator::Kind::SHL:
                if (rightVal >= 0 && rightVal <= 31) {
                    // Left-shifting a negative (or really, any signed) value is undefined behavior
                    // in C++, but not in GLSL. Do the shift on unsigned values to avoid triggering
                    // an UBSAN error.
                    return URESULT(<<);
                }
                context.fErrors->error(pos, "shift value out of range");
                return nullptr;
 
            case Operator::Kind::SHR:
                if (rightVal >= 0 && rightVal <= 31) {
                    return RESULT(>>);
                }
                context.fErrors->error(pos, "shift value out of range");
                return nullptr;
 
            default:
                break;
        }
        #undef RESULT
        #undef URESULT
 
        return nullptr;
    }
 
    // Handle pairs of floating-point literals.
    if (left->isFloatLiteral() && right->isFloatLiteral()) {
        SKSL_FLOAT leftVal  = left->as<Literal>().floatValue();
        SKSL_FLOAT rightVal = right->as<Literal>().floatValue();
 
        #define RESULT(Op) fold_expression(pos, leftVal Op rightVal, &resultType)
        switch (op.kind()) {
            case Operator::Kind::PLUS:  return RESULT(+);
            case Operator::Kind::MINUS: return RESULT(-);
            case Operator::Kind::STAR:  return RESULT(*);
            case Operator::Kind::SLASH: return RESULT(/);
            case Operator::Kind::EQEQ:  return RESULT(==);
            case Operator::Kind::NEQ:   return RESULT(!=);
            case Operator::Kind::GT:    return RESULT(>);
            case Operator::Kind::GTEQ:  return RESULT(>=);
            case Operator::Kind::LT:    return RESULT(<);
            case Operator::Kind::LTEQ:  return RESULT(<=);
            default:                    break;
        }
        #undef RESULT
 
        return nullptr;
    }
 
    // Perform matrix multiplication.
    if (op.kind() == Operator::Kind::STAR) {
        if (leftType.isMatrix() && rightType.isMatrix()) {
            return simplify_matrix_times_matrix(context, pos, *left, *right);
        }
        if (leftType.isVector() && rightType.isMatrix()) {
            return simplify_vector_times_matrix(context, pos, *left, *right);
        }
        if (leftType.isMatrix() && rightType.isVector()) {
            return simplify_matrix_times_vector(context, pos, *left, *right);
        }
    }
 
    // Perform constant folding on pairs of vectors/matrices.
    if (is_vec_or_mat(leftType) && leftType.matches(rightType)) {
        return simplify_componentwise(context, pos, *left, op, *right);
    }
 
    // Perform constant folding on vectors/matrices against scalars, e.g.: half4(2) + 2
    if (rightType.isScalar() && is_vec_or_mat(leftType) &&
        leftType.componentType().matches(rightType)) {
        return simplify_componentwise(context, pos,
                                      *left, op, *splat_scalar(context, *right, left->type()));
    }
 
    // Perform constant folding on scalars against vectors/matrices, e.g.: 2 + half4(2)
    if (leftType.isScalar() && is_vec_or_mat(rightType) &&
        rightType.componentType().matches(leftType)) {
        return simplify_componentwise(context, pos,
                                      *splat_scalar(context, *left, right->type()), op, *right);
    }
 
    // Perform constant folding on pairs of matrices, arrays or structs.
    if ((leftType.isMatrix() && rightType.isMatrix()) ||
        (leftType.isArray() && rightType.isArray()) ||
        (leftType.isStruct() && rightType.isStruct())) {
        return simplify_constant_equality(context, pos, *left, op, *right);
    }
 
    // We aren't able to constant-fold these expressions.
    return nullptr;
}

◆ get_storage_class()

static SpvStorageClass_ SkSL::get_storage_class ( const Expression & expr )

static

Definition at line 3024 of file SkSLSPIRVCodeGenerator.cpp.

                                                                  {
    switch (expr.kind()) {
        case Expression::Kind::kVariableReference: {
            const Variable& var = *expr.as<VariableReference>().variable();
            if (var.storage() != Variable::Storage::kGlobal) {
                return SpvStorageClassFunction;
            }
            return get_storage_class_for_global_variable(var, SpvStorageClassPrivate);
        }
        case Expression::Kind::kFieldAccess:
            return get_storage_class(*expr.as<FieldAccess>().base());
        case Expression::Kind::kIndex:
            return get_storage_class(*expr.as<IndexExpression>().base());
        default:
            return SpvStorageClassFunction;
    }
}

◆ get_storage_class_for_global_variable()

static SpvStorageClass_ SkSL::get_storage_class_for_global_variable	(	const Variable &	var,
		SpvStorageClass_	fallbackStorageClass
	)

static

Definition at line 2983 of file SkSLSPIRVCodeGenerator.cpp.

                                                                    {
    SkASSERT(var.storage() == Variable::Storage::kGlobal);
 
    if (var.type().typeKind() == Type::TypeKind::kSampler ||
        var.type().typeKind() == Type::TypeKind::kSeparateSampler ||
        var.type().typeKind() == Type::TypeKind::kTexture) {
        return SpvStorageClassUniformConstant;
    }
 
    const Layout& layout = var.layout();
    ModifierFlags flags = var.modifierFlags();
    if (flags & ModifierFlag::kIn) {
        SkASSERT(!(layout.fFlags & LayoutFlag::kPushConstant));
        return SpvStorageClassInput;
    }
    if (flags & ModifierFlag::kOut) {
        SkASSERT(!(layout.fFlags & LayoutFlag::kPushConstant));
        return SpvStorageClassOutput;
    }
    if (flags.isUniform()) {
        if (layout.fFlags & LayoutFlag::kPushConstant) {
            return SpvStorageClassPushConstant;
        }
        return SpvStorageClassUniform;
    }
    if (flags.isBuffer()) {
        // Note: In SPIR-V 1.3, a storage buffer can be declared with the "StorageBuffer"
        // storage class and the "Block" decoration and the <1.3 approach we use here ("Uniform"
        // storage class and the "BufferBlock" decoration) is deprecated. Since we target SPIR-V
        // 1.0, we have to use the deprecated approach which is well supported in Vulkan and
        // addresses SkSL use cases (notably SkSL currently doesn't support pointer features that
        // would benefit from SPV_KHR_variable_pointers capabilities).
        return SpvStorageClassUniform;
    }
    if (flags.isWorkgroup()) {
        return SpvStorageClassWorkgroup;
    }
    return fallbackStorageClass;
}

◆ get_struct_definitions_from_module()

static void SkSL::get_struct_definitions_from_module	(	Program &	program,
		const Module &	module,
		std::vector< const ProgramElement * > *	addedStructDefs
	)

static

Definition at line 37 of file SkSLFindAndDeclareBuiltinStructs.cpp.

                                                           {
    // We want to start at the root module and work our way towards the Program, so that structs
    // are added to the program in the same order that they appear in the Module hierarchy.
    if (module.fParent) {
        get_struct_definitions_from_module(program, *module.fParent, addedStructDefs);
    }
 
    // Find StructDefinitions from this Module that are used by the program, and copy them into our
    // array of shared elements.
    for (const std::unique_ptr<ProgramElement>& elem : module.fElements) {
        if (elem->is<StructDefinition>()) {
            const StructDefinition& structDef = elem->as<StructDefinition>();
            int* structCount = program.fUsage->fStructCounts.find(&structDef.type());
            if (structCount && *structCount > 0) {
                addedStructDefs->push_back(&structDef);
            }
        }
    }
}

◆ get_thread_local_memory_pool()

static MemoryPool * SkSL::get_thread_local_memory_pool ( )

static

Definition at line 18 of file SkSLPool.cpp.

                                                  {
    return sMemPool;
}

◆ get_top_level_symbol_table()

static SymbolTable * SkSL::get_top_level_symbol_table ( const FunctionDeclaration & anyFunc )

static

Definition at line 4940 of file SkSLSPIRVCodeGenerator.cpp.

                                                                                   {
    return anyFunc.definition()->body()->as<Block>().symbolTable()->fParent;
}

◆ get_transition()

static State SkSL::get_transition	(	uint8_t	transition,
		State	state
	)

static

Definition at line 763 of file SkSLLexer.cpp.

                                                             {
    IndexEntry index = kIndices[state];
    if (index < 0) {
        return kFull[~index].data[transition];
    }
    const CompactEntry& entry = kCompact[index];
    int v = entry.data[transition >> 2];
    v >>= 2 * (transition & 3);
    v &= 3;
    v *= 9;
    return (entry.values >> v) & 511;
}

◆ GetIntrinsicMap()

const IntrinsicMap & SkSL::GetIntrinsicMap ( )

Definition at line 16 of file SkSLIntrinsicList.cpp.

                                      {
    #define SKSL_INTRINSIC(name) {#name, k_##name##_IntrinsicKind},
    static const SkNoDestructor<IntrinsicMap> kAllIntrinsics(IntrinsicMap{
        SKSL_INTRINSIC_LIST
    });
    #undef SKSL_INTRINSIC
 
    return *kAllIntrinsics;
}

◆ GetModuleData()

std::string SkSL::GetModuleData	(	ModuleName	name,
		const char *	filename
	)

Definition at line 46 of file SkSLModuleDataDefault.cpp.

                                                        {
#define M(name) case ModuleName::name: return std::string(SKSL_MINIFIED_##name);
    switch (name) {
        M(sksl_shared)
        M(sksl_compute)
        M(sksl_frag)
        M(sksl_gpu)
        M(sksl_public)
        M(sksl_rt_shader)
        M(sksl_vert)
#if defined(SK_GRAPHITE)
        M(sksl_graphite_frag)
        M(sksl_graphite_frag_es2)
        M(sksl_graphite_vert)
        M(sksl_graphite_vert_es2)
#endif
        default:
            SkUNREACHABLE;
    }
#undef M
}

◆ has_compile_time_constant_arguments()

static bool SkSL::has_compile_time_constant_arguments ( const ExpressionArray & arguments )

static

Definition at line 53 of file SkSLFunctionCall.cpp.

                                                                                  {
    for (const std::unique_ptr<Expression>& arg : arguments) {
        const Expression* expr = ConstantFolder::GetConstantValueForVariable(*arg);
        if (!Analysis::IsCompileTimeConstant(*expr)) {
            return false;
        }
    }
    return true;
}

◆ hoist_vardecl_symbols_into_outer_scope()

static void SkSL::hoist_vardecl_symbols_into_outer_scope	(	const Context &	context,
		const Block &	initBlock,
		SymbolTable *	innerSymbols,
		SymbolTable *	hoistedSymbols
	)

static

Definition at line 70 of file SkSLForStatement.cpp.

                                                                                {
    class SymbolHoister : public ProgramVisitor {
    public:
        SymbolHoister(const Context& ctx, SymbolTable* innerSym, SymbolTable* hoistSym)
                : fContext(ctx)
                , fInnerSymbols(innerSym)
                , fHoistedSymbols(hoistSym) {}
 
        bool visitStatement(const Statement& stmt) override {
            if (stmt.is<VarDeclaration>()) {
                // Hoist the variable's symbol outside of the initializer block's symbol table, and
                // into the outer symbol table. If the initializer's symbol table originally had
                // ownership, transfer it. (If the variable was owned elsewhere, it can keep its
                // current owner.)
                Variable* var = stmt.as<VarDeclaration>().var();
                fInnerSymbols->moveSymbolTo(fHoistedSymbols, var, fContext);
                return false;
            }
            return ProgramVisitor::visitStatement(stmt);
        }
 
        const Context& fContext;
        SymbolTable* fInnerSymbols;
        SymbolTable* fHoistedSymbols;
    };
 
    SymbolHoister{context, innerSymbols, hoistedSymbols}.visitStatement(initBlock);
}

◆ index_out_of_range()

static bool SkSL::index_out_of_range	(	const Context &	context,
		Position	pos,
		SKSL_INT	index,
		const Expression &	base
	)

static

Definition at line 32 of file SkSLIndexExpression.cpp.

                                {
    if (index >= 0) {
        if (base.type().columns() == Type::kUnsizedArray) {
            return false;
        } else if (index < base.type().columns()) {
            return false;
        }
    }
    context.fErrors->error(pos, "index " + std::to_string(index) + " out of range for '" +
                                base.type().displayName() + "'");
    return true;
}

◆ is_abs()

static bool SkSL::is_abs ( Expression & expr )

static

Definition at line 447 of file SkSLGLSLCodeGenerator.cpp.

                                     {
    return expr.is<FunctionCall>() &&
           expr.as<FunctionCall>().function().intrinsicKind() == k_abs_IntrinsicKind;
}

◆ is_block_ending_with_return()

static bool SkSL::is_block_ending_with_return ( const Statement * stmt )

static

Definition at line 2637 of file SkSLMetalCodeGenerator.cpp.

                                                               {
    // This function detects (potentially nested) blocks that end in a return statement.
    if (!stmt->is<Block>()) {
        return false;
    }
    const StatementArray& block = stmt->as<Block>().children();
    for (int index = block.size(); index--; ) {
        stmt = block[index].get();
        if (stmt->is<ReturnStatement>()) {
            return true;
        }
        if (stmt->is<Block>()) {
            return is_block_ending_with_return(stmt);
        }
        if (!stmt->is<Nop>()) {
            break;
        }
    }
    return false;
}

◆ is_bool()

static bool SkSL::is_bool ( const Type & type )

static

Definition at line 927 of file SkSLSPIRVCodeGenerator.cpp.

                                      {
    return (type.isScalar() || type.isVector()) && type.componentType().isBoolean();
}

◆ is_buffer()

static bool SkSL::is_buffer ( const InterfaceBlock & block )

static

Definition at line 559 of file SkSLMetalCodeGenerator.cpp.

                                                   {
    return block.var()->modifierFlags().isBuffer();
}

◆ is_compute_builtin()

static bool SkSL::is_compute_builtin ( const Variable & var )

static

Definition at line 1713 of file SkSLMetalCodeGenerator.cpp.

                                                    {
    switch (var.layout().fBuiltin) {
        case SK_NUMWORKGROUPS_BUILTIN:
        case SK_WORKGROUPID_BUILTIN:
        case SK_LOCALINVOCATIONID_BUILTIN:
        case SK_GLOBALINVOCATIONID_BUILTIN:
        case SK_LOCALINVOCATIONINDEX_BUILTIN:
            return true;
        default:
            break;
    }
    return false;
}

◆ is_constant_diagonal()

static bool SkSL::is_constant_diagonal	(	const Expression &	expr,
		double	value
	)

static

Definition at line 366 of file SkSLConstantFolder.cpp.

                                                                       {
    SkASSERT(expr.type().isMatrix());
    int columns = expr.type().columns();
    int rows = expr.type().rows();
    if (columns != rows) {
        return false;
    }
    int slotIdx = 0;
    for (int c = 0; c < columns; ++c) {
        for (int r = 0; r < rows; ++r) {
            double expectation = (c == r) ? value : 0;
            std::optional<double> slotVal = expr.getConstantValue(slotIdx++);
            if (!slotVal.has_value() || *slotVal != expectation) {
                return false;
            }
        }
    }
    return true;
}

◆ is_constant_value()

static bool SkSL::is_constant_value	(	const Expression &	expr,
		double	value
	)

static

Definition at line 387 of file SkSLConstantFolder.cpp.

                                                                    {
    return expr.type().isMatrix() ? is_constant_diagonal(expr, value)
                                  : ConstantFolder::IsConstantSplat(expr, value);
}

◆ is_control_flow_op()

static bool SkSL::is_control_flow_op ( SpvOp_ op )

static

Definition at line 961 of file SkSLSPIRVCodeGenerator.cpp.

                                          {
    switch (op) {
        case SpvOpReturn:
        case SpvOpReturnValue:
        case SpvOpKill:
        case SpvOpSwitch:
        case SpvOpBranch:
        case SpvOpBranchConditional:
            return true;
        default:
            return false;
    }
}

◆ is_dead_variable()

static bool SkSL::is_dead_variable	(	const ProgramElement &	element,
		ProgramUsage *	usage,
		bool	onlyPrivateGlobals
	)

static

Definition at line 26 of file SkSLEliminateDeadGlobalVariables.cpp.

                                                      {
    if (!element.is<GlobalVarDeclaration>()) {
        return false;
    }
    const GlobalVarDeclaration& global = element.as<GlobalVarDeclaration>();
    const VarDeclaration& varDecl = global.varDeclaration();
    if (onlyPrivateGlobals && !skstd::starts_with(varDecl.var()->name(), '$')) {
        return false;
    }
    if (!usage->isDead(*varDecl.var())) {
        return false;
    }
    // This declaration is about to be eliminated by remove_if; update ProgramUsage accordingly.
    usage->remove(&varDecl);
    return true;
}

◆ is_float()

static bool SkSL::is_float ( const Type & type )

static

Definition at line 914 of file SkSLSPIRVCodeGenerator.cpp.

                                       {
    return (type.isScalar() || type.isVector() || type.isMatrix()) &&
           type.componentType().isFloat();
}

◆ is_globally_reachable_op()

static bool SkSL::is_globally_reachable_op ( SpvOp_ op )

static

Definition at line 975 of file SkSLSPIRVCodeGenerator.cpp.

                                                {
    switch (op) {
        case SpvOpConstant:
        case SpvOpConstantTrue:
        case SpvOpConstantFalse:
        case SpvOpConstantComposite:
        case SpvOpTypeVoid:
        case SpvOpTypeInt:
        case SpvOpTypeFloat:
        case SpvOpTypeBool:
        case SpvOpTypeVector:
        case SpvOpTypeMatrix:
        case SpvOpTypeArray:
        case SpvOpTypePointer:
        case SpvOpTypeFunction:
        case SpvOpTypeRuntimeArray:
        case SpvOpTypeStruct:
        case SpvOpTypeImage:
        case SpvOpTypeSampledImage:
        case SpvOpTypeSampler:
        case SpvOpVariable:
        case SpvOpFunction:
        case SpvOpFunctionParameter:
        case SpvOpFunctionEnd:
        case SpvOpExecutionMode:
        case SpvOpMemoryModel:
        case SpvOpCapability:
        case SpvOpExtInstImport:
        case SpvOpEntryPoint:
        case SpvOpSource:
        case SpvOpSourceExtension:
        case SpvOpName:
        case SpvOpMemberName:
        case SpvOpDecorate:
        case SpvOpMemberDecorate:
            return true;
        default:
            return false;
    }
}

◆ is_in()

static bool SkSL::is_in ( ModifierFlags f )

static

Definition at line 953 of file SkSLSPIRVCodeGenerator.cpp.

                                   {
    if (f & ModifierFlag::kIn) {
        return true;  // `in` and `inout` both count
    }
    // If neither in/out flag is set, the type is implicitly `in`.
    return !SkToBool(f & ModifierFlag::kOut);
}

◆ is_in_globals()

static bool SkSL::is_in_globals ( const Variable & var )

static

Definition at line 1759 of file SkSLMetalCodeGenerator.cpp.

                                               {
    SkASSERT(var.storage() == VariableStorage::kGlobal);
    return !var.modifierFlags().isConst();
}

◆ is_input()

static bool SkSL::is_input ( const Variable & var )

static

Definition at line 1728 of file SkSLMetalCodeGenerator.cpp.

                                          {
    SkASSERT(var.storage() == VariableStorage::kGlobal);
    return var.modifierFlags() & ModifierFlag::kIn &&
           (var.layout().fBuiltin == -1 || is_compute_builtin(var)) &&
           var.type().typeKind() != Type::TypeKind::kTexture;
}

◆ is_matrix_op_scalar()

static bool SkSL::is_matrix_op_scalar	(	const Expression &	left,
		const Expression &	right
	)

static

Definition at line 476 of file SkSLConstantFolder.cpp.

                                                                                 {
    return is_scalar_op_matrix(right, left);
}

◆ is_nontrivial_expression()

static bool SkSL::is_nontrivial_expression ( const Expression & expr )

static

Definition at line 2521 of file SkSLWGSLCodeGenerator.cpp.

                                                             {
    // We consider a "trivial expression" one which we can repeat multiple times in the output
    // without being dangerous or spammy. We avoid emitting temporary variables for very trivial
    // expressions: literals, unadorned variable references, or constant vectors.
    if (expr.is<VariableReference>() || expr.is<Literal>()) {
        // Variables and literals are trivial; adding a let-declaration won't simplify anything.
        return false;
    }
    if (expr.type().isVector() && Analysis::IsConstantExpression(expr)) {
        // Compile-time constant vectors are also considered trivial; they're short and sweet.
        return false;
    }
    return true;
}

◆ is_out()

static bool SkSL::is_out ( ModifierFlags f )

static

Definition at line 949 of file SkSLSPIRVCodeGenerator.cpp.

                                    {
    return SkToBool(f & ModifierFlag::kOut);
}

◆ is_output()

static bool SkSL::is_output ( const Variable & var )

static

Definition at line 1736 of file SkSLMetalCodeGenerator.cpp.

                                           {
    SkASSERT(var.storage() == VariableStorage::kGlobal);
    // inout vars get written into the Inputs struct, so we exclude them from Outputs
    return  (var.modifierFlags() & ModifierFlag::kOut) &&
           !(var.modifierFlags() & ModifierFlag::kIn) &&
             var.layout().fBuiltin == -1 &&
             var.type().typeKind() != Type::TypeKind::kTexture;
}

◆ is_readonly()

static bool SkSL::is_readonly ( const InterfaceBlock & block )

static

Definition at line 564 of file SkSLMetalCodeGenerator.cpp.

                                                     {
    return block.var()->modifierFlags().isReadOnly();
}

◆ is_safe_to_eliminate()

static bool SkSL::is_safe_to_eliminate	(	const Type &	type,
		const Expression &	arg
	)

static

Definition at line 28 of file SkSLConstructorCompound.cpp.

                                                                          {
    if (type.isScalar()) {
        // A scalar "compound type" with a single scalar argument is a no-op and can be eliminated.
        // (Pedantically, this isn't a compound at all, but it's harmless to allow and simplifies
        // call sites which need to narrow a vector and may sometimes end up with a scalar.)
        SkASSERTF(arg.type().matches(type), "Creating type '%s' from '%s'",
                  type.description().c_str(), arg.type().description().c_str());
        return true;
    }
    if (type.isVector() && arg.type().matches(type)) {
        // A vector compound constructor containing a single argument of matching type can trivially
        // be eliminated.
        return true;
    }
    // This is a meaningful single-argument compound constructor (e.g. vector-from-matrix,
    // matrix-from-vector).
    return false;
}

◆ is_scalar_op_matrix()

static bool SkSL::is_scalar_op_matrix	(	const Expression &	left,
		const Expression &	right
	)

static

Definition at line 472 of file SkSLConstantFolder.cpp.

                                                                                 {
    return left.type().isScalar() && right.type().isMatrix();
}

◆ is_signed()

static bool SkSL::is_signed ( const Type & type )

static

Definition at line 919 of file SkSLSPIRVCodeGenerator.cpp.

                                        {
    return (type.isScalar() || type.isVector()) && type.componentType().isSigned();
}

◆ is_simple_initializer()

static bool SkSL::is_simple_initializer ( const Statement * stmt )

static

Definition at line 46 of file SkSLForStatement.cpp.

                                                         {
    return !stmt || stmt->isEmpty() || stmt->is<SkSL::VarDeclaration>() ||
           stmt->is<SkSL::ExpressionStatement>();
}

◆ is_sk_position()

bool SkSL::is_sk_position ( const Expression & expr )

Definition at line 1123 of file SkSLGLSLCodeGenerator.cpp.

                                            {
    if (!expr.is<FieldAccess>()) {
        return false;
    }
    const FieldAccess& f = expr.as<FieldAccess>();
    return f.base()->type().fields()[f.fieldIndex()].fLayout.fBuiltin == SK_POSITION_BUILTIN;
}

◆ is_sk_samplemask()

bool SkSL::is_sk_samplemask ( const Expression & expr )

Definition at line 1131 of file SkSLGLSLCodeGenerator.cpp.

                                              {
    if (!expr.is<VariableReference>()) {
        return false;
    }
    const VariableReference& v = expr.as<VariableReference>();
    return v.variable()->layout().fBuiltin == SK_SAMPLEMASK_BUILTIN;
}

◆ is_threadgroup()

static bool SkSL::is_threadgroup ( const Variable & var )

static

Definition at line 1753 of file SkSLMetalCodeGenerator.cpp.

                                                {
    SkASSERT(var.storage() == VariableStorage::kGlobal);
    return var.modifierFlags().isWorkgroup();
}

◆ is_uniforms()

static bool SkSL::is_uniforms ( const Variable & var )

static

Definition at line 1746 of file SkSLMetalCodeGenerator.cpp.

                                             {
    SkASSERT(var.storage() == VariableStorage::kGlobal);
    return var.modifierFlags().isUniform() &&
           var.type().typeKind() != Type::TypeKind::kSampler;
}

◆ is_unsigned()

static bool SkSL::is_unsigned ( const Type & type )

static

Definition at line 923 of file SkSLSPIRVCodeGenerator.cpp.

                                          {
    return (type.isScalar() || type.isVector()) && type.componentType().isUnsigned();
}

◆ is_vardecl_block_initializer()

static bool SkSL::is_vardecl_block_initializer ( const Statement * stmt )

static

Definition at line 27 of file SkSLForStatement.cpp.

                                                                {
    if (!stmt) {
        return false;
    }
    if (!stmt->is<SkSL::Block>()) {
        return false;
    }
    const SkSL::Block& b = stmt->as<SkSL::Block>();
    if (b.isScope()) {
        return false;
    }
    for (const auto& child : b.children()) {
        if (!child->is<SkSL::VarDeclaration>()) {
            return false;
        }
    }
    return true;
}

◆ is_vardecl_compile_time_constant()

static bool SkSL::is_vardecl_compile_time_constant ( const VarDeclaration & varDecl )

static

Definition at line 4537 of file SkSLSPIRVCodeGenerator.cpp.

                                                                            {
    return varDecl.var()->modifierFlags().isConst() &&
           (varDecl.var()->type().isScalar() || varDecl.var()->type().isVector()) &&
           (ConstantFolder::GetConstantValueOrNull(*varDecl.value()) ||
            Analysis::IsCompileTimeConstant(*varDecl.value()));
}

◆ is_vec_or_mat()

static bool SkSL::is_vec_or_mat ( const Type & type )

static

Definition at line 41 of file SkSLConstantFolder.cpp.

                                            {
    switch (type.typeKind()) {
        case Type::TypeKind::kMatrix:
        case Type::TypeKind::kVector:
            return true;
 
        default:
            return false;
    }
}

◆ is_whitespace()

static bool SkSL::is_whitespace ( Token::Kind kind )

static

Definition at line 273 of file SkSLParser.cpp.

                                          {
    switch (kind) {
        case Token::Kind::TK_WHITESPACE:
        case Token::Kind::TK_LINE_COMMENT:
        case Token::Kind::TK_BLOCK_COMMENT:
            return true;
 
        default:
            return false;
    }
}

◆ layout_flags_to_image_format()

static SpvImageFormat SkSL::layout_flags_to_image_format ( LayoutFlags flags )

static

Definition at line 1639 of file SkSLSPIRVCodeGenerator.cpp.

                                                                      {
    flags &= LayoutFlag::kAllPixelFormats;
    switch (flags.value()) {
        case (int)LayoutFlag::kRGBA8:
            return SpvImageFormatRgba8;
 
        case (int)LayoutFlag::kRGBA32F:
            return SpvImageFormatRgba32f;
 
        case (int)LayoutFlag::kR32F:
            return SpvImageFormatR32f;
 
        default:
            return SpvImageFormatUnknown;
    }
 
    SkUNREACHABLE;
}

◆ logical_not_operand()

static std::unique_ptr< Expression > SkSL::logical_not_operand	(	const Context &	context,
		Position	pos,
		std::unique_ptr< Expression >	operand
	)

static

Definition at line 151 of file SkSLPrefixExpression.cpp.

                                                                                          {
    const Expression* value = ConstantFolder::GetConstantValueForVariable(*operand);
    switch (value->kind()) {
        case Expression::Kind::kLiteral: {
            // Convert !boolLiteral(true) to boolLiteral(false).
            SkASSERT(value->type().isBoolean());
            const Literal& b = value->as<Literal>();
            return Literal::MakeBool(pos, !b.boolValue(), &operand->type());
        }
        case Expression::Kind::kPrefix: {
            // Convert `!(!expression)` into `expression`.
            PrefixExpression& prefix = operand->as<PrefixExpression>();
            if (prefix.getOperator().kind() == Operator::Kind::LOGICALNOT) {
                prefix.operand()->fPosition = pos;
                return std::move(prefix.operand());
            }
            break;
        }
        case Expression::Kind::kBinary: {
            BinaryExpression& binary = operand->as<BinaryExpression>();
            std::optional<Operator> replacement;
            switch (binary.getOperator().kind()) {
                case OperatorKind::EQEQ: replacement = OperatorKind::NEQ;  break;
                case OperatorKind::NEQ:  replacement = OperatorKind::EQEQ; break;
                case OperatorKind::LT:   replacement = OperatorKind::GTEQ; break;
                case OperatorKind::LTEQ: replacement = OperatorKind::GT;   break;
                case OperatorKind::GT:   replacement = OperatorKind::LTEQ; break;
                case OperatorKind::GTEQ: replacement = OperatorKind::LT;   break;
                default:                                                   break;
            }
            if (replacement.has_value()) {
                return BinaryExpression::Make(context, pos, std::move(binary.left()),
                                              *replacement, std::move(binary.right()),
                                              &binary.type());
            }
            break;
        }
        default:
            break;
    }
 
    // No simplified form; convert expression to Prefix(LOGICALNOT, expression).
    return std::make_unique<PrefixExpression>(pos, Operator::Kind::LOGICALNOT, std::move(operand));
}

◆ make_reciprocal_expression()

static std::unique_ptr< Expression > SkSL::make_reciprocal_expression	(	const Context &	context,
		const Expression &	right
	)

static

Definition at line 396 of file SkSLConstantFolder.cpp.

                                                                                       {
    if (right.type().isMatrix() || !right.type().componentType().isFloat()) {
        return nullptr;
    }
    // Verify that each slot contains a finite, non-zero literal, take its reciprocal.
    double values[4];
    int nslots = right.type().slotCount();
    for (int index = 0; index < nslots; ++index) {
        std::optional<double> value = right.getConstantValue(index);
        if (!value) {
            return nullptr;
        }
        *value = sk_ieee_double_divide(1.0, *value);
        if (*value >= -FLT_MAX && *value <= FLT_MAX && *value != 0.0) {
            // The reciprocal can be represented safely as a finite 32-bit float.
            values[index] = *value;
        } else {
            // The value is outside the 32-bit float range, or is NaN; do not optimize.
            return nullptr;
        }
    }
    // Turn the expression array into a compound constructor. (If this is a single-slot expression,
    // this will return the literal as-is.)
    return ConstructorCompound::MakeFromConstants(context, right.fPosition, right.type(), values);
}

◆ make_splat_from_arguments()

static const Expression * SkSL::make_splat_from_arguments	(	const Type &	type,
		const ExpressionArray &	args
	)

static

Definition at line 47 of file SkSLConstructorCompound.cpp.

                                                                                                  {
    // Splats cannot represent a matrix.
    if (type.isMatrix()) {
        return nullptr;
    }
    const Expression* splatExpression = nullptr;
    for (int index = 0; index < args.size(); ++index) {
        // Arguments must only be scalars or a splat constructors (which can only contain scalars).
        const Expression* expr;
        if (args[index]->type().isScalar()) {
            expr = args[index].get();
        } else if (args[index]->is<ConstructorSplat>()) {
            expr = args[index]->as<ConstructorSplat>().argument().get();
        } else {
            return nullptr;
        }
        // On the first iteration, just remember the expression we encountered.
        if (index == 0) {
            splatExpression = expr;
            continue;
        }
        // On subsequent iterations, ensure that the expression we found matches the first one.
        // (Note that IsSameExpressionTree will always reject an Expression with side effects.)
        if (!Analysis::IsSameExpressionTree(*expr, *splatExpression)) {
            return nullptr;
        }
    }
 
    return splatExpression;
}

◆ MakeRasterPipelineProgram()

std::unique_ptr< RP::Program > SkSL::MakeRasterPipelineProgram	(	const SkSL::Program &	program,
		const FunctionDefinition &	function,
		DebugTracePriv *	debugTrace,
		bool	writeTraceOps
	)

Definition at line 4070 of file SkSLRasterPipelineCodeGenerator.cpp.

                                                                           {
    RP::Generator generator(program, debugTrace, writeTraceOps);
    if (!generator.writeProgram(function)) {
        return nullptr;
    }
    return generator.finish();
}

◆ mask_char()

static char SkSL::mask_char ( int8_t component )

static

Definition at line 88 of file SkSLSwizzle.cpp.

                                        {
    switch (component) {
        case SwizzleComponent::X:    return 'x';
        case SwizzleComponent::Y:    return 'y';
        case SwizzleComponent::Z:    return 'z';
        case SwizzleComponent::W:    return 'w';
        case SwizzleComponent::R:    return 'r';
        case SwizzleComponent::G:    return 'g';
        case SwizzleComponent::B:    return 'b';
        case SwizzleComponent::A:    return 'a';
        case SwizzleComponent::S:    return 's';
        case SwizzleComponent::T:    return 't';
        case SwizzleComponent::P:    return 'p';
        case SwizzleComponent::Q:    return 'q';
        case SwizzleComponent::UL:   return 'L';
        case SwizzleComponent::UT:   return 'T';
        case SwizzleComponent::UR:   return 'R';
        case SwizzleComponent::UB:   return 'B';
        case SwizzleComponent::ZERO: return '0';
        case SwizzleComponent::ONE:  return '1';
        default: SkUNREACHABLE;
    }
}

◆ needs_address_space()

static bool SkSL::needs_address_space	(	const Type &	type,
		ModifierFlags	modifiers
	)

static

Definition at line 554 of file SkSLMetalCodeGenerator.cpp.

                                                                           {
    return type.isUnsizedArray() || pass_by_reference(type, modifiers);
}

◆ negate_expression()

static std::unique_ptr< Expression > SkSL::negate_expression	(	const Context &	context,
		Position	pos,
		const Expression &	expr,
		const Type &	type
	)

static

Definition at line 316 of file SkSLConstantFolder.cpp.

                                                                       {
    std::unique_ptr<Expression> ctor = cast_expression(context, pos, expr, type);
    return ctor ? PrefixExpression::Make(context, pos, Operator::Kind::MINUS, std::move(ctor))
                : nullptr;
}

◆ negate_operand()

static std::unique_ptr< Expression > SkSL::negate_operand	(	const Context &	context,
		Position	pos,
		std::unique_ptr< Expression >	value
	)

static

Definition at line 139 of file SkSLPrefixExpression.cpp.

                                                                                   {
    // Attempt to simplify this negation (e.g. eliminate double negation, literal values)
    if (std::unique_ptr<Expression> simplified = simplify_negation(context, pos, *value)) {
        return simplified;
    }
 
    // No simplified form; convert expression to Prefix(MINUS, expression).
    return std::make_unique<PrefixExpression>(pos, Operator::Kind::MINUS, std::move(value));
}

◆ negate_operands()

static ExpressionArray SkSL::negate_operands	(	const Context &	context,
		Position	pos,
		const ExpressionArray &	operands
	)

static

Definition at line 122 of file SkSLPrefixExpression.cpp.

                                                                     {
    ExpressionArray replacement;
    replacement.reserve_exact(array.size());
    for (const std::unique_ptr<Expression>& expr : array) {
        // The logic below is very similar to `negate_operand`, but with different ownership rules.
        if (std::unique_ptr<Expression> simplified = simplify_negation(context, pos, *expr)) {
            replacement.push_back(std::move(simplified));
        } else {
            replacement.push_back(std::make_unique<PrefixExpression>(pos, Operator::Kind::MINUS,
                                                                     expr->clone()));
        }
    }
    return replacement;
}

◆ negate_value()

static double SkSL::negate_value ( double value )

static

Definition at line 35 of file SkSLPrefixExpression.cpp.

                                         {
    return -value;
}

◆ one_over_scalar()

static std::unique_ptr< Expression > SkSL::one_over_scalar	(	const Context &	context,
		const Expression &	right
	)

static

Definition at line 615 of file SkSLConstantFolder.cpp.

                                                                            {
    SkASSERT(right.type().isScalar());
    Position pos = right.fPosition;
    return BinaryExpression::Make(context, pos,
                                  Literal::Make(pos, 1.0, &right.type()),
                                  Operator::Kind::SLASH,
                                  right.clone());
}

◆ operator_name()

static const char * SkSL::operator_name ( Operator op )

static

Definition at line 372 of file SkSLMetalCodeGenerator.cpp.

                                              {
    switch (op.kind()) {
        case Operator::Kind::LOGICALXOR:  return " != ";
        default:                          return op.operatorName();
    }
}

◆ optimize_comparison()

static std::unique_ptr< Expression > SkSL::optimize_comparison	(	const Context &	context,
		const IntrinsicArguments &	arguments,
		CompareFn	compare
	)

static

Definition at line 176 of file SkSLFunctionCall.cpp.

                                                                          {
    const Expression* left = arguments[0];
    const Expression* right = arguments[1];
    SkASSERT(left);
    SkASSERT(right);
    SkASSERT(!arguments[2]);
 
    const Type& type = left->type();
    SkASSERT(type.isVector());
    SkASSERT(type.componentType().isScalar());
    SkASSERT(type.matches(right->type()));
 
    double array[4];
 
    for (int index = 0; index < type.columns(); ++index) {
        std::optional<double> leftValue = left->getConstantValue(index);
        std::optional<double> rightValue = right->getConstantValue(index);
        SkASSERT(leftValue.has_value());
        SkASSERT(rightValue.has_value());
        array[index] = compare(*leftValue, *rightValue) ? 1.0 : 0.0;
    }
 
    const Type& bvecType = context.fTypes.fBool->toCompound(context, type.columns(), /*rows=*/1);
    return ConstructorCompound::MakeFromConstants(context, left->fPosition, bvecType, array);
}

◆ optimize_constructor_swizzle()

static std::unique_ptr< Expression > SkSL::optimize_constructor_swizzle	(	const Context &	context,
		Position	pos,
		const ConstructorCompound &	base,
		ComponentArray	components
	)

static

Definition at line 120 of file SkSLSwizzle.cpp.

                                                                                           {
    auto baseArguments = base.argumentSpan();
    std::unique_ptr<Expression> replacement;
    const Type& exprType = base.type();
    const Type& componentType = exprType.componentType();
    int swizzleSize = components.size();
 
    // Swizzles can duplicate some elements and discard others, e.g.
    // `half4(1, 2, 3, 4).xxz` --> `half3(1, 1, 3)`. However, there are constraints:
    // - Expressions with side effects need to occur exactly once, even if they would otherwise be
    //   swizzle-eliminated
    // - Non-trivial expressions should not be repeated, but elimination is OK.
    //
    // Look up the argument for the constructor at each index. This is typically simple but for
    // weird cases like `half4(bar.yz, half2(foo))`, it can be harder than it seems. This example
    // would result in:
    //     argMap[0] = {.fArgIndex = 0, .fComponent = 0}   (bar.yz     .x)
    //     argMap[1] = {.fArgIndex = 0, .fComponent = 1}   (bar.yz     .y)
    //     argMap[2] = {.fArgIndex = 1, .fComponent = 0}   (half2(foo) .x)
    //     argMap[3] = {.fArgIndex = 1, .fComponent = 1}   (half2(foo) .y)
    struct ConstructorArgMap {
        int8_t fArgIndex;
        int8_t fComponent;
    };
 
    int numConstructorArgs = base.type().columns();
    ConstructorArgMap argMap[4] = {};
    int writeIdx = 0;
    for (int argIdx = 0; argIdx < (int)baseArguments.size(); ++argIdx) {
        const Expression& arg = *baseArguments[argIdx];
        const Type& argType = arg.type();
 
        if (!argType.isScalar() && !argType.isVector()) {
            return nullptr;
        }
 
        int argSlots = argType.slotCount();
        for (int componentIdx = 0; componentIdx < argSlots; ++componentIdx) {
            argMap[writeIdx].fArgIndex = argIdx;
            argMap[writeIdx].fComponent = componentIdx;
            ++writeIdx;
        }
    }
    SkASSERT(writeIdx == numConstructorArgs);
 
    // Count up the number of times each constructor argument is used by the swizzle.
    //    `half4(bar.yz, half2(foo)).xwxy` -> { 3, 1 }
    // - bar.yz    is referenced 3 times, by `.x_xy`
    // - half(foo) is referenced 1 time,  by `._w__`
    int8_t exprUsed[4] = {};
    for (int8_t c : components) {
        exprUsed[argMap[c].fArgIndex]++;
    }
 
    for (int index = 0; index < numConstructorArgs; ++index) {
        int8_t constructorArgIndex = argMap[index].fArgIndex;
        const Expression& baseArg = *baseArguments[constructorArgIndex];
 
        // Check that non-trivial expressions are not swizzled in more than once.
        if (exprUsed[constructorArgIndex] > 1 && !Analysis::IsTrivialExpression(baseArg)) {
            return nullptr;
        }
        // Check that side-effect-bearing expressions are swizzled in exactly once.
        if (exprUsed[constructorArgIndex] != 1 && Analysis::HasSideEffects(baseArg)) {
            return nullptr;
        }
    }
 
    struct ReorderedArgument {
        int8_t fArgIndex;
        ComponentArray fComponents;
    };
    STArray<4, ReorderedArgument> reorderedArgs;
    for (int8_t c : components) {
        const ConstructorArgMap& argument = argMap[c];
        const Expression& baseArg = *baseArguments[argument.fArgIndex];
 
        if (baseArg.type().isScalar()) {
            // This argument is a scalar; add it to the list as-is.
            SkASSERT(argument.fComponent == 0);
            reorderedArgs.push_back({argument.fArgIndex,
                                     ComponentArray{}});
        } else {
            // This argument is a component from a vector.
            SkASSERT(baseArg.type().isVector());
            SkASSERT(argument.fComponent < baseArg.type().columns());
            if (reorderedArgs.empty() ||
                reorderedArgs.back().fArgIndex != argument.fArgIndex) {
                // This can't be combined with the previous argument. Add a new one.
                reorderedArgs.push_back({argument.fArgIndex,
                                         ComponentArray{argument.fComponent}});
            } else {
                // Since we know this argument uses components, it should already have at least one
                // component set.
                SkASSERT(!reorderedArgs.back().fComponents.empty());
                // Build up the current argument with one more component.
                reorderedArgs.back().fComponents.push_back(argument.fComponent);
            }
        }
    }
 
    // Convert our reordered argument list to an actual array of expressions, with the new order and
    // any new inner swizzles that need to be applied.
    ExpressionArray newArgs;
    newArgs.reserve_exact(swizzleSize);
    for (const ReorderedArgument& reorderedArg : reorderedArgs) {
        std::unique_ptr<Expression> newArg = baseArguments[reorderedArg.fArgIndex]->clone();
 
        if (reorderedArg.fComponents.empty()) {
            newArgs.push_back(std::move(newArg));
        } else {
            newArgs.push_back(Swizzle::Make(context, pos, std::move(newArg),
                                            reorderedArg.fComponents));
        }
    }
 
    // Wrap the new argument list in a compound constructor.
    return ConstructorCompound::Make(context,
                                     pos,
                                     componentType.toCompound(context, swizzleSize, /*rows=*/1),
                                     std::move(newArgs));
}

◆ optimize_intrinsic_call()

static std::unique_ptr< Expression > SkSL::optimize_intrinsic_call	(	const Context &	context,
		Position	pos,
		IntrinsicKind	intrinsic,
		const ExpressionArray &	argArray,
		const Type &	returnType
	)

static

Definition at line 635 of file SkSLFunctionCall.cpp.

                                                                                   {
    // Replace constant variables with their literal values.
    IntrinsicArguments arguments = {};
    SkASSERT(SkToSizeT(argArray.size()) <= arguments.size());
    for (int index = 0; index < argArray.size(); ++index) {
        arguments[index] = ConstantFolder::GetConstantValueForVariable(*argArray[index]);
    }
 
    auto Get = [&](int idx, int col) -> float {
        return *arguments[idx]->getConstantValue(col);
    };
 
    switch (intrinsic) {
        // 8.1 : Angle and Trigonometry Functions
        case k_radians_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_radians);
        case k_degrees_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_degrees);
        case k_sin_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_sin);
        case k_cos_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_cos);
        case k_tan_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_tan);
        case k_sinh_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_sinh);
        case k_cosh_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_cosh);
        case k_tanh_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_tanh);
        case k_asin_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_asin);
        case k_acos_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_acos);
        case k_atan_IntrinsicKind:
            if (argArray.size() == 1) {
                return evaluate_intrinsic<float>(context, arguments, returnType,
                                                 Intrinsics::evaluate_atan);
            } else {
                return evaluate_pairwise_intrinsic(context, arguments, returnType,
                                                   Intrinsics::evaluate_atan2);
            }
        case k_asinh_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_asinh);
 
        case k_acosh_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_acosh);
        case k_atanh_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_atanh);
        // 8.2 : Exponential Functions
        case k_pow_IntrinsicKind:
            return evaluate_pairwise_intrinsic(context, arguments, returnType,
                                               Intrinsics::evaluate_pow);
        case k_exp_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_exp);
        case k_log_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_log);
        case k_exp2_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_exp2);
        case k_log2_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_log2);
        case k_sqrt_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_sqrt);
        case k_inversesqrt_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_inversesqrt);
        // 8.3 : Common Functions
        case k_abs_IntrinsicKind:
            return evaluate_intrinsic_numeric(context, arguments, returnType,
                                              Intrinsics::evaluate_abs);
        case k_sign_IntrinsicKind:
            return Intrinsics::evaluate_sign(context, arguments);
 
        case k_floor_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_floor);
        case k_ceil_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_ceil);
        case k_fract_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_fract);
        case k_mod_IntrinsicKind:
            return evaluate_pairwise_intrinsic(context, arguments, returnType,
                                               Intrinsics::evaluate_mod);
        case k_min_IntrinsicKind:
            return evaluate_pairwise_intrinsic(context, arguments, returnType,
                                               Intrinsics::evaluate_min);
        case k_max_IntrinsicKind:
            return evaluate_pairwise_intrinsic(context, arguments, returnType,
                                               Intrinsics::evaluate_max);
        case k_clamp_IntrinsicKind:
            return evaluate_3_way_intrinsic(context, arguments, returnType,
                                            Intrinsics::evaluate_clamp);
        case k_fma_IntrinsicKind:
            return evaluate_3_way_intrinsic(context, arguments, returnType,
                                            Intrinsics::evaluate_fma);
        case k_saturate_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_saturate);
        case k_mix_IntrinsicKind:
            if (arguments[2]->type().componentType().isBoolean()) {
                const SkSL::Type& numericType = arguments[0]->type().componentType();
 
                if (numericType.isFloat()) {
                    type_check_expression<float>(*arguments[0]);
                    type_check_expression<float>(*arguments[1]);
                } else if (numericType.isInteger()) {
                    type_check_expression<SKSL_INT>(*arguments[0]);
                    type_check_expression<SKSL_INT>(*arguments[1]);
                } else if (numericType.isBoolean()) {
                    type_check_expression<bool>(*arguments[0]);
                    type_check_expression<bool>(*arguments[1]);
                } else {
                    SkDEBUGFAILF("unsupported type %s", numericType.description().c_str());
                    return nullptr;
                }
                return evaluate_n_way_intrinsic(context, arguments[0], arguments[1], arguments[2],
                                                returnType, Intrinsics::evaluate_mix);
            } else {
                return evaluate_3_way_intrinsic(context, arguments, returnType,
                                                Intrinsics::evaluate_mix);
            }
        case k_step_IntrinsicKind:
            return evaluate_pairwise_intrinsic(context, arguments, returnType,
                                               Intrinsics::evaluate_step);
        case k_smoothstep_IntrinsicKind:
            return evaluate_3_way_intrinsic(context, arguments, returnType,
                                            Intrinsics::evaluate_smoothstep);
        case k_trunc_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_trunc);
        case k_round_IntrinsicKind:      // GLSL `round` documents its rounding mode as unspecified
        case k_roundEven_IntrinsicKind:  // and is allowed to behave identically to `roundEven`.
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_round);
        case k_floatBitsToInt_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_floatBitsToInt);
        case k_floatBitsToUint_IntrinsicKind:
            return evaluate_intrinsic<float>(context, arguments, returnType,
                                             Intrinsics::evaluate_floatBitsToUint);
        case k_intBitsToFloat_IntrinsicKind:
            return evaluate_intrinsic<SKSL_INT>(context, arguments, returnType,
                                                Intrinsics::evaluate_intBitsToFloat);
        case k_uintBitsToFloat_IntrinsicKind:
            return evaluate_intrinsic<SKSL_INT>(context, arguments, returnType,
                                                Intrinsics::evaluate_uintBitsToFloat);
        // 8.4 : Floating-Point Pack and Unpack Functions
        case k_packUnorm2x16_IntrinsicKind: {
            auto Pack = [&](int n) -> unsigned int {
                float x = Get(0, n);
                return (int)std::round(Intrinsics::evaluate_clamp(x, 0.0, 1.0) * 65535.0);
            };
            const double packed = ((Pack(0) << 0)  & 0x0000FFFF) |
                                  ((Pack(1) << 16) & 0xFFFF0000);
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                          *context.fTypes.fUInt, &packed);
        }
        case k_packSnorm2x16_IntrinsicKind: {
            auto Pack = [&](int n) -> unsigned int {
                float x = Get(0, n);
                return (int)std::round(Intrinsics::evaluate_clamp(x, -1.0, 1.0) * 32767.0);
            };
            const double packed = ((Pack(0) << 0)  & 0x0000FFFF) |
                                  ((Pack(1) << 16) & 0xFFFF0000);
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                          *context.fTypes.fUInt, &packed);
        }
        case k_packHalf2x16_IntrinsicKind: {
            auto Pack = [&](int n) -> unsigned int {
                return SkFloatToHalf(Get(0, n));
            };
            const double packed = ((Pack(0) << 0)  & 0x0000FFFF) |
                                  ((Pack(1) << 16) & 0xFFFF0000);
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                          *context.fTypes.fUInt, &packed);
        }
        case k_unpackUnorm2x16_IntrinsicKind: {
            SKSL_INT x = *arguments[0]->getConstantValue(0);
            uint16_t a = ((x >> 0)  & 0x0000FFFF);
            uint16_t b = ((x >> 16) & 0x0000FFFF);
            const double unpacked[2] = {double(a) / 65535.0,
                                        double(b) / 65535.0};
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                          *context.fTypes.fFloat2, unpacked);
        }
        case k_unpackSnorm2x16_IntrinsicKind: {
            SKSL_INT x = *arguments[0]->getConstantValue(0);
            int16_t a = ((x >> 0)  & 0x0000FFFF);
            int16_t b = ((x >> 16) & 0x0000FFFF);
            const double unpacked[2] = {Intrinsics::evaluate_clamp(double(a) / 32767.0, -1.0, 1.0),
                                        Intrinsics::evaluate_clamp(double(b) / 32767.0, -1.0, 1.0)};
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                          *context.fTypes.fFloat2, unpacked);
        }
        case k_unpackHalf2x16_IntrinsicKind: {
            SKSL_INT x = *arguments[0]->getConstantValue(0);
            uint16_t a = ((x >> 0)  & 0x0000FFFF);
            uint16_t b = ((x >> 16) & 0x0000FFFF);
            const double unpacked[2] = {SkHalfToFloat(a),
                                        SkHalfToFloat(b)};
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                          *context.fTypes.fFloat2, unpacked);
        }
        // 8.5 : Geometric Functions
        case k_length_IntrinsicKind:
            return Intrinsics::evaluate_length(arguments);
 
        case k_distance_IntrinsicKind:
            return Intrinsics::evaluate_distance(arguments);
 
        case k_dot_IntrinsicKind:
            return Intrinsics::evaluate_dot(arguments);
 
        case k_cross_IntrinsicKind: {
            auto X = [&](int n) -> float { return Get(0, n); };
            auto Y = [&](int n) -> float { return Get(1, n); };
            SkASSERT(arguments[0]->type().columns() == 3);  // the vec2 form is not a real intrinsic
 
            double vec[3] = {X(1) * Y(2) - Y(1) * X(2),
                             X(2) * Y(0) - Y(2) * X(0),
                             X(0) * Y(1) - Y(0) * X(1)};
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                          returnType, vec);
        }
        case k_normalize_IntrinsicKind:
            return Intrinsics::evaluate_normalize(context, arguments);
 
        case k_faceforward_IntrinsicKind:
            return Intrinsics::evaluate_faceforward(context, arguments);
 
        case k_reflect_IntrinsicKind:
            return Intrinsics::evaluate_reflect(context, arguments);
 
        case k_refract_IntrinsicKind:
            return Intrinsics::evaluate_refract(context, arguments);
 
        // 8.6 : Matrix Functions
        case k_matrixCompMult_IntrinsicKind:
            return evaluate_pairwise_intrinsic(context, arguments, returnType,
                                               Intrinsics::evaluate_matrixCompMult);
        case k_transpose_IntrinsicKind: {
            double mat[16];
            int index = 0;
            for (int c = 0; c < returnType.columns(); ++c) {
                for (int r = 0; r < returnType.rows(); ++r) {
                    mat[index++] = Get(0, (returnType.columns() * r) + c);
                }
            }
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                          returnType, mat);
        }
        case k_outerProduct_IntrinsicKind: {
            double mat[16];
            int index = 0;
            for (int c = 0; c < returnType.columns(); ++c) {
                for (int r = 0; r < returnType.rows(); ++r) {
                    mat[index++] = Get(0, r) * Get(1, c);
                }
            }
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                          returnType, mat);
        }
        case k_determinant_IntrinsicKind: {
            float mat[16];
            extract_matrix(arguments[0], mat);
            float determinant;
            switch (arguments[0]->type().slotCount()) {
                case 4:
                    determinant = SkInvert2x2Matrix(mat, /*outMatrix=*/nullptr);
                    break;
                case 9:
                    determinant = SkInvert3x3Matrix(mat, /*outMatrix=*/nullptr);
                    break;
                case 16:
                    determinant = SkInvert4x4Matrix(mat, /*outMatrix=*/nullptr);
                    break;
                default:
                    SkDEBUGFAILF("unsupported type %s", arguments[0]->type().description().c_str());
                    return nullptr;
            }
            return Literal::MakeFloat(arguments[0]->fPosition, determinant, &returnType);
        }
        case k_inverse_IntrinsicKind: {
            float mat[16] = {};
            extract_matrix(arguments[0], mat);
            switch (arguments[0]->type().slotCount()) {
                case 4:
                    if (SkInvert2x2Matrix(mat, mat) == 0.0f) {
                        return nullptr;
                    }
                    break;
                case 9:
                    if (SkInvert3x3Matrix(mat, mat) == 0.0f) {
                        return nullptr;
                    }
                    break;
                case 16:
                    if (SkInvert4x4Matrix(mat, mat) == 0.0f) {
                        return nullptr;
                    }
                    break;
                default:
                    SkDEBUGFAILF("unsupported type %s", arguments[0]->type().description().c_str());
                    return nullptr;
            }
 
            double dmat[16];
            std::copy(mat, mat + std::size(mat), dmat);
            return ConstructorCompound::MakeFromConstants(context, arguments[0]->fPosition,
                                                         returnType, dmat);
        }
        // 8.7 : Vector Relational Functions
        case k_lessThan_IntrinsicKind:
            return optimize_comparison(context, arguments, Intrinsics::compare_lessThan);
 
        case k_lessThanEqual_IntrinsicKind:
            return optimize_comparison(context, arguments, Intrinsics::compare_lessThanEqual);
 
        case k_greaterThan_IntrinsicKind:
            return optimize_comparison(context, arguments, Intrinsics::compare_greaterThan);
 
        case k_greaterThanEqual_IntrinsicKind:
            return optimize_comparison(context, arguments, Intrinsics::compare_greaterThanEqual);
 
        case k_equal_IntrinsicKind:
            return optimize_comparison(context, arguments, Intrinsics::compare_equal);
 
        case k_notEqual_IntrinsicKind:
            return optimize_comparison(context, arguments, Intrinsics::compare_notEqual);
 
        case k_any_IntrinsicKind:
            return coalesce_vector<bool>(arguments, /*startingState=*/false, returnType,
                                         Intrinsics::coalesce_any,
                                         /*finalize=*/nullptr);
        case k_all_IntrinsicKind:
            return coalesce_vector<bool>(arguments, /*startingState=*/true, returnType,
                                         Intrinsics::coalesce_all,
                                         /*finalize=*/nullptr);
        case k_not_IntrinsicKind:
            return evaluate_intrinsic<bool>(context, arguments, returnType,
                                            Intrinsics::evaluate_not);
        default:
            return nullptr;
    }
}

◆ parameters_match()

static bool SkSL::parameters_match	(	SkSpan< const std::unique_ptr< Variable > >	params,
		SkSpan< Variable *const >	otherParams
	)

static

Checks a parameter list (params) against the parameters of a function that was declared earlier (otherParams). Returns true if they match, even if the parameters in otherParams contain generic types.

Definition at line 294 of file SkSLFunctionDeclaration.cpp.

                                                                  {
    // If the param lists are different lengths, they're definitely not a match.
    if (params.size() != otherParams.size()) {
        return false;
    }
 
    // Figure out a consistent generic index (or bail if we find a contradiction).
    int genericIndex = -1;
    for (size_t i = 0; i < params.size(); ++i) {
        const Type* paramType = &params[i]->type();
        const Type* otherParamType = &otherParams[i]->type();
 
        if (otherParamType->isGeneric()) {
            int genericIndexForThisParam = find_generic_index(*paramType, *otherParamType,
                                                              /*allowNarrowing=*/false);
            if (genericIndexForThisParam == -1) {
                // The type wasn't a match for this generic at all; these params can't be a match.
                return false;
            }
            if (genericIndex != -1 && genericIndex != genericIndexForThisParam) {
                // The generic index mismatches from what we determined on a previous parameter.
                return false;
            }
            genericIndex = genericIndexForThisParam;
        }
    }
 
    // Now that we've determined a generic index (if we needed one), do a parameter check.
    for (size_t i = 0; i < params.size(); i++) {
        const Type* paramType = &params[i]->type();
        const Type* otherParamType = &otherParams[i]->type();
 
        // Make generic types concrete.
        if (otherParamType->isGeneric()) {
            SkASSERT(genericIndex != -1);
            SkASSERT(genericIndex < (int)otherParamType->coercibleTypes().size());
            otherParamType = otherParamType->coercibleTypes()[genericIndex];
        }
        // Detect type mismatches.
        if (!paramType->matches(*otherParamType)) {
            return false;
        }
    }
    return true;
}

◆ parse_modifier_token()

static ModifierFlags SkSL::parse_modifier_token ( Token::Kind token )

static

Definition at line 77 of file SkSLParser.cpp.

                                                           {
    switch (token) {
        case Token::Kind::TK_UNIFORM:        return ModifierFlag::kUniform;
        case Token::Kind::TK_CONST:          return ModifierFlag::kConst;
        case Token::Kind::TK_IN:             return ModifierFlag::kIn;
        case Token::Kind::TK_OUT:            return ModifierFlag::kOut;
        case Token::Kind::TK_INOUT:          return ModifierFlag::kIn | ModifierFlag::kOut;
        case Token::Kind::TK_FLAT:           return ModifierFlag::kFlat;
        case Token::Kind::TK_NOPERSPECTIVE:  return ModifierFlag::kNoPerspective;
        case Token::Kind::TK_PURE:           return ModifierFlag::kPure;
        case Token::Kind::TK_INLINE:         return ModifierFlag::kInline;
        case Token::Kind::TK_NOINLINE:       return ModifierFlag::kNoInline;
        case Token::Kind::TK_HIGHP:          return ModifierFlag::kHighp;
        case Token::Kind::TK_MEDIUMP:        return ModifierFlag::kMediump;
        case Token::Kind::TK_LOWP:           return ModifierFlag::kLowp;
        case Token::Kind::TK_EXPORT:         return ModifierFlag::kExport;
        case Token::Kind::TK_ES3:            return ModifierFlag::kES3;
        case Token::Kind::TK_WORKGROUP:      return ModifierFlag::kWorkgroup;
        case Token::Kind::TK_READONLY:       return ModifierFlag::kReadOnly;
        case Token::Kind::TK_WRITEONLY:      return ModifierFlag::kWriteOnly;
        case Token::Kind::TK_BUFFER:         return ModifierFlag::kBuffer;
        case Token::Kind::TK_PIXELLOCAL:     return ModifierFlag::kPixelLocal;
        default:                             return ModifierFlag::kNone;
    }
}

◆ pass_by_reference()

static bool SkSL::pass_by_reference	(	const Type &	type,
		ModifierFlags	flags
	)

static

Definition at line 549 of file SkSLMetalCodeGenerator.cpp.

                                                                     {
    return (flags & ModifierFlag::kOut) && !type.isUnsizedArray();
}

◆ pick_by_type()

template<typename T >

static T SkSL::pick_by_type	(	const Type &	type,
		T	ifFloat,
		T	ifInt,
		T	ifUInt,
		T	ifBool
	)

static

Definition at line 932 of file SkSLSPIRVCodeGenerator.cpp.

                                                                                {
    if (is_float(type)) {
        return ifFloat;
    }
    if (is_signed(type)) {
        return ifInt;
    }
    if (is_unsigned(type)) {
        return ifUInt;
    }
    if (is_bool(type)) {
        return ifBool;
    }
    SkDEBUGFAIL("unrecognized type");
    return ifFloat;
}

◆ pun_value()

template<typename T1 , typename T2 >

static double SkSL::pun_value ( double val )

static

Definition at line 346 of file SkSLFunctionCall.cpp.

                                    {
    // Interpret `val` as a value of type T1.
    static_assert(sizeof(T1) == sizeof(T2));
    T1 inputValue = (T1)val;
    // Reinterpret those bits as a value of type T2.
    T2 outputValue;
    memcpy(&outputValue, &inputValue, sizeof(T2));
    // Return the value-of-type-T2 as a double. (Non-finite values will prohibit optimization.)
    return (double)outputValue;
}

◆ range_of_at_least_one_char()

static Position SkSL::range_of_at_least_one_char	(	int	start,
		int	end
	)

static

Definition at line 1580 of file SkSLParser.cpp.

                                                               {
    return Position::Range(start, std::max(end, start + 1));
}

◆ remove_break_statements()

static void SkSL::remove_break_statements ( std::unique_ptr< Statement > & stmt )

static

Definition at line 66 of file SkSLSwitchStatement.cpp.

                                                                    {
    class RemoveBreaksWriter : public ProgramWriter {
    public:
        bool visitStatementPtr(std::unique_ptr<Statement>& stmt) override {
            if (stmt->is<BreakStatement>()) {
                stmt = Nop::Make();
                return false;
            }
            return ProgramWriter::visitStatementPtr(stmt);
        }
 
        bool visitExpressionPtr(std::unique_ptr<Expression>& expr) override {
            return false;
        }
    };
    RemoveBreaksWriter{}.visitStatementPtr(stmt);
}

◆ replace_empty_with_nop()

static std::unique_ptr< Statement > SkSL::replace_empty_with_nop	(	std::unique_ptr< Statement >	stmt,
		bool	isEmpty
	)

static

Definition at line 51 of file SkSLIfStatement.cpp.

                                                                       {
    return (stmt && (!isEmpty || stmt->is<Nop>())) ? std::move(stmt)
                                                   : Nop::Make();
}

◆ set_thread_local_memory_pool()

static void SkSL::set_thread_local_memory_pool ( MemoryPool * memPool )

static

Definition at line 22 of file SkSLPool.cpp.

                                                              {
    sMemPool = memPool;
}

◆ short_circuit_boolean()

static std::unique_ptr< Expression > SkSL::short_circuit_boolean	(	Position	pos,
		const Expression &	left,
		Operator	op,
		const Expression &	right
	)

static

Definition at line 71 of file SkSLConstantFolder.cpp.

                                                                                  {
    bool leftVal = left.as<Literal>().boolValue();
 
    // When the literal is on the left, we can sometimes eliminate the other expression entirely.
    if ((op.kind() == Operator::Kind::LOGICALAND && !leftVal) ||  // (false && expr) -> (false)
        (op.kind() == Operator::Kind::LOGICALOR  && leftVal)) {   // (true  || expr) -> (true)
 
        return left.clone(pos);
    }
 
    // We can't eliminate the right-side expression via short-circuit, but we might still be able to
    // simplify away a no-op expression.
    return eliminate_no_op_boolean(pos, right, op, left);
}

◆ simplify_arithmetic()

static std::unique_ptr< Expression > SkSL::simplify_arithmetic	(	const Context &	context,
		Position	pos,
		const Expression &	left,
		Operator	op,
		const Expression &	right,
		const Type &	resultType
	)

static

Definition at line 480 of file SkSLConstantFolder.cpp.

                                                                               {
    switch (op.kind()) {
        case Operator::Kind::PLUS:
            if (!is_scalar_op_matrix(left, right) &&
                ConstantFolder::IsConstantSplat(right, 0.0)) {  // x + 0
                if (std::unique_ptr<Expression> expr = cast_expression(context, pos, left,
                                                                       resultType)) {
                    return expr;
                }
            }
            if (!is_matrix_op_scalar(left, right) &&
                ConstantFolder::IsConstantSplat(left, 0.0)) {  // 0 + x
                if (std::unique_ptr<Expression> expr = cast_expression(context, pos, right,
                                                                       resultType)) {
                    return expr;
                }
            }
            break;
 
        case Operator::Kind::STAR:
            if (is_constant_value(right, 1.0)) {  // x * 1
                if (std::unique_ptr<Expression> expr = cast_expression(context, pos, left,
                                                                       resultType)) {
                    return expr;
                }
            }
            if (is_constant_value(left, 1.0)) {   // 1 * x
                if (std::unique_ptr<Expression> expr = cast_expression(context, pos, right,
                                                                       resultType)) {
                    return expr;
                }
            }
            if (is_constant_value(right, 0.0) && !Analysis::HasSideEffects(left)) {  // x * 0
                return zero_expression(context, pos, resultType);
            }
            if (is_constant_value(left, 0.0) && !Analysis::HasSideEffects(right)) {  // 0 * x
                return zero_expression(context, pos, resultType);
            }
            if (is_constant_value(right, -1.0)) {  // x * -1 (to `-x`)
                if (std::unique_ptr<Expression> expr = negate_expression(context, pos, left,
                                                                         resultType)) {
                    return expr;
                }
            }
            if (is_constant_value(left, -1.0)) {  // -1 * x (to `-x`)
                if (std::unique_ptr<Expression> expr = negate_expression(context, pos, right,
                                                                         resultType)) {
                    return expr;
                }
            }
            break;
 
        case Operator::Kind::MINUS:
            if (!is_scalar_op_matrix(left, right) &&
                ConstantFolder::IsConstantSplat(right, 0.0)) {  // x - 0
                if (std::unique_ptr<Expression> expr = cast_expression(context, pos, left,
                                                                       resultType)) {
                    return expr;
                }
            }
            if (!is_matrix_op_scalar(left, right) &&
                ConstantFolder::IsConstantSplat(left, 0.0)) {  // 0 - x
                if (std::unique_ptr<Expression> expr = negate_expression(context, pos, right,
                                                                         resultType)) {
                    return expr;
                }
            }
            break;
 
        case Operator::Kind::SLASH:
            if (!is_scalar_op_matrix(left, right) &&
                ConstantFolder::IsConstantSplat(right, 1.0)) {  // x / 1
                if (std::unique_ptr<Expression> expr = cast_expression(context, pos, left,
                                                                       resultType)) {
                    return expr;
                }
            }
            if (!left.type().isMatrix()) {  // convert `x / 2` into `x * 0.5`
                if (std::unique_ptr<Expression> expr = make_reciprocal_expression(context, right)) {
                    return BinaryExpression::Make(context, pos, left.clone(), Operator::Kind::STAR,
                                                  std::move(expr));
                }
            }
            break;
 
        case Operator::Kind::PLUSEQ:
        case Operator::Kind::MINUSEQ:
            if (ConstantFolder::IsConstantSplat(right, 0.0)) {  // x += 0, x -= 0
                if (std::unique_ptr<Expression> var = cast_expression(context, pos, left,
                                                                      resultType)) {
                    Analysis::UpdateVariableRefKind(var.get(), VariableRefKind::kRead);
                    return var;
                }
            }
            break;
 
        case Operator::Kind::STAREQ:
            if (is_constant_value(right, 1.0)) {  // x *= 1
                if (std::unique_ptr<Expression> var = cast_expression(context, pos, left,
                                                                      resultType)) {
                    Analysis::UpdateVariableRefKind(var.get(), VariableRefKind::kRead);
                    return var;
                }
            }
            break;
 
        case Operator::Kind::SLASHEQ:
            if (ConstantFolder::IsConstantSplat(right, 1.0)) {  // x /= 1
                if (std::unique_ptr<Expression> var = cast_expression(context, pos, left,
                                                                      resultType)) {
                    Analysis::UpdateVariableRefKind(var.get(), VariableRefKind::kRead);
                    return var;
                }
            }
            if (std::unique_ptr<Expression> expr = make_reciprocal_expression(context, right)) {
                return BinaryExpression::Make(context, pos, left.clone(), Operator::Kind::STAREQ,
                                              std::move(expr));
            }
            break;
 
        default:
            break;
    }
 
    return nullptr;
}

◆ simplify_componentwise()

static std::unique_ptr< Expression > SkSL::simplify_componentwise	(	const Context &	context,
		Position	pos,
		const Expression &	left,
		Operator	op,
		const Expression &	right
	)

static

Definition at line 215 of file SkSLConstantFolder.cpp.

                                                                                   {
    SkASSERT(is_vec_or_mat(left.type()));
    SkASSERT(left.type().matches(right.type()));
    const Type& type = left.type();
 
    // Handle equality operations: == !=
    if (std::unique_ptr<Expression> result = simplify_constant_equality(context, pos, left, op,
            right)) {
        return result;
    }
 
    // Handle floating-point arithmetic: + - * /
    using FoldFn = double (*)(double, double);
    FoldFn foldFn;
    switch (op.kind()) {
        case Operator::Kind::PLUS:  foldFn = +[](double a, double b) { return a + b; }; break;
        case Operator::Kind::MINUS: foldFn = +[](double a, double b) { return a - b; }; break;
        case Operator::Kind::STAR:  foldFn = +[](double a, double b) { return a * b; }; break;
        case Operator::Kind::SLASH: foldFn = +[](double a, double b) { return a / b; }; break;
        default:
            return nullptr;
    }
 
    const Type& componentType = type.componentType();
    SkASSERT(componentType.isNumber());
 
    double minimumValue = componentType.minimumValue();
    double maximumValue = componentType.maximumValue();
 
    double args[16];
    int numSlots = type.slotCount();
    for (int i = 0; i < numSlots; i++) {
        double value = foldFn(*left.getConstantValue(i), *right.getConstantValue(i));
        if (value < minimumValue || value > maximumValue) {
            return nullptr;
        }
        args[i] = value;
    }
    return ConstructorCompound::MakeFromConstants(context, pos, type, args);
}

◆ simplify_constant_equality()

static std::unique_ptr< Expression > SkSL::simplify_constant_equality	(	const Context &	context,
		Position	pos,
		const Expression &	left,
		Operator	op,
		const Expression &	right
	)

static

Definition at line 89 of file SkSLConstantFolder.cpp.

                                                                                       {
    if (op.kind() == Operator::Kind::EQEQ || op.kind() == Operator::Kind::NEQ) {
        bool equality = (op.kind() == Operator::Kind::EQEQ);
 
        switch (left.compareConstant(right)) {
            case Expression::ComparisonResult::kNotEqual:
                equality = !equality;
                [[fallthrough]];
 
            case Expression::ComparisonResult::kEqual:
                return Literal::MakeBool(context, pos, equality);
 
            case Expression::ComparisonResult::kUnknown:
                break;
        }
    }
    return nullptr;
}

◆ simplify_matrix_division()

static std::unique_ptr< Expression > SkSL::simplify_matrix_division	(	const Context &	context,
		Position	pos,
		const Expression &	left,
		Operator	op,
		const Expression &	right,
		const Type &	resultType
	)

static

Definition at line 625 of file SkSLConstantFolder.cpp.

                                                                                    {
    // Convert matrix-over-scalar `x /= y` into `x *= (1.0 / y)`. This generates better
    // code in SPIR-V and Metal, and should be roughly equivalent elsewhere.
    switch (op.kind()) {
        case OperatorKind::SLASH:
        case OperatorKind::SLASHEQ:
            if (left.type().isMatrix() && right.type().isScalar()) {
                Operator multiplyOp = op.isAssignment() ? OperatorKind::STAREQ
                                                        : OperatorKind::STAR;
                return BinaryExpression::Make(context, pos,
                                              left.clone(),
                                              multiplyOp,
                                              one_over_scalar(context, right));
            }
            break;
 
        default:
            break;
    }
 
    return nullptr;
}

◆ simplify_matrix_multiplication()

static std::unique_ptr< Expression > SkSL::simplify_matrix_multiplication	(	const Context &	context,
		Position	pos,
		const Expression &	left,
		const Expression &	right,
		int	leftColumns,
		int	leftRows,
		int	rightColumns,
		int	rightRows
	)

static

Definition at line 112 of file SkSLConstantFolder.cpp.

                                                                                 {
    const Type& componentType = left.type().componentType();
    SkASSERT(componentType.matches(right.type().componentType()));
 
    // Fetch the left matrix.
    double leftVals[4][4];
    for (int c = 0; c < leftColumns; ++c) {
        for (int r = 0; r < leftRows; ++r) {
            leftVals[c][r] = *left.getConstantValue((c * leftRows) + r);
        }
    }
    // Fetch the right matrix.
    double rightVals[4][4];
    for (int c = 0; c < rightColumns; ++c) {
        for (int r = 0; r < rightRows; ++r) {
            rightVals[c][r] = *right.getConstantValue((c * rightRows) + r);
        }
    }
 
    SkASSERT(leftColumns == rightRows);
    int outColumns   = rightColumns,
        outRows      = leftRows;
 
    double args[16];
    int argIndex = 0;
    for (int c = 0; c < outColumns; ++c) {
        for (int r = 0; r < outRows; ++r) {
            // Compute a dot product for this position.
            double val = 0;
            for (int dotIdx = 0; dotIdx < leftColumns; ++dotIdx) {
                val += leftVals[dotIdx][r] * rightVals[c][dotIdx];
            }
 
            if (val >= -FLT_MAX && val <= FLT_MAX) {
                args[argIndex++] = val;
            } else {
                // The value is outside the 32-bit float range, or is NaN; do not optimize.
                return nullptr;
            }
        }
    }
 
    if (outColumns == 1) {
        // Matrix-times-vector conceptually makes a 1-column N-row matrix, but we return vecN.
        std::swap(outColumns, outRows);
    }
 
    const Type& resultType = componentType.toCompound(context, outColumns, outRows);
    return ConstructorCompound::MakeFromConstants(context, pos, resultType, args);
}

◆ simplify_matrix_times_matrix()

static std::unique_ptr< Expression > SkSL::simplify_matrix_times_matrix	(	const Context &	context,
		Position	pos,
		const Expression &	left,
		const Expression &	right
	)

static

Definition at line 170 of file SkSLConstantFolder.cpp.

                                                                                         {
    const Type& leftType = left.type();
    const Type& rightType = right.type();
 
    SkASSERT(leftType.isMatrix());
    SkASSERT(rightType.isMatrix());
 
    return simplify_matrix_multiplication(context, pos, left, right,
                                          leftType.columns(), leftType.rows(),
                                          rightType.columns(), rightType.rows());
}

◆ simplify_matrix_times_vector()

static std::unique_ptr< Expression > SkSL::simplify_matrix_times_vector	(	const Context &	context,
		Position	pos,
		const Expression &	left,
		const Expression &	right
	)

static

Definition at line 200 of file SkSLConstantFolder.cpp.

                                                                                         {
    const Type& leftType = left.type();
    const Type& rightType = right.type();
 
    SkASSERT(leftType.isMatrix());
    SkASSERT(rightType.isVector());
 
    return simplify_matrix_multiplication(context, pos, left, right,
                                          leftType.columns(), leftType.rows(),
                                          /*rightColumns=*/1, /*rightRows=*/rightType.columns());
}

◆ simplify_negation()

static std::unique_ptr< Expression > SkSL::simplify_negation	(	const Context &	context,
		Position	pos,
		const Expression &	originalExpr
	)

static

Definition at line 71 of file SkSLPrefixExpression.cpp.

                                                                                     {
    const Expression* value = ConstantFolder::GetConstantValueForVariable(originalExpr);
    switch (value->kind()) {
        case Expression::Kind::kLiteral:
        case Expression::Kind::kConstructorSplat:
        case Expression::Kind::kConstructorCompound: {
            // Convert `-vecN(literal, ...)` into `vecN(-literal, ...)`.
            if (std::unique_ptr<Expression> expr = apply_to_elements(context, pos, *value,
                                                                     negate_value)) {
                return expr;
            }
            break;
        }
        case Expression::Kind::kPrefix: {
            // Convert `-(-expression)` into `expression`.
            const PrefixExpression& prefix = value->as<PrefixExpression>();
            if (prefix.getOperator().kind() == Operator::Kind::MINUS) {
                return prefix.operand()->clone(pos);
            }
            break;
        }
        case Expression::Kind::kConstructorArray:
            // Convert `-array[N](literal, ...)` into `array[N](-literal, ...)`.
            if (Analysis::IsCompileTimeConstant(*value)) {
                const ConstructorArray& ctor = value->as<ConstructorArray>();
                return ConstructorArray::Make(context, pos, ctor.type(),
                                              negate_operands(context, pos, ctor.arguments()));
            }
            break;
 
        case Expression::Kind::kConstructorDiagonalMatrix:
            // Convert `-matrix(literal)` into `matrix(-literal)`.
            if (Analysis::IsCompileTimeConstant(*value)) {
                const ConstructorDiagonalMatrix& ctor = value->as<ConstructorDiagonalMatrix>();
                if (std::unique_ptr<Expression> simplified = simplify_negation(context,
                                                                               pos,
                                                                               *ctor.argument())) {
                    return ConstructorDiagonalMatrix::Make(context, pos, ctor.type(),
                                                           std::move(simplified));
                }
            }
            break;
 
        default:
            break;
    }
    return nullptr;
}

◆ simplify_vector_times_matrix()

static std::unique_ptr< Expression > SkSL::simplify_vector_times_matrix	(	const Context &	context,
		Position	pos,
		const Expression &	left,
		const Expression &	right
	)

static

Definition at line 185 of file SkSLConstantFolder.cpp.

                                                                                         {
    const Type& leftType = left.type();
    const Type& rightType = right.type();
 
    SkASSERT(leftType.isVector());
    SkASSERT(rightType.isMatrix());
 
    return simplify_matrix_multiplication(context, pos, left, right,
                                          /*leftColumns=*/leftType.columns(), /*leftRows=*/1,
                                          rightType.columns(), rightType.rows());
}

◆ SPIRVtoHLSL()

bool SkSL::SPIRVtoHLSL	(	const std::string &	,
		std::string *
	)

Definition at line 47 of file SkSLSPIRVtoHLSL.cpp.

47{ bool SPIRVtoHLSL(const std::string&, std::string*) { return false; } }

SkSL::SPIRVtoHLSL

bool SPIRVtoHLSL(const std::string &, std::string *)

Definition: SkSLSPIRVtoHLSL.cpp:47

◆ splat_scalar()

static std::unique_ptr< Expression > SkSL::splat_scalar	(	const Context &	context,
		const Expression &	scalar,
		const Type &	type
	)

static

Definition at line 260 of file SkSLConstantFolder.cpp.

                                                                  {
    if (type.isVector()) {
        return ConstructorSplat::Make(context, scalar.fPosition, type, scalar.clone());
    }
    if (type.isMatrix()) {
        int numSlots = type.slotCount();
        ExpressionArray splatMatrix;
        splatMatrix.reserve_exact(numSlots);
        for (int index = 0; index < numSlots; ++index) {
            splatMatrix.push_back(scalar.clone());
        }
        return ConstructorCompound::Make(context, scalar.fPosition, type, std::move(splatMatrix));
    }
    SkDEBUGFAILF("unsupported type %s", type.description().c_str());
    return nullptr;
}

◆ stod()

bool SkSL::stod	(	std::string_view	s,
		SKSL_FLOAT *	value
	)

Definition at line 58 of file SkSLString.cpp.

                                                   {
    std::string str(s.data(), s.size());
    std::stringstream buffer(str);
    buffer.imbue(std::locale::classic());
    buffer >> *value;
    return !buffer.fail() && std::isfinite(*value);
}

◆ stoi()

bool SkSL::stoi	(	std::string_view	s,
		SKSL_INT *	value
	)

Definition at line 66 of file SkSLString.cpp.

                                                 {
    if (s.empty()) {
        return false;
    }
    char suffix = s.back();
    if (suffix == 'u' || suffix == 'U') {
        s.remove_suffix(1);
    }
    std::string str(s);  // s is not null-terminated
    const char* strEnd = str.data() + str.length();
    char* p;
    errno = 0;
    unsigned long long result = strtoull(str.data(), &p, /*base=*/0);
    *value = static_cast<SKSL_INT>(result);
    return p == strEnd && errno == 0 && result <= 0xFFFFFFFF;
}

◆ strip_export_flag()

static void SkSL::strip_export_flag	(	Context &	context,
		const FunctionDeclaration *	funcDecl,
		SymbolTable *	symbols
	)

static

Definition at line 42 of file SkSLRenamePrivateSymbols.cpp.

                                                    {
    // Remove `$export` from every overload of this function.
    Symbol* mutableSym = symbols->findMutable(funcDecl->name());
    while (mutableSym) {
        FunctionDeclaration* mutableDecl = &mutableSym->as<FunctionDeclaration>();
 
        ModifierFlags flags = mutableDecl->modifierFlags();
        flags &= ~ModifierFlag::kExport;
        mutableDecl->setModifierFlags(flags);
 
        mutableSym = mutableDecl->mutableNextOverload();
    }
}

◆ ToGLSL() [1/2]

bool SkSL::ToGLSL	(	Program &	program,
		const ShaderCaps *	caps,
		OutputStream &	out
	)

Converts a Program into GLSL code.

Definition at line 2034 of file SkSLGLSLCodeGenerator.cpp.

                                                                         {
    TRACE_EVENT0("skia.shaders", "SkSL::ToGLSL");
    SkASSERT(caps != nullptr);
 
    program.fContext->fErrors->setSource(*program.fSource);
    GLSLCodeGenerator cg(program.fContext.get(), caps, &program, &out);
    bool result = cg.generateCode();
    program.fContext->fErrors->setSource(std::string_view());
 
    return result;
}

◆ ToGLSL() [2/2]

bool SkSL::ToGLSL	(	Program &	program,
		const ShaderCaps *	caps,
		std::string *	out
	)

Definition at line 2046 of file SkSLGLSLCodeGenerator.cpp.

                                                                      {
    StringStream buffer;
    if (!ToGLSL(program, caps, buffer)) {
        return false;
    }
    *out = buffer.str();
    return true;
}

◆ ToHLSL() [1/2]

bool SkSL::ToHLSL	(	Program &	program,
		const ShaderCaps *	caps,
		OutputStream &	out
	)

Converts a Program into HLSL code. (SPIRV-Cross must be enabled.)

Definition at line 26 of file SkSLHLSLCodeGenerator.cpp.

                                                                         {
    TRACE_EVENT0("skia.shaders", "SkSL::ToHLSL");
    std::string hlsl;
    if (!ToHLSL(program, caps, &hlsl)) {
        return false;
    }
    out.writeString(hlsl);
    return true;
}

◆ ToHLSL() [2/2]

bool SkSL::ToHLSL	(	Program &	program,
		const ShaderCaps *	caps,
		std::string *	out
	)

Definition at line 36 of file SkSLHLSLCodeGenerator.cpp.

                                                                      {
    std::string spirv;
    if (!ToSPIRV(program, caps, &spirv)) {
        return false;
    }
    if (!SPIRVtoHLSL(spirv, out)) {
        program.fContext->fErrors->error(Position(), "HLSL cross-compilation not enabled");
        return false;
    }
    return true;
}

◆ ToMetal() [1/2]

bool SkSL::ToMetal	(	Program &	program,
		const ShaderCaps *	caps,
		OutputStream &	out
	)

Converts a Program into Metal code.

Definition at line 3653 of file SkSLMetalCodeGenerator.cpp.

                                                                          {
    TRACE_EVENT0("skia.shaders", "SkSL::ToMetal");
    SkASSERT(caps != nullptr);
 
    program.fContext->fErrors->setSource(*program.fSource);
    MetalCodeGenerator cg(program.fContext.get(), caps, &program, &out);
    bool result = cg.generateCode();
    program.fContext->fErrors->setSource(std::string_view());
 
    return result;
}

◆ ToMetal() [2/2]

bool SkSL::ToMetal	(	Program &	program,
		const ShaderCaps *	caps,
		std::string *	out
	)

Definition at line 3665 of file SkSLMetalCodeGenerator.cpp.

                                                                       {
    StringStream buffer;
    if (!ToMetal(program, caps, buffer)) {
        return false;
    }
    *out = buffer.str();
    return true;
}

◆ ToSPIRV() [1/2]

bool SkSL::ToSPIRV	(	Program &	program,
		const ShaderCaps *	caps,
		OutputStream &	out
	)

Converts a Program into a SPIR-V binary.

Definition at line 5408 of file SkSLSPIRVCodeGenerator.cpp.

                                                                          {
    TRACE_EVENT0("skia.shaders", "SkSL::ToSPIRV");
    SkASSERT(caps != nullptr);
 
    program.fContext->fErrors->setSource(*program.fSource);
#ifdef SK_ENABLE_SPIRV_VALIDATION
    StringStream buffer;
    SPIRVCodeGenerator cg(program.fContext.get(), caps, &program, &buffer);
    bool result = cg.generateCode();
 
    if (result && program.fConfig->fSettings.fValidateSPIRV) {
        std::string_view binary = buffer.str();
        result = validate_spirv(*program.fContext->fErrors, binary);
        out.write(binary.data(), binary.size());
    }
#else
    SPIRVCodeGenerator cg(program.fContext.get(), caps, &program, &out);
    bool result = cg.generateCode();
#endif
    program.fContext->fErrors->setSource(std::string_view());
 
    return result;
}

◆ ToSPIRV() [2/2]

bool SkSL::ToSPIRV	(	Program &	program,
		const ShaderCaps *	caps,
		std::string *	out
	)

Definition at line 5432 of file SkSLSPIRVCodeGenerator.cpp.

                                                                       {
    StringStream buffer;
    if (!ToSPIRV(program, caps, buffer)) {
        return false;
    }
    *out = buffer.str();
    return true;
}

◆ ToWGSL() [1/2]

bool SkSL::ToWGSL	(	Program &	program,
		const ShaderCaps *	caps,
		OutputStream &	out
	)

Convert a Program into WGSL code.

Definition at line 4597 of file SkSLWGSLCodeGenerator.cpp.

                                                                         {
    TRACE_EVENT0("skia.shaders", "SkSL::ToWGSL");
    SkASSERT(caps != nullptr);
 
    program.fContext->fErrors->setSource(*program.fSource);
#ifdef SK_ENABLE_WGSL_VALIDATION
    StringStream wgsl;
    WGSLCodeGenerator cg(program.fContext.get(), caps, &program, &wgsl);
    bool result = cg.generateCode();
    if (result) {
        std::string wgslString = wgsl.str();
        std::string warnings;
        result = validate_wgsl(*program.fContext->fErrors, wgslString, &warnings);
        if (!warnings.empty()) {
            out.writeText("/* Tint reported warnings. */\n\n");
        }
        out.writeString(wgslString);
    }
#else
    WGSLCodeGenerator cg(program.fContext.get(), caps, &program, &out);
    bool result = cg.generateCode();
#endif
    program.fContext->fErrors->setSource(std::string_view());
 
    return result;
}

◆ ToWGSL() [2/2]

bool SkSL::ToWGSL	(	Program &	program,
		const ShaderCaps *	caps,
		std::string *	out
	)

Definition at line 4624 of file SkSLWGSLCodeGenerator.cpp.

                                                                      {
    StringStream buffer;
    if (!ToWGSL(program, caps, buffer)) {
        return false;
    }
    *out = buffer.str();
    return true;
}

◆ type_check_expression()

template<typename T >

static void SkSL::type_check_expression ( const Expression & expr )

static

◆ type_check_expression< bool >()

template<>

void SkSL::type_check_expression< bool > ( const Expression & expr )

Definition at line 77 of file SkSLFunctionCall.cpp.

                                                         {
    SkASSERT(expr.type().componentType().isBoolean());
}

◆ type_check_expression< float >()

template<>

void SkSL::type_check_expression< float > ( const Expression & expr )

Definition at line 67 of file SkSLFunctionCall.cpp.

                                                          {
    SkASSERT(expr.type().componentType().isFloat());
}

◆ type_check_expression< SKSL_INT >()

template<>

void SkSL::type_check_expression< SKSL_INT > ( const Expression & expr )

Definition at line 72 of file SkSLFunctionCall.cpp.

                                                             {
    SkASSERT(expr.type().componentType().isInteger());
}

◆ type_generically_matches()

static bool SkSL::type_generically_matches	(	const Type &	concreteType,
		const Type &	maybeGenericType
	)

static

Returns true if the types match, or if concreteType can be found in maybeGenericType.

Definition at line 283 of file SkSLFunctionDeclaration.cpp.

                                                                                             {
    return maybeGenericType.isGeneric()
                ? find_generic_index(concreteType, maybeGenericType, /*allowNarrowing=*/false) != -1
                : concreteType.matches(maybeGenericType);
}

◆ type_is_valid_for_color()

static bool SkSL::type_is_valid_for_color ( const Type & type )

static

Definition at line 123 of file SkSLFunctionDeclaration.cpp.

                                                      {
    return type.isVector() && type.columns() == 4 && type.componentType().isFloat();
}

◆ type_is_valid_for_coords()

static bool SkSL::type_is_valid_for_coords ( const Type & type )

static

Definition at line 127 of file SkSLFunctionDeclaration.cpp.

                                                       {
    return type.isVector() && type.highPrecision() && type.columns() == 2 &&
           type.componentType().isFloat();
}

◆ type_to_sksltype()

bool SkSL::type_to_sksltype	(	const Context &	context,
		const Type &	type,
		SkSLType *	outType
	)

Definition at line 46 of file SkSLUtil.cpp.

                                                                                   {
    // If a new GrSL type is added, this function will need to be updated.
    static_assert(kSkSLTypeCount == 41);
 
    if (type.matches(*context.fTypes.fVoid    )) { *outType = SkSLType::kVoid;     return true; }
    if (type.matches(*context.fTypes.fBool    )) { *outType = SkSLType::kBool;     return true; }
    if (type.matches(*context.fTypes.fBool2   )) { *outType = SkSLType::kBool2;    return true; }
    if (type.matches(*context.fTypes.fBool3   )) { *outType = SkSLType::kBool3;    return true; }
    if (type.matches(*context.fTypes.fBool4   )) { *outType = SkSLType::kBool4;    return true; }
    if (type.matches(*context.fTypes.fShort   )) { *outType = SkSLType::kShort;    return true; }
    if (type.matches(*context.fTypes.fShort2  )) { *outType = SkSLType::kShort2;   return true; }
    if (type.matches(*context.fTypes.fShort3  )) { *outType = SkSLType::kShort3;   return true; }
    if (type.matches(*context.fTypes.fShort4  )) { *outType = SkSLType::kShort4;   return true; }
    if (type.matches(*context.fTypes.fUShort  )) { *outType = SkSLType::kUShort;   return true; }
    if (type.matches(*context.fTypes.fUShort2 )) { *outType = SkSLType::kUShort2;  return true; }
    if (type.matches(*context.fTypes.fUShort3 )) { *outType = SkSLType::kUShort3;  return true; }
    if (type.matches(*context.fTypes.fUShort4 )) { *outType = SkSLType::kUShort4;  return true; }
    if (type.matches(*context.fTypes.fFloat   )) { *outType = SkSLType::kFloat;    return true; }
    if (type.matches(*context.fTypes.fFloat2  )) { *outType = SkSLType::kFloat2;   return true; }
    if (type.matches(*context.fTypes.fFloat3  )) { *outType = SkSLType::kFloat3;   return true; }
    if (type.matches(*context.fTypes.fFloat4  )) { *outType = SkSLType::kFloat4;   return true; }
    if (type.matches(*context.fTypes.fFloat2x2)) { *outType = SkSLType::kFloat2x2; return true; }
    if (type.matches(*context.fTypes.fFloat3x3)) { *outType = SkSLType::kFloat3x3; return true; }
    if (type.matches(*context.fTypes.fFloat4x4)) { *outType = SkSLType::kFloat4x4; return true; }
    if (type.matches(*context.fTypes.fHalf    )) { *outType = SkSLType::kHalf;     return true; }
    if (type.matches(*context.fTypes.fHalf2   )) { *outType = SkSLType::kHalf2;    return true; }
    if (type.matches(*context.fTypes.fHalf3   )) { *outType = SkSLType::kHalf3;    return true; }
    if (type.matches(*context.fTypes.fHalf4   )) { *outType = SkSLType::kHalf4;    return true; }
    if (type.matches(*context.fTypes.fHalf2x2 )) { *outType = SkSLType::kHalf2x2;  return true; }
    if (type.matches(*context.fTypes.fHalf3x3 )) { *outType = SkSLType::kHalf3x3;  return true; }
    if (type.matches(*context.fTypes.fHalf4x4 )) { *outType = SkSLType::kHalf4x4;  return true; }
    if (type.matches(*context.fTypes.fInt     )) { *outType = SkSLType::kInt;      return true; }
    if (type.matches(*context.fTypes.fInt2    )) { *outType = SkSLType::kInt2;     return true; }
    if (type.matches(*context.fTypes.fInt3    )) { *outType = SkSLType::kInt3;     return true; }
    if (type.matches(*context.fTypes.fInt4    )) { *outType = SkSLType::kInt4;     return true; }
    if (type.matches(*context.fTypes.fUInt    )) { *outType = SkSLType::kUInt;     return true; }
    if (type.matches(*context.fTypes.fUInt2   )) { *outType = SkSLType::kUInt2;    return true; }
    if (type.matches(*context.fTypes.fUInt3   )) { *outType = SkSLType::kUInt3;    return true; }
    if (type.matches(*context.fTypes.fUInt4   )) { *outType = SkSLType::kUInt4;    return true; }
    return false;
}

◆ types_match()

static bool SkSL::types_match	(	const Type &	a,
		const Type &	b
	)

static

Definition at line 3698 of file SkSLSPIRVCodeGenerator.cpp.

                                                      {
    if (a.matches(b)) {
        return true;
    }
    return (a.typeKind() == b.typeKind()) &&
           (a.isScalar() || a.isVector() || a.isMatrix()) &&
           (a.columns() == b.columns() && a.rows() == b.rows()) &&
           a.componentType().numberKind() == b.componentType().numberKind();
}

◆ validate_swizzle_domain()

static bool SkSL::validate_swizzle_domain ( const ComponentArray & fields )

static

Definition at line 34 of file SkSLSwizzle.cpp.

                                                                  {
    enum SwizzleDomain {
        kCoordinate,
        kColor,
        kUV,
        kRectangle,
    };
 
    std::optional<SwizzleDomain> domain;
 
    for (int8_t field : fields) {
        SwizzleDomain fieldDomain;
        switch (field) {
            case SwizzleComponent::X:
            case SwizzleComponent::Y:
            case SwizzleComponent::Z:
            case SwizzleComponent::W:
                fieldDomain = kCoordinate;
                break;
            case SwizzleComponent::R:
            case SwizzleComponent::G:
            case SwizzleComponent::B:
            case SwizzleComponent::A:
                fieldDomain = kColor;
                break;
            case SwizzleComponent::S:
            case SwizzleComponent::T:
            case SwizzleComponent::P:
            case SwizzleComponent::Q:
                fieldDomain = kUV;
                break;
            case SwizzleComponent::UL:
            case SwizzleComponent::UT:
            case SwizzleComponent::UR:
            case SwizzleComponent::UB:
                fieldDomain = kRectangle;
                break;
            case SwizzleComponent::ZERO:
            case SwizzleComponent::ONE:
                continue;
            default:
                return false;
        }
 
        if (!domain.has_value()) {
            domain = fieldDomain;
        } else if (domain != fieldDomain) {
            return false;
        }
    }
 
    return true;
}

◆ write_stringstream()

void SkSL::write_stringstream	(	const StringStream &	s,
		OutputStream &	out
	)

Definition at line 42 of file SkSLUtil.cpp.

                                                                  {
    out.write(s.str().c_str(), s.str().size());
}

◆ zero_expression()

static std::unique_ptr< Expression > SkSL::zero_expression	(	const Context &	context,
		Position	pos,
		const Type &	type
	)

static

Definition at line 299 of file SkSLConstantFolder.cpp.

                                                                     {
    std::unique_ptr<Expression> zero = Literal::Make(pos, 0.0, &type.componentType());
    if (type.isScalar()) {
        return zero;
    }
    if (type.isVector()) {
        return ConstructorSplat::Make(context, pos, type, std::move(zero));
    }
    if (type.isMatrix()) {
        return ConstructorDiagonalMatrix::Make(context, pos, type, std::move(zero));
    }
    SkDEBUGFAILF("unsupported type %s", type.description().c_str());
    return nullptr;
}

Variable Documentation

◆ kAccepts

const uint8_t SkSL::kAccepts[427]

static

Initial value:

= {
        255, 255, 89,  89, 92, 68,  73,  92,  43, 41, 41, 41, 41, 36,  41,  41, 41,  41,  37, 41,
        41,  41,  27,  58, 82, 63,  67,  87,  44, 45, 56, 80, 54, 52,  78,  51, 55,  53,  79, 50,
        1,   255, 255, 1,  57, 255, 255, 91,  90, 81, 2,  1,  1,  255, 255, 1,  255, 255, 1,  2,
        3,   255, 255, 1,  3,  2,   2,   255, 2,  2,  2,  70, 88, 75,  59,  83, 77,  71,  72, 74,
        76,  60,  84,  69, 42, 42,  48,  49,  62, 86, 66, 42, 42, 40,  42,  42, 42,  42,  42, 42,
        42,  42,  42,  42, 42, 42,  42,  42,  14, 42, 42, 42, 42, 30,  42,  42, 42,  12,  42, 42,
        42,  42,  42,  42, 22, 42,  42,  42,  42, 15, 42, 42, 42, 42,  42,  42, 13,  42,  42, 42,
        42,  42,  16,  10, 42, 42,  42,  42,  42, 42, 42, 42, 42, 7,   42,  42, 42,  42,  42, 42,
        40,  42,  42,  42, 42, 42,  5,   42,  42, 42, 42, 42, 23, 42,  8,   42, 42,  42,  42, 42,
        40,  42,  42,  42, 42, 42,  42,  33,  42, 42, 42, 42, 6,  18,  42,  42, 42,  25,  42, 42,
        20,  42,  42,  42, 42, 42,  42,  42,  42, 42, 42, 42, 42, 42,  42,  42, 42,  42,  42, 42,
        32,  42,  42,  42, 35, 42,  42,  42,  42, 42, 42, 34, 42, 42,  42,  42, 42,  42,  42, 42,
        42,  42,  42,  42, 42, 42,  26,  42,  42, 42, 42, 42, 42, 42,  42,  42, 42,  24,  42, 42,
        19,  42,  42,  42, 42, 42,  42,  42,  42, 42, 42, 42, 42, 42,  42,  42, 42,  39,  42, 42,
        42,  42,  42,  42, 42, 42,  42,  42,  42, 42, 42, 42, 42, 42,  42,  42, 28,  42,  42, 42,
        17,  42,  42,  42, 42, 42,  42,  42,  42, 40, 42, 42, 42, 42,  42,  42, 42,  42,  42, 42,
        42,  42,  42,  42, 42, 42,  42,  40,  42, 42, 42, 42, 42, 42,  42,  42, 42,  42,  42, 42,
        42,  42,  42,  42, 42, 31,  42,  42,  42, 42, 42, 42, 42, 42,  11,  42, 42,  42,  42, 42,
        42,  42,  42,  42, 42, 42,  4,   42,  42, 42, 42, 42, 42, 42,  42,  42, 42,  42,  21, 42,
        42,  42,  42,  42, 42, 42,  42,  42,  42, 42, 42, 42, 42, 42,  42,  42, 42,  42,  42, 42,
        42,  42,  42,  42, 9,  42,  42,  42,  42, 42, 42, 42, 38, 42,  42,  42, 42,  42,  42, 42,
        29,  46,  61,  85, 65, 47,  64,
}

Definition at line 775 of file SkSLLexer.cpp.

◆ kCompact

constexpr CompactEntry SkSL::kCompact[]

staticconstexpr

Definition at line 121 of file SkSLLexer.cpp.

◆ kDefaultInlineThreshold

constexpr int SkSL::kDefaultInlineThreshold = 50

staticconstexpr

Definition at line 38 of file SkSLDefines.h.

◆ kDefaultLayout

constexpr Layout SkSL::kDefaultLayout

staticconstexpr

Definition at line 29 of file SkSLVariable.cpp.

◆ kDeterminant2

constexpr char SkSL::kDeterminant2[]

staticconstexpr

Initial value:

= R"(
float _determinant2(mat2 m) {
return m[0].x*m[1].y - m[0].y*m[1].x;
}
)"

Definition at line 475 of file SkSLGLSLCodeGenerator.cpp.

◆ kDeterminant3

constexpr char SkSL::kDeterminant3[]

staticconstexpr

Initial value:

= R"(
float _determinant3(mat3 m) {
float
 a00 = m[0].x, a01 = m[0].y, a02 = m[0].z,
 a10 = m[1].x, a11 = m[1].y, a12 = m[1].z,
 a20 = m[2].x, a21 = m[2].y, a22 = m[2].z,
 b01 = a22*a11 - a12*a21,
 b11 =-a22*a10 + a12*a20,
 b21 = a21*a10 - a11*a20;
return a00*b01 + a01*b11 + a02*b21;
}
)"

Definition at line 481 of file SkSLGLSLCodeGenerator.cpp.

◆ kDeterminant4

constexpr char SkSL::kDeterminant4[]

staticconstexpr

Initial value:

= R"(
mat4 _determinant4(mat4 m) {
float
 a00 = m[0].x, a01 = m[0].y, a02 = m[0].z, a03 = m[0].w,
 a10 = m[1].x, a11 = m[1].y, a12 = m[1].z, a13 = m[1].w,
 a20 = m[2].x, a21 = m[2].y, a22 = m[2].z, a23 = m[2].w,
 a30 = m[3].x, a31 = m[3].y, a32 = m[3].z, a33 = m[3].w,
 b00 = a00*a11 - a01*a10,
 b01 = a00*a12 - a02*a10,
 b02 = a00*a13 - a03*a10,
 b03 = a01*a12 - a02*a11,
 b04 = a01*a13 - a03*a11,
 b05 = a02*a13 - a03*a12,
 b06 = a20*a31 - a21*a30,
 b07 = a20*a32 - a22*a30,
 b08 = a20*a33 - a23*a30,
 b09 = a21*a32 - a22*a31,
 b10 = a21*a33 - a23*a31,
 b11 = a22*a33 - a23*a32;
return b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06;
}
)"

Definition at line 494 of file SkSLGLSLCodeGenerator.cpp.

◆ kFull

constexpr FullEntry SkSL::kFull[]

staticconstexpr

Definition at line 32 of file SkSLLexer.cpp.

◆ kIndices

constexpr IndexEntry SkSL::kIndices[]

staticconstexpr

Initial value:

= {
        0,   -1,  1,   1,   0,   2,   0,   3,   4,   5,   6,   7,   8,   6,   9,   10,  11,  12,
        6,   13,  14,  15,  6,   16,  0,   17,  0,   0,   0,   0,   18,  0,   19,  0,   0,   0,
        20,  0,   0,   21,  22,  23,  24,  24,  25,  26,  27,  0,   28,  0,   -2,  29,  30,  31,
        32,  32,  33,  34,  34,  -3,  -4,  35,  36,  36,  0,   0,   0,   37,  38,  -5,  -5,  0,
        0,   39,  40,  0,   0,   41,  0,   42,  0,   43,  0,   0,   44,  44,  0,   0,   45,  0,
        0,   46,  47,  44,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,
        44,  62,  63,  64,  65,  44,  -6,  66,  67,  44,  68,  69,  70,  71,  72,  73,  44,  74,
        75,  76,  77,  44,  -7,  78,  79,  80,  81,  82,  44,  83,  84,  85,  86,  87,  44,  88,
        89,  90,  57,  91,  92,  93,  -8,  94,  95,  44,  96,  47,  97,  98,  99,  100, 101, 102,
        -9,  103, 104, 105, 44,  106, 107, 108, 109, 110, 44,  111, 44,  112, 113, 93,  114, 115,
        116, 117, 118, 119, 120, 121, 122, 44,  123, 124, 93,  125, 44,  -10, 126, 127, 128, 44,
        129, 130, 44,  131, 132, 133, 134, 135, 136, 137, 57,  138, 139, 140, 141, 142, 132, 143,
        144, 145, 146, 147, 44,  148, 149, 150, 44,  151, 152, 153, 154, 155, 156, 44,  157, 158,
        159, 160, 161, 162, 163, 57,  164, 165, 166, 167, 168, 169, 44,  170, 171, 172, 173, 174,
        175, 176, 177, 178, 179, 44,  180, 181, 182, 183, 132, -11, 184, 185, 186, 108, 187, 188,
        189, 190, 191, 192, 193, 194, 195, 44,  196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
        51,  206, 207, 208, 209, 210, 211, 212, 44,  213, 214, 215, 44,  -12, 216, 217, 218, 219,
        220, -13, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
        237, 227, 238, 239, 240, 241, 132, 242, 243, 57,  244, 245, 246, 247, 248, 249, 250, 51,
        251, 252, 253, 44,  254, 255, 256, 257, 258, 259, 260, 261, 44,  -14, 262, 263, 264, 265,
        266, 57,  267, 70,  268, 269, 44,  270, 271, 272, 273, 247, 274, 275, 276, 277, 278, 279,
        44,  202, 280, 281, 282, 283, 108, 284, 285, 149, 286, 287, 288, 289, 290, 149, 291, 292,
        293, 294, 295, 57,  -15, 296, 297, 298, 44,  299, 300, 301, 302, 303, 304, 305, 44,  306,
        307, 308, 309, 310, 311, 312, 44,  0,   313, 0,   0,   0,   0,
}

Definition at line 737 of file SkSLLexer.cpp.

◆ kInvalidChar

constexpr uint8_t SkSL::kInvalidChar = 18

staticconstexpr

Definition at line 15 of file SkSLLexer.cpp.

◆ kInverse2

constexpr char SkSL::kInverse2[]

staticconstexpr

Initial value:

= R"(
mat2 _inverse2(mat2 m) {
return mat2(m[1].y, -m[0].y, -m[1].x, m[0].x) / (m[0].x * m[1].y - m[0].y * m[1].x);
}
)"

Definition at line 548 of file SkSLGLSLCodeGenerator.cpp.

◆ kInverse2x2 [1/2]

constexpr char SkSL::kInverse2x2[]

staticconstexpr

Initial value:

= R"(
template <typename T>
matrix<T, 2, 2> mat2_inverse(matrix<T, 2, 2> m) {
return matrix<T, 2, 2>(m[1].y, -m[0].y, -m[1].x, m[0].x) * (1/determinant(m));
}
)"

Definition at line 731 of file SkSLMetalCodeGenerator.cpp.

◆ kInverse2x2 [2/2]

constexpr char SkSL::kInverse2x2[]

staticconstexpr

Initial value:

=
     "fn mat2_inverse(m: mat2x2<f32>) -> mat2x2<f32> {"
"\n"     "return mat2x2<f32>(m[1].y, -m[0].y, -m[1].x, m[0].x) * (1/determinant(m));"
"\n" "}"
"\n"

Definition at line 3342 of file SkSLWGSLCodeGenerator.cpp.

◆ kInverse3

constexpr char SkSL::kInverse3[]

staticconstexpr

Initial value:

= R"(
mat3 _inverse3(mat3 m) {
float
 a00 = m[0].x, a01 = m[0].y, a02 = m[0].z,
 a10 = m[1].x, a11 = m[1].y, a12 = m[1].z,
 a20 = m[2].x, a21 = m[2].y, a22 = m[2].z,
 b01 = a22*a11 - a12*a21,
 b11 =-a22*a10 + a12*a20,
 b21 = a21*a10 - a11*a20,
 det = a00*b01 + a01*b11 + a02*b21;
return mat3(
 b01, (-a22*a01 + a02*a21), ( a12*a01 - a02*a11),
 b11, ( a22*a00 - a02*a20), (-a12*a00 + a02*a10),
 b21, (-a21*a00 + a01*a20), ( a11*a00 - a01*a10)) / det;
}
)"

Definition at line 554 of file SkSLGLSLCodeGenerator.cpp.

◆ kInverse3x3 [1/2]

constexpr char SkSL::kInverse3x3[]

staticconstexpr

Initial value:

= R"(
template <typename T>
matrix<T, 3, 3> mat3_inverse(matrix<T, 3, 3> m) {
T
 a00 = m[0].x, a01 = m[0].y, a02 = m[0].z,
 a10 = m[1].x, a11 = m[1].y, a12 = m[1].z,
 a20 = m[2].x, a21 = m[2].y, a22 = m[2].z,
 b01 =  a22*a11 - a12*a21,
 b11 = -a22*a10 + a12*a20,
 b21 =  a21*a10 - a11*a20,
 det = a00*b01 + a01*b11 + a02*b21;
return matrix<T, 3, 3>(
 b01, (-a22*a01 + a02*a21), ( a12*a01 - a02*a11),
 b11, ( a22*a00 - a02*a20), (-a12*a00 + a02*a10),
 b21, (-a21*a00 + a01*a20), ( a11*a00 - a01*a10)) * (1/det);
}
)"

Definition at line 738 of file SkSLMetalCodeGenerator.cpp.

◆ kInverse3x3 [2/2]

constexpr char SkSL::kInverse3x3[]

staticconstexpr

Initial value:

=
     "fn mat3_inverse(m: mat3x3<f32>) -> mat3x3<f32> {"
"\n"     "let a00 = m[0].x; let a01 = m[0].y; let a02 = m[0].z;"
"\n"     "let a10 = m[1].x; let a11 = m[1].y; let a12 = m[1].z;"
"\n"     "let a20 = m[2].x; let a21 = m[2].y; let a22 = m[2].z;"
"\n"     "let b01 =  a22*a11 - a12*a21;"
"\n"     "let b11 = -a22*a10 + a12*a20;"
"\n"     "let b21 =  a21*a10 - a11*a20;"
"\n"     "let det = a00*b01 + a01*b11 + a02*b21;"
"\n"     "return mat3x3<f32>(b01, (-a22*a01 + a02*a21), ( a12*a01 - a02*a11),"
"\n"                        "b11, ( a22*a00 - a02*a20), (-a12*a00 + a02*a10),"
"\n"                        "b21, (-a21*a00 + a01*a20), ( a11*a00 - a01*a10)) * (1/det);"
"\n" "}"
"\n"

Definition at line 3348 of file SkSLWGSLCodeGenerator.cpp.

◆ kInverse4

constexpr char SkSL::kInverse4[]

staticconstexpr

Definition at line 571 of file SkSLGLSLCodeGenerator.cpp.

◆ kInverse4x4 [1/2]

constexpr char SkSL::kInverse4x4[]

staticconstexpr

Definition at line 756 of file SkSLMetalCodeGenerator.cpp.

◆ kInverse4x4 [2/2]

constexpr char SkSL::kInverse4x4[]

staticconstexpr

Definition at line 3363 of file SkSLWGSLCodeGenerator.cpp.

◆ kLoopTerminationLimit

constexpr int SkSL::kLoopTerminationLimit = 100000

staticconstexpr

Definition at line 36 of file SkSLGetLoopUnrollInfo.cpp.

◆ kMappings

constexpr uint8_t SkSL::kMappings[118]

staticconstexpr

Initial value:

= {
        1,  2,  3,  3,  1,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
        3,  3,  3,  1,  4,  3,  5,  6,  7,  8,  3,  9,  10, 11, 12, 13, 14, 15, 16, 17,
        18, 19, 20, 21, 22, 22, 22, 23, 23, 24, 25, 26, 27, 28, 29, 3,  30, 30, 31, 32,
        33, 30, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 36, 34, 37, 34, 34, 38,
        34, 34, 39, 3,  40, 41, 42, 3,  43, 44, 45, 46, 47, 48, 49, 50, 51, 34, 52, 53,
        54, 55, 56, 57, 34, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
}

Definition at line 16 of file SkSLLexer.cpp.

◆ kMaxParseDepth

constexpr int SkSL::kMaxParseDepth = 50

staticconstexpr

Definition at line 75 of file SkSLParser.cpp.

◆ kMaxStructDepth

constexpr int SkSL::kMaxStructDepth = 8

staticconstexpr

Definition at line 40 of file SkSLType.cpp.

◆ kPrivateTypes

constexpr BuiltinTypePtr SkSL::kPrivateTypes[]

staticconstexpr

Initial value:

= {
    TYPE(Sampler2D), TYPE(SamplerExternalOES), TYPE(Sampler2DRect),
 
    TYPE(SubpassInput), TYPE(SubpassInputMS),
 
    TYPE(Sampler),
    TYPE(Texture2D_sample),
    TYPE(Texture2D), TYPE(ReadOnlyTexture2D), TYPE(WriteOnlyTexture2D),
    TYPE(GenTexture2D), TYPE(ReadableTexture2D), TYPE(WritableTexture2D),
 
    TYPE(AtomicUInt),
}

Definition at line 75 of file SkSLModuleLoader.cpp.

◆ kRootTypes

constexpr BuiltinTypePtr SkSL::kRootTypes[]

staticconstexpr

Definition at line 37 of file SkSLModuleLoader.cpp.

◆ kVariableSlotLimit

constexpr int SkSL::kVariableSlotLimit = 100000

staticconstexpr

Definition at line 43 of file SkSLDefines.h.

◆ SKSL_MAGIC

const int32_t SkSL::SKSL_MAGIC = 0x001F0000

static

Definition at line 745 of file SkSLSPIRVCodeGenerator.cpp.

◆ sMemPool

thread_local MemoryPool* SkSL::sMemPool = nullptr

static

Definition at line 16 of file SkSLPool.cpp.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BuiltinTypePtr

◆ CoalesceFn

◆ CompareFn

◆ ComponentArray

◆ EvaluateFn

◆ FinalizeFn

◆ IndexEntry

◆ IntrinsicArguments

◆ IntrinsicMap

◆ LayoutFlags

◆ State

◆ StatementArray

Enumeration Type Documentation

◆ ExpressionKind

◆ FieldAccessOwnerKind

◆ GLSLGeneration

◆ IntrinsicKind

◆ LayoutFlag

◆ ModifierFlag

◆ ModuleName

◆ OperatorKind

◆ OperatorPrecedence

◆ ProgramElementKind

◆ ProgramKind

◆ StatementKind

◆ SymbolKind

◆ VariableRefKind

◆ VariableStorage

◆ Version

Function Documentation

◆ all_arguments_constant()

◆ append_rtadjust_fixup_to_vertex_main()

◆ apply_to_elements()

◆ argument_and_parameter_flags_match()

◆ argument_needs_scratch_variable()

◆ arguments_match_field_types()

◆ binary_op_is_ambiguous_in_wgsl()

◆ bitwise_not_operand()

◆ bitwise_not_value()

◆ block_for_case()

◆ build_argument_type_list()

◆ calculate_count()

◆ call_cost()

◆ call_signature_is_valid()

◆ candidate_func()

◆ cast_constant_array()

◆ cast_constant_composite()

◆ cast_expression()

◆ check_main_signature()

◆ check_modifiers()

◆ check_parameters()

◆ check_return_type()

◆ coalesce_n_way_vector()

◆ coalesce_pairwise_vectors()

◆ coalesce_vector()

◆ compile_and_shrink()

◆ contains_builtin_struct()

◆ contains_constant_zero()

◆ contains_matching_data()

◆ convert_compound_constructor()

◆ count_returns_at_end_of_control_flow()

◆ dead_function_predicate()

◆ eliminate_dead_local_variables()

◆ eliminate_empty_statements()

◆ eliminate_no_op_boolean()

◆ eliminate_unnecessary_braces()

◆ eliminate_unreachable_code()

◆ error_on_divide_by_zero()

◆ evaluate_3_way_intrinsic()

◆ evaluate_intrinsic()

◆ evaluate_intrinsic_numeric()

◆ evaluate_n_way_intrinsic()

◆ evaluate_pairwise_intrinsic()