blob: f5ff4f9411438313cfadd33f50b49a8e1c88d61e [file] [log] [blame]
* 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/ir/SkSLFunctionDefinition.h"
#include "include/core/SkTypes.h"
#include "include/private/SkSLDefines.h"
#include "include/private/SkSLSymbol.h"
#include "include/sksl/DSLCore.h"
#include "include/sksl/DSLExpression.h"
#include "include/sksl/DSLStatement.h"
#include "include/sksl/DSLType.h"
#include "include/sksl/SkSLErrorReporter.h"
#include "src/base/SkSafeMath.h"
#include "src/sksl/SkSLAnalysis.h"
#include "src/sksl/SkSLCompiler.h"
#include "src/sksl/SkSLContext.h"
#include "src/sksl/SkSLProgramSettings.h"
#include "src/sksl/SkSLThreadContext.h"
#include "src/sksl/ir/SkSLBlock.h"
#include "src/sksl/ir/SkSLExpression.h"
#include "src/sksl/ir/SkSLField.h"
#include "src/sksl/ir/SkSLFieldAccess.h"
#include "src/sksl/ir/SkSLReturnStatement.h"
#include "src/sksl/ir/SkSLSymbolTable.h"
#include "src/sksl/ir/SkSLType.h"
#include "src/sksl/ir/SkSLVarDeclarations.h"
#include "src/sksl/ir/SkSLVariable.h"
#include "src/sksl/ir/SkSLVariableReference.h"
#include "src/sksl/transform/SkSLProgramWriter.h"
#include <algorithm>
#include <cstddef>
#include <forward_list>
#include <string_view>
namespace SkSL {
static void append_rtadjust_fixup_to_vertex_main(const Context& context,
const FunctionDeclaration& decl,
Block& body) {
using namespace SkSL::dsl;
using SkSL::dsl::Swizzle; // disambiguate from SkSL::Swizzle
using OwnerKind = SkSL::FieldAccess::OwnerKind;
// If this program uses RTAdjust...
ThreadContext::RTAdjustData& rtAdjust = ThreadContext::RTAdjustState();
if (rtAdjust.fVar || rtAdjust.fInterfaceBlock) {
// ...append a line to the end of the function body which fixes up sk_Position.
const SymbolTable* symbolTable = ThreadContext::SymbolTable().get();
const Field& skPositionField = symbolTable->find(Compiler::POSITION_NAME)->as<Field>();
auto Ref = [](const Variable* var) -> std::unique_ptr<Expression> {
return VariableReference::Make(Position(), var);
auto Field = [&](const Variable* var, int idx) -> std::unique_ptr<Expression> {
return FieldAccess::Make(context, Position(), Ref(var), idx,
auto Pos = [&]() -> DSLExpression {
return DSLExpression(Field(&skPositionField.owner(), skPositionField.fieldIndex()));
auto Adjust = [&]() -> DSLExpression {
return DSLExpression(rtAdjust.fInterfaceBlock
? Field(rtAdjust.fInterfaceBlock, rtAdjust.fFieldIndex)
: Ref(rtAdjust.fVar));
auto fixupStmt = DSLStatement(
Pos().assign(Float4(Swizzle(Pos(), X, Y) * Swizzle(Adjust(), X, Z) +
Swizzle(Pos(), W, W) * Swizzle(Adjust(), Y, W),
std::unique_ptr<FunctionDefinition> FunctionDefinition::Convert(const Context& context,
Position pos,
const FunctionDeclaration& function,
std::unique_ptr<Statement> body,
bool builtin) {
class Finalizer : public ProgramWriter {
Finalizer(const Context& context, const FunctionDeclaration& function)
: fContext(context)
, fFunction(function) {}
~Finalizer() override {
SkASSERT(fBreakableLevel == 0);
SkASSERT(fContinuableLevel == std::forward_list<int>{0});
bool functionReturnsValue() const {
return !fFunction.returnType().isVoid();
bool visitExpression(Expression& expr) override {
// We don't need to scan expressions.
return false;
bool visitStatement(Statement& stmt) override {
switch (stmt.kind()) {
case Statement::Kind::kVarDeclaration: {
// We count the number of slots used, but don't consider the precision of the
// base type. In practice, this reflects what GPUs really do pretty well.
// (i.e., RelaxedPrecision math doesn't mean your variable takes less space.)
// We also don't attempt to reclaim slots at the end of a Block.
size_t prevSlotsUsed = fSlotsUsed;
const Variable* var =<VarDeclaration>().var();
if (var->type().isOrContainsUnsizedArray()) {
"unsized arrays are not permitted here");
fSlotsUsed = SkSafeMath::Add(fSlotsUsed, var->type().slotCount());
// To avoid overzealous error reporting, only trigger the error at the first
// place where the stack limit is exceeded.
if (prevSlotsUsed < kVariableSlotLimit && fSlotsUsed >= kVariableSlotLimit) {
"variable '" + std::string(var->name()) +
"' exceeds the stack size limit");
case Statement::Kind::kReturn: {
// Early returns from a vertex main() function will bypass sk_Position
// normalization, so SkASSERT that we aren't doing that. If this becomes an
// issue, we can add normalization before each return statement.
if (ProgramConfig::IsVertex(fContext.fConfig->fKind) && fFunction.isMain()) {
"early returns from vertex programs are not supported");
// Verify that the return statement matches the function's return type.
ReturnStatement& returnStmt =<ReturnStatement>();
if (returnStmt.expression()) {
if (this->functionReturnsValue()) {
// Coerce return expression to the function's return type.
std::move(returnStmt.expression()), fContext));
} else {
// Returning something from a function with a void return type.
"may not return a value from a void function");
} else {
if (this->functionReturnsValue()) {
// Returning nothing from a function with a non-void return type.
"expected function to return '" +
fFunction.returnType().displayName() + "'");
case Statement::Kind::kDo:
case Statement::Kind::kFor: {
bool result = INHERITED::visitStatement(stmt);
return result;
case Statement::Kind::kSwitch: {
bool result = INHERITED::visitStatement(stmt);
return result;
case Statement::Kind::kBreak:
if (fBreakableLevel == 0) {
"break statement must be inside a loop or switch");
case Statement::Kind::kContinue:
if (fContinuableLevel.front() == 0) {
if (std::any_of(fContinuableLevel.begin(),
[](int level) { return level > 0; })) {
"continue statement cannot be used in a switch");
} else {
"continue statement must be inside a loop");
return INHERITED::visitStatement(stmt);
const Context& fContext;
const FunctionDeclaration& fFunction;
// how deeply nested we are in breakable constructs (for, do, switch).
int fBreakableLevel = 0;
// number of slots consumed by all variables declared in the function
size_t fSlotsUsed = 0;
// how deeply nested we are in continuable constructs (for, do).
// We keep a stack (via a forward_list) in order to disallow continue inside of switch.
std::forward_list<int> fContinuableLevel{0};
using INHERITED = ProgramWriter;
Finalizer(context, function).visitStatement(*body);
if (function.isMain() && ProgramConfig::IsVertex(context.fConfig->fKind)) {
append_rtadjust_fixup_to_vertex_main(context, function, body->as<Block>());
if (Analysis::CanExitWithoutReturningValue(function, *body)) {
context.fErrors->error(body->fPosition, "function '" + std::string( +
"' can exit without returning a value");
SkASSERTF(!function.isIntrinsic(), "Intrinsic function '%.*s' should not have a definition",
return std::make_unique<FunctionDefinition>(pos, &function, builtin, std::move(body));
} // namespace SkSL