1/*
2 * Copyright 2018 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "src/sksl/ir/SkSLVariableReference.h"
9
10#include "src/sksl/SkSLIRGenerator.h"
11#include "src/sksl/ir/SkSLConstructor.h"
12#include "src/sksl/ir/SkSLFloatLiteral.h"
13#include "src/sksl/ir/SkSLSetting.h"
14
15namespace SkSL {
16
17VariableReference::VariableReference(int offset, const Variable& variable, RefKind refKind)
18: INHERITED(offset, kVariableReference_Kind, variable.fType)
19, fVariable(variable)
20, fRefKind(refKind) {
21 if (refKind != kRead_RefKind) {
22 fVariable.fWriteCount++;
23 }
24 if (refKind != kWrite_RefKind) {
25 fVariable.fReadCount++;
26 }
27}
28
29VariableReference::~VariableReference() {
30 if (fRefKind != kRead_RefKind) {
31 fVariable.fWriteCount--;
32 }
33 if (fRefKind != kWrite_RefKind) {
34 fVariable.fReadCount--;
35 }
36}
37
38void VariableReference::setRefKind(RefKind refKind) {
39 if (fRefKind != kRead_RefKind) {
40 fVariable.fWriteCount--;
41 }
42 if (fRefKind != kWrite_RefKind) {
43 fVariable.fReadCount--;
44 }
45 if (refKind != kRead_RefKind) {
46 fVariable.fWriteCount++;
47 }
48 if (refKind != kWrite_RefKind) {
49 fVariable.fReadCount++;
50 }
51 fRefKind = refKind;
52}
53
54std::unique_ptr<Expression> VariableReference::copy_constant(const IRGenerator& irGenerator,
55 const Expression* expr) {
56 SkASSERT(expr->isConstant());
57 switch (expr->fKind) {
58 case Expression::kIntLiteral_Kind:
59 return std::unique_ptr<Expression>(new IntLiteral(irGenerator.fContext,
60 -1,
61 ((IntLiteral*) expr)->fValue));
62 case Expression::kFloatLiteral_Kind:
63 return std::unique_ptr<Expression>(new FloatLiteral(
64 irGenerator.fContext,
65 -1,
66 ((FloatLiteral*) expr)->fValue));
67 case Expression::kBoolLiteral_Kind:
68 return std::unique_ptr<Expression>(new BoolLiteral(irGenerator.fContext,
69 -1,
70 ((BoolLiteral*) expr)->fValue));
71 case Expression::kConstructor_Kind: {
72 const Constructor* c = (const Constructor*) expr;
73 std::vector<std::unique_ptr<Expression>> args;
74 for (const auto& arg : c->fArguments) {
75 args.push_back(copy_constant(irGenerator, arg.get()));
76 }
77 return std::unique_ptr<Expression>(new Constructor(-1, c->fType,
78 std::move(args)));
79 }
80 case Expression::kSetting_Kind: {
81 const Setting* s = (const Setting*) expr;
82 return std::unique_ptr<Expression>(new Setting(-1, s->fName,
83 copy_constant(irGenerator,
84 s->fValue.get())));
85 }
86 default:
87 ABORT("unsupported constant\n");
88 }
89}
90
91std::unique_ptr<Expression> VariableReference::constantPropagate(const IRGenerator& irGenerator,
92 const DefinitionMap& definitions) {
93 if (fRefKind != kRead_RefKind) {
94 return nullptr;
95 }
96 if (irGenerator.fKind == Program::kPipelineStage_Kind &&
97 fVariable.fStorage == Variable::kGlobal_Storage &&
98 (fVariable.fModifiers.fFlags & Modifiers::kIn_Flag) &&
99 !(fVariable.fModifiers.fFlags & Modifiers::kUniform_Flag)) {
100 return irGenerator.getArg(fOffset, fVariable.fName);
101 }
102 if ((fVariable.fModifiers.fFlags & Modifiers::kConst_Flag) && fVariable.fInitialValue &&
103 fVariable.fInitialValue->isConstant() && fType.kind() != Type::kArray_Kind) {
104 return copy_constant(irGenerator, fVariable.fInitialValue);
105 }
106 auto exprIter = definitions.find(&fVariable);
107 if (exprIter != definitions.end() && exprIter->second &&
108 (*exprIter->second)->isConstant()) {
109 return copy_constant(irGenerator, exprIter->second->get());
110 }
111 return nullptr;
112}
113
114} // namespace
115