blob: 5daee59cc0ea7fc9e078eae9f1dbdf77fb83a28d [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 "include/sksl/DSLCore.h"
#include "src/core/SkSafeMath.h"
#include "src/sksl/SkSLAnalysis.h"
#include "src/sksl/SkSLBuiltinMap.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/SkSLFieldAccess.h"
#include "src/sksl/ir/SkSLFunctionCall.h"
#include "src/sksl/ir/SkSLFunctionDefinition.h"
#include "src/sksl/ir/SkSLInterfaceBlock.h"
#include "src/sksl/ir/SkSLReturnStatement.h"
#include "src/sksl/transform/SkSLProgramWriter.h"
#include <forward_list>
#include <string_view>
#include <vector>
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 Variable* skPerVertex = nullptr;
if (const ProgramElement* perVertexDecl =
context.fBuiltins->find(Compiler::PERVERTEX_NAME)) {
SkASSERT(perVertexDecl->is<SkSL::InterfaceBlock>());
skPerVertex = &perVertexDecl->as<SkSL::InterfaceBlock>().variable();
}
SkASSERT(skPerVertex);
auto Ref = [](const Variable* var) -> std::unique_ptr<Expression> {
return VariableReference::Make(/*line=*/-1, var);
};
auto Field = [&](const Variable* var, int idx) -> std::unique_ptr<Expression> {
return FieldAccess::Make(context, Ref(var), idx, OwnerKind::kAnonymousInterfaceBlock);
};
auto Pos = [&]() -> DSLExpression {
return DSLExpression(FieldAccess::Make(context, Ref(skPerVertex), /*fieldIndex=*/0,
OwnerKind::kAnonymousInterfaceBlock));
};
auto Adjust = [&]() -> DSLExpression {
return DSLExpression(rtAdjust.fInterfaceBlock
? Field(rtAdjust.fInterfaceBlock, rtAdjust.fFieldIndex)
: Ref(rtAdjust.fVar));
};
auto fixupStmt = DSLStatement(
Pos() = Float4(Swizzle(Pos(), X, Y) * Swizzle(Adjust(), X, Z) +
Swizzle(Pos(), W, W) * Swizzle(Adjust(), Y, W),
0,
Pos().w())
);
body.children().push_back(fixupStmt.release());
}
}
std::unique_ptr<FunctionDefinition> FunctionDefinition::Convert(const Context& context,
int line,
const FunctionDeclaration& function,
std::unique_ptr<Statement> body,
bool builtin) {
class Finalizer : public ProgramWriter {
public:
Finalizer(const Context& context, const FunctionDeclaration& function,
FunctionSet* referencedBuiltinFunctions)
: fContext(context)
, fFunction(function)
, fReferencedBuiltinFunctions(referencedBuiltinFunctions) {
// Function parameters count as local variables.
for (const Variable* var : function.parameters()) {
this->addLocalVariable(var, function.fLine);
}
}
void addLocalVariable(const Variable* var, int line) {
// We count the number of slots used, but don't consider the precision of the base type.
// In practice, this reflects what GPUs actually 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;
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) {
fContext.fErrors->error(line, "variable '" + std::string(var->name()) +
"' exceeds the stack size limit");
}
}
~Finalizer() override {
SkASSERT(fBreakableLevel == 0);
SkASSERT(fContinuableLevel == std::forward_list<int>{0});
}
void copyBuiltinFunctionIfNeeded(const FunctionDeclaration& function) {
if (const ProgramElement* found =
fContext.fBuiltins->findAndInclude(function.description())) {
const FunctionDefinition& original = found->as<FunctionDefinition>();
// Sort the referenced builtin functions into a consistent order; otherwise our
// output will become non-deterministic.
std::vector<const FunctionDeclaration*> builtinFunctions(
original.referencedBuiltinFunctions().begin(),
original.referencedBuiltinFunctions().end());
std::sort(builtinFunctions.begin(), builtinFunctions.end(),
[](const FunctionDeclaration* a, const FunctionDeclaration* b) {
if (a->isBuiltin() != b->isBuiltin()) {
return a->isBuiltin() < b->isBuiltin();
}
if (a->fLine != b->fLine) {
return a->fLine < b->fLine;
}
if (a->name() != b->name()) {
return a->name() < b->name();
}
return a->description() < b->description();
});
for (const FunctionDeclaration* f : builtinFunctions) {
this->copyBuiltinFunctionIfNeeded(*f);
}
ThreadContext::SharedElements().push_back(found);
}
}
bool functionReturnsValue() const {
return !fFunction.returnType().isVoid();
}
bool visitExpression(Expression& expr) override {
if (expr.is<FunctionCall>()) {
const FunctionDeclaration& func = expr.as<FunctionCall>().function();
if (func.isBuiltin()) {
if (func.intrinsicKind() == k_dFdy_IntrinsicKind) {
ThreadContext::Inputs().fUseFlipRTUniform = true;
}
if (func.definition()) {
fReferencedBuiltinFunctions->insert(&func);
}
if (!fContext.fConfig->fIsBuiltinCode && fContext.fBuiltins) {
this->copyBuiltinFunctionIfNeeded(func);
}
}
}
return INHERITED::visitExpression(expr);
}
bool visitStatement(Statement& stmt) override {
switch (stmt.kind()) {
case Statement::Kind::kVarDeclaration: {
const Variable* var = &stmt.as<VarDeclaration>().var();
this->addLocalVariable(var, stmt.fLine);
break;
}
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 (fContext.fConfig->fKind == ProgramKind::kVertex && fFunction.isMain()) {
fContext.fErrors->error(
stmt.fLine,
"early returns from vertex programs are not supported");
}
// Verify that the return statement matches the function's return type.
ReturnStatement& returnStmt = stmt.as<ReturnStatement>();
if (returnStmt.expression()) {
if (this->functionReturnsValue()) {
// Coerce return expression to the function's return type.
returnStmt.setExpression(fFunction.returnType().coerceExpression(
std::move(returnStmt.expression()), fContext));
} else {
// Returning something from a function with a void return type.
returnStmt.setExpression(nullptr);
fContext.fErrors->error(returnStmt.fLine,
"may not return a value from a void function");
}
} else {
if (this->functionReturnsValue()) {
// Returning nothing from a function with a non-void return type.
fContext.fErrors->error(returnStmt.fLine,
"expected function to return '" +
fFunction.returnType().displayName() + "'");
}
}
break;
}
case Statement::Kind::kDo:
case Statement::Kind::kFor: {
++fBreakableLevel;
++fContinuableLevel.front();
bool result = INHERITED::visitStatement(stmt);
--fContinuableLevel.front();
--fBreakableLevel;
return result;
}
case Statement::Kind::kSwitch: {
++fBreakableLevel;
fContinuableLevel.push_front(0);
bool result = INHERITED::visitStatement(stmt);
fContinuableLevel.pop_front();
--fBreakableLevel;
return result;
}
case Statement::Kind::kBreak:
if (fBreakableLevel == 0) {
fContext.fErrors->error(stmt.fLine,
"break statement must be inside a loop or switch");
}
break;
case Statement::Kind::kContinue:
if (fContinuableLevel.front() == 0) {
if (std::any_of(fContinuableLevel.begin(),
fContinuableLevel.end(),
[](int level) { return level > 0; })) {
fContext.fErrors->error(stmt.fLine,
"continue statement cannot be used in a switch");
} else {
fContext.fErrors->error(stmt.fLine,
"continue statement must be inside a loop");
}
}
break;
default:
break;
}
return INHERITED::visitStatement(stmt);
}
private:
const Context& fContext;
const FunctionDeclaration& fFunction;
// which builtin functions have we encountered in this function
FunctionSet* fReferencedBuiltinFunctions;
// 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;
};
FunctionSet referencedBuiltinFunctions;
Finalizer(context, function, &referencedBuiltinFunctions).visitStatement(*body);
if (function.isMain() && context.fConfig->fKind == ProgramKind::kVertex) {
append_rtadjust_fixup_to_vertex_main(context, function, body->as<Block>());
}
if (Analysis::CanExitWithoutReturningValue(function, *body)) {
context.fErrors->error(function.fLine, "function '" + std::string(function.name()) +
"' can exit without returning a value");
}
SkASSERTF(!function.isIntrinsic(),
"Intrinsic %s should not have a definition",
std::string(function.name()).c_str());
return std::make_unique<FunctionDefinition>(line, &function, builtin, std::move(body),
std::move(referencedBuiltinFunctions));
}
} // namespace SkSL