| /* | |
| * Copyright 2021 Google LLC | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include "src/sksl/SkSLConstantFolder.h" | |
| #include "src/sksl/ir/SkSLIndexExpression.h" | |
| #include "src/sksl/ir/SkSLSwizzle.h" | |
| namespace SkSL { | |
| const Type& IndexExpression::IndexType(const Context& context, const Type& type) { | |
| if (type.isMatrix()) { | |
| if (type.componentType() == *context.fTypes.fFloat) { | |
| switch (type.rows()) { | |
| case 2: return *context.fTypes.fFloat2; | |
| case 3: return *context.fTypes.fFloat3; | |
| case 4: return *context.fTypes.fFloat4; | |
| default: SkASSERT(false); | |
| } | |
| } else if (type.componentType() == *context.fTypes.fHalf) { | |
| switch (type.rows()) { | |
| case 2: return *context.fTypes.fHalf2; | |
| case 3: return *context.fTypes.fHalf3; | |
| case 4: return *context.fTypes.fHalf4; | |
| default: SkASSERT(false); | |
| } | |
| } | |
| } | |
| return type.componentType(); | |
| } | |
| std::unique_ptr<Expression> IndexExpression::Convert(const Context& context, | |
| SymbolTable& symbolTable, | |
| std::unique_ptr<Expression> base, | |
| std::unique_ptr<Expression> index) { | |
| // Convert an array type reference: `int[10]`. | |
| if (base->is<TypeReference>()) { | |
| const Type& baseType = base->as<TypeReference>().value(); | |
| SKSL_INT arraySize = baseType.convertArraySize(context, std::move(index)); | |
| if (!arraySize) { | |
| return nullptr; | |
| } | |
| return std::make_unique<TypeReference>(context, base->fOffset, | |
| symbolTable.addArrayDimension(&baseType, arraySize)); | |
| } | |
| // Convert an index expression with an expression inside of it: `arr[a * 3]`. | |
| const Type& baseType = base->type(); | |
| if (!baseType.isArray() && !baseType.isMatrix() && !baseType.isVector()) { | |
| context.fErrors->error(base->fOffset, | |
| "expected array, but found '" + baseType.displayName() + "'"); | |
| return nullptr; | |
| } | |
| if (!index->type().isInteger()) { | |
| index = context.fTypes.fInt->coerceExpression(std::move(index), context); | |
| if (!index) { | |
| return nullptr; | |
| } | |
| } | |
| // Perform compile-time bounds checking on constant-expression indices. | |
| const Expression* indexExpr = ConstantFolder::GetConstantValueForVariable(*index); | |
| if (indexExpr->isIntLiteral()) { | |
| SKSL_INT indexValue = indexExpr->as<Literal>().intValue(); | |
| if (indexValue < 0 || indexValue >= baseType.columns()) { | |
| context.fErrors->error(base->fOffset, "index " + to_string(indexValue) + | |
| " out of range for '" + baseType.displayName() + | |
| "'"); | |
| return nullptr; | |
| } | |
| } | |
| return IndexExpression::Make(context, std::move(base), std::move(index)); | |
| } | |
| std::unique_ptr<Expression> IndexExpression::Make(const Context& context, | |
| std::unique_ptr<Expression> base, | |
| std::unique_ptr<Expression> index) { | |
| const Type& baseType = base->type(); | |
| SkASSERT(baseType.isArray() || baseType.isMatrix() || baseType.isVector()); | |
| SkASSERT(index->type().isInteger()); | |
| if (context.fConfig->fSettings.fOptimize) { | |
| // Constant array indexes on vectors can be converted to swizzles: `v[2]` --> `v.z`. | |
| // Swizzling is harmless and can unlock further simplifications for some base types. | |
| const Expression* indexExpr = ConstantFolder::GetConstantValueForVariable(*index); | |
| if (indexExpr->isIntLiteral() && baseType.isVector()) { | |
| SKSL_INT indexValue = indexExpr->as<Literal>().intValue(); | |
| return Swizzle::Make(context, std::move(base), ComponentArray{(int8_t)indexValue}); | |
| } | |
| } | |
| return std::make_unique<IndexExpression>(context, std::move(base), std::move(index)); | |
| } | |
| } // namespace SkSL |