blob: 459362f5492207775cff717753481762a48145d8 [file] [log] [blame]
John Stiles44e96be2020-08-31 13:16:04 -04001/*
2 * Copyright 2020 Google LLC
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/SkSLInliner.h"
9
10#include "limits.h"
11#include <memory>
12#include <unordered_set>
13
14#include "src/sksl/SkSLAnalysis.h"
15#include "src/sksl/ir/SkSLBinaryExpression.h"
16#include "src/sksl/ir/SkSLBoolLiteral.h"
17#include "src/sksl/ir/SkSLBreakStatement.h"
18#include "src/sksl/ir/SkSLConstructor.h"
19#include "src/sksl/ir/SkSLContinueStatement.h"
20#include "src/sksl/ir/SkSLDiscardStatement.h"
21#include "src/sksl/ir/SkSLDoStatement.h"
22#include "src/sksl/ir/SkSLEnum.h"
23#include "src/sksl/ir/SkSLExpressionStatement.h"
24#include "src/sksl/ir/SkSLExternalFunctionCall.h"
25#include "src/sksl/ir/SkSLExternalValueReference.h"
26#include "src/sksl/ir/SkSLField.h"
27#include "src/sksl/ir/SkSLFieldAccess.h"
28#include "src/sksl/ir/SkSLFloatLiteral.h"
29#include "src/sksl/ir/SkSLForStatement.h"
30#include "src/sksl/ir/SkSLFunctionCall.h"
31#include "src/sksl/ir/SkSLFunctionDeclaration.h"
32#include "src/sksl/ir/SkSLFunctionDefinition.h"
33#include "src/sksl/ir/SkSLFunctionReference.h"
34#include "src/sksl/ir/SkSLIfStatement.h"
35#include "src/sksl/ir/SkSLIndexExpression.h"
John Stiles98c1f822020-09-09 14:18:53 -040036#include "src/sksl/ir/SkSLInlineMarker.h"
John Stiles44e96be2020-08-31 13:16:04 -040037#include "src/sksl/ir/SkSLIntLiteral.h"
38#include "src/sksl/ir/SkSLInterfaceBlock.h"
39#include "src/sksl/ir/SkSLLayout.h"
40#include "src/sksl/ir/SkSLNop.h"
41#include "src/sksl/ir/SkSLNullLiteral.h"
42#include "src/sksl/ir/SkSLPostfixExpression.h"
43#include "src/sksl/ir/SkSLPrefixExpression.h"
44#include "src/sksl/ir/SkSLReturnStatement.h"
45#include "src/sksl/ir/SkSLSetting.h"
46#include "src/sksl/ir/SkSLSwitchCase.h"
47#include "src/sksl/ir/SkSLSwitchStatement.h"
48#include "src/sksl/ir/SkSLSwizzle.h"
49#include "src/sksl/ir/SkSLTernaryExpression.h"
50#include "src/sksl/ir/SkSLUnresolvedFunction.h"
51#include "src/sksl/ir/SkSLVarDeclarations.h"
52#include "src/sksl/ir/SkSLVarDeclarationsStatement.h"
53#include "src/sksl/ir/SkSLVariable.h"
54#include "src/sksl/ir/SkSLVariableReference.h"
55#include "src/sksl/ir/SkSLWhileStatement.h"
56
57namespace SkSL {
58namespace {
59
60static int count_all_returns(const FunctionDefinition& funcDef) {
61 class CountAllReturns : public ProgramVisitor {
62 public:
63 CountAllReturns(const FunctionDefinition& funcDef) {
64 this->visitProgramElement(funcDef);
65 }
66
67 bool visitStatement(const Statement& stmt) override {
Ethan Nicholase6592142020-09-08 10:22:09 -040068 switch (stmt.kind()) {
69 case Statement::Kind::kReturn:
John Stiles44e96be2020-08-31 13:16:04 -040070 ++fNumReturns;
71 [[fallthrough]];
72
73 default:
John Stilesff9dc822020-09-10 14:40:52 -040074 return INHERITED::visitStatement(stmt);
John Stiles44e96be2020-08-31 13:16:04 -040075 }
76 }
77
78 int fNumReturns = 0;
79 using INHERITED = ProgramVisitor;
80 };
81
82 return CountAllReturns{funcDef}.fNumReturns;
83}
84
85static int count_returns_at_end_of_control_flow(const FunctionDefinition& funcDef) {
86 class CountReturnsAtEndOfControlFlow : public ProgramVisitor {
87 public:
88 CountReturnsAtEndOfControlFlow(const FunctionDefinition& funcDef) {
89 this->visitProgramElement(funcDef);
90 }
91
92 bool visitStatement(const Statement& stmt) override {
Ethan Nicholase6592142020-09-08 10:22:09 -040093 switch (stmt.kind()) {
94 case Statement::Kind::kBlock: {
John Stiles44e96be2020-08-31 13:16:04 -040095 // Check only the last statement of a block.
96 const auto& blockStmts = stmt.as<Block>().fStatements;
97 return (blockStmts.size() > 0) ? this->visitStatement(*blockStmts.back())
98 : false;
99 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400100 case Statement::Kind::kSwitch:
101 case Statement::Kind::kWhile:
102 case Statement::Kind::kDo:
103 case Statement::Kind::kFor:
John Stiles44e96be2020-08-31 13:16:04 -0400104 // Don't introspect switches or loop structures at all.
105 return false;
106
Ethan Nicholase6592142020-09-08 10:22:09 -0400107 case Statement::Kind::kReturn:
John Stiles44e96be2020-08-31 13:16:04 -0400108 ++fNumReturns;
109 [[fallthrough]];
110
111 default:
John Stilesff9dc822020-09-10 14:40:52 -0400112 return INHERITED::visitStatement(stmt);
John Stiles44e96be2020-08-31 13:16:04 -0400113 }
114 }
115
116 int fNumReturns = 0;
117 using INHERITED = ProgramVisitor;
118 };
119
120 return CountReturnsAtEndOfControlFlow{funcDef}.fNumReturns;
121}
122
123static int count_returns_in_breakable_constructs(const FunctionDefinition& funcDef) {
124 class CountReturnsInBreakableConstructs : public ProgramVisitor {
125 public:
126 CountReturnsInBreakableConstructs(const FunctionDefinition& funcDef) {
127 this->visitProgramElement(funcDef);
128 }
129
130 bool visitStatement(const Statement& stmt) override {
Ethan Nicholase6592142020-09-08 10:22:09 -0400131 switch (stmt.kind()) {
132 case Statement::Kind::kSwitch:
133 case Statement::Kind::kWhile:
134 case Statement::Kind::kDo:
135 case Statement::Kind::kFor: {
John Stiles44e96be2020-08-31 13:16:04 -0400136 ++fInsideBreakableConstruct;
John Stilesff9dc822020-09-10 14:40:52 -0400137 bool result = INHERITED::visitStatement(stmt);
John Stiles44e96be2020-08-31 13:16:04 -0400138 --fInsideBreakableConstruct;
139 return result;
140 }
141
Ethan Nicholase6592142020-09-08 10:22:09 -0400142 case Statement::Kind::kReturn:
John Stiles44e96be2020-08-31 13:16:04 -0400143 fNumReturns += (fInsideBreakableConstruct > 0) ? 1 : 0;
144 [[fallthrough]];
145
146 default:
John Stilesff9dc822020-09-10 14:40:52 -0400147 return INHERITED::visitStatement(stmt);
John Stiles44e96be2020-08-31 13:16:04 -0400148 }
149 }
150
151 int fNumReturns = 0;
152 int fInsideBreakableConstruct = 0;
153 using INHERITED = ProgramVisitor;
154 };
155
156 return CountReturnsInBreakableConstructs{funcDef}.fNumReturns;
157}
158
159static bool has_early_return(const FunctionDefinition& funcDef) {
160 int returnCount = count_all_returns(funcDef);
161 if (returnCount == 0) {
162 return false;
163 }
164
165 int returnsAtEndOfControlFlow = count_returns_at_end_of_control_flow(funcDef);
166 return returnCount > returnsAtEndOfControlFlow;
167}
168
John Stiles991b09d2020-09-10 13:33:40 -0400169static bool contains_recursive_call(const FunctionDeclaration& funcDecl) {
170 class ContainsRecursiveCall : public ProgramVisitor {
171 public:
172 bool visit(const FunctionDeclaration& funcDecl) {
173 fFuncDecl = &funcDecl;
174 return funcDecl.fDefinition ? this->visitProgramElement(*funcDecl.fDefinition)
175 : false;
176 }
177
178 bool visitExpression(const Expression& expr) override {
179 if (expr.is<FunctionCall>() && expr.as<FunctionCall>().fFunction.matches(*fFuncDecl)) {
180 return true;
181 }
182 return INHERITED::visitExpression(expr);
183 }
184
185 bool visitStatement(const Statement& stmt) override {
186 if (stmt.is<InlineMarker>() && stmt.as<InlineMarker>().fFuncDecl->matches(*fFuncDecl)) {
187 return true;
188 }
189 return INHERITED::visitStatement(stmt);
190 }
191
192 const FunctionDeclaration* fFuncDecl;
193 using INHERITED = ProgramVisitor;
194 };
195
196 return ContainsRecursiveCall{}.visit(funcDecl);
197}
198
John Stiles44e96be2020-08-31 13:16:04 -0400199static const Type* copy_if_needed(const Type* src, SymbolTable& symbolTable) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400200 if (src->typeKind() == Type::TypeKind::kArray) {
John Stiles44e96be2020-08-31 13:16:04 -0400201 return symbolTable.takeOwnershipOfSymbol(std::make_unique<Type>(*src));
202 }
203 return src;
204}
205
206} // namespace
207
208void Inliner::reset(const Context& context, const Program::Settings& settings) {
209 fContext = &context;
210 fSettings = &settings;
211 fInlineVarCounter = 0;
212}
213
214std::unique_ptr<Expression> Inliner::inlineExpression(int offset,
215 VariableRewriteMap* varMap,
216 const Expression& expression) {
217 auto expr = [&](const std::unique_ptr<Expression>& e) -> std::unique_ptr<Expression> {
218 if (e) {
219 return this->inlineExpression(offset, varMap, *e);
220 }
221 return nullptr;
222 };
223 auto argList = [&](const std::vector<std::unique_ptr<Expression>>& originalArgs)
224 -> std::vector<std::unique_ptr<Expression>> {
225 std::vector<std::unique_ptr<Expression>> args;
226 args.reserve(originalArgs.size());
227 for (const std::unique_ptr<Expression>& arg : originalArgs) {
228 args.push_back(expr(arg));
229 }
230 return args;
231 };
232
Ethan Nicholase6592142020-09-08 10:22:09 -0400233 switch (expression.kind()) {
234 case Expression::Kind::kBinary: {
John Stiles44e96be2020-08-31 13:16:04 -0400235 const BinaryExpression& b = expression.as<BinaryExpression>();
236 return std::make_unique<BinaryExpression>(offset,
237 expr(b.fLeft),
238 b.fOperator,
239 expr(b.fRight),
240 b.fType);
241 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400242 case Expression::Kind::kBoolLiteral:
243 case Expression::Kind::kIntLiteral:
244 case Expression::Kind::kFloatLiteral:
245 case Expression::Kind::kNullLiteral:
John Stiles44e96be2020-08-31 13:16:04 -0400246 return expression.clone();
Ethan Nicholase6592142020-09-08 10:22:09 -0400247 case Expression::Kind::kConstructor: {
John Stiles44e96be2020-08-31 13:16:04 -0400248 const Constructor& constructor = expression.as<Constructor>();
249 return std::make_unique<Constructor>(offset, constructor.fType,
250 argList(constructor.fArguments));
251 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400252 case Expression::Kind::kExternalFunctionCall: {
John Stiles44e96be2020-08-31 13:16:04 -0400253 const ExternalFunctionCall& externalCall = expression.as<ExternalFunctionCall>();
254 return std::make_unique<ExternalFunctionCall>(offset, externalCall.fType,
255 externalCall.fFunction,
256 argList(externalCall.fArguments));
257 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400258 case Expression::Kind::kExternalValue:
John Stiles44e96be2020-08-31 13:16:04 -0400259 return expression.clone();
Ethan Nicholase6592142020-09-08 10:22:09 -0400260 case Expression::Kind::kFieldAccess: {
John Stiles44e96be2020-08-31 13:16:04 -0400261 const FieldAccess& f = expression.as<FieldAccess>();
262 return std::make_unique<FieldAccess>(expr(f.fBase), f.fFieldIndex, f.fOwnerKind);
263 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400264 case Expression::Kind::kFunctionCall: {
John Stiles44e96be2020-08-31 13:16:04 -0400265 const FunctionCall& funcCall = expression.as<FunctionCall>();
266 return std::make_unique<FunctionCall>(offset, funcCall.fType, funcCall.fFunction,
267 argList(funcCall.fArguments));
268 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400269 case Expression::Kind::kFunctionReference:
Brian Osman2b3b35f2020-09-08 09:17:36 -0400270 return expression.clone();
Ethan Nicholase6592142020-09-08 10:22:09 -0400271 case Expression::Kind::kIndex: {
John Stiles44e96be2020-08-31 13:16:04 -0400272 const IndexExpression& idx = expression.as<IndexExpression>();
273 return std::make_unique<IndexExpression>(*fContext, expr(idx.fBase), expr(idx.fIndex));
274 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400275 case Expression::Kind::kPrefix: {
John Stiles44e96be2020-08-31 13:16:04 -0400276 const PrefixExpression& p = expression.as<PrefixExpression>();
277 return std::make_unique<PrefixExpression>(p.fOperator, expr(p.fOperand));
278 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400279 case Expression::Kind::kPostfix: {
John Stiles44e96be2020-08-31 13:16:04 -0400280 const PostfixExpression& p = expression.as<PostfixExpression>();
281 return std::make_unique<PostfixExpression>(expr(p.fOperand), p.fOperator);
282 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400283 case Expression::Kind::kSetting:
John Stiles44e96be2020-08-31 13:16:04 -0400284 return expression.clone();
Ethan Nicholase6592142020-09-08 10:22:09 -0400285 case Expression::Kind::kSwizzle: {
John Stiles44e96be2020-08-31 13:16:04 -0400286 const Swizzle& s = expression.as<Swizzle>();
287 return std::make_unique<Swizzle>(*fContext, expr(s.fBase), s.fComponents);
288 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400289 case Expression::Kind::kTernary: {
John Stiles44e96be2020-08-31 13:16:04 -0400290 const TernaryExpression& t = expression.as<TernaryExpression>();
291 return std::make_unique<TernaryExpression>(offset, expr(t.fTest),
292 expr(t.fIfTrue), expr(t.fIfFalse));
293 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400294 case Expression::Kind::kVariableReference: {
John Stiles44e96be2020-08-31 13:16:04 -0400295 const VariableReference& v = expression.as<VariableReference>();
296 auto found = varMap->find(&v.fVariable);
297 if (found != varMap->end()) {
298 return std::make_unique<VariableReference>(offset, *found->second, v.fRefKind);
299 }
300 return v.clone();
301 }
302 default:
303 SkASSERT(false);
304 return nullptr;
305 }
306}
307
308std::unique_ptr<Statement> Inliner::inlineStatement(int offset,
309 VariableRewriteMap* varMap,
310 SymbolTable* symbolTableForStatement,
311 const Variable* returnVar,
312 bool haveEarlyReturns,
313 const Statement& statement) {
314 auto stmt = [&](const std::unique_ptr<Statement>& s) -> std::unique_ptr<Statement> {
315 if (s) {
316 return this->inlineStatement(offset, varMap, symbolTableForStatement, returnVar,
317 haveEarlyReturns, *s);
318 }
319 return nullptr;
320 };
321 auto stmts = [&](const std::vector<std::unique_ptr<Statement>>& ss) {
322 std::vector<std::unique_ptr<Statement>> result;
323 for (const auto& s : ss) {
324 result.push_back(stmt(s));
325 }
326 return result;
327 };
328 auto expr = [&](const std::unique_ptr<Expression>& e) -> std::unique_ptr<Expression> {
329 if (e) {
330 return this->inlineExpression(offset, varMap, *e);
331 }
332 return nullptr;
333 };
Ethan Nicholase6592142020-09-08 10:22:09 -0400334 switch (statement.kind()) {
335 case Statement::Kind::kBlock: {
John Stiles44e96be2020-08-31 13:16:04 -0400336 const Block& b = statement.as<Block>();
337 return std::make_unique<Block>(offset, stmts(b.fStatements), b.fSymbols, b.fIsScope);
338 }
339
Ethan Nicholase6592142020-09-08 10:22:09 -0400340 case Statement::Kind::kBreak:
341 case Statement::Kind::kContinue:
342 case Statement::Kind::kDiscard:
John Stiles44e96be2020-08-31 13:16:04 -0400343 return statement.clone();
344
Ethan Nicholase6592142020-09-08 10:22:09 -0400345 case Statement::Kind::kDo: {
John Stiles44e96be2020-08-31 13:16:04 -0400346 const DoStatement& d = statement.as<DoStatement>();
347 return std::make_unique<DoStatement>(offset, stmt(d.fStatement), expr(d.fTest));
348 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400349 case Statement::Kind::kExpression: {
John Stiles44e96be2020-08-31 13:16:04 -0400350 const ExpressionStatement& e = statement.as<ExpressionStatement>();
351 return std::make_unique<ExpressionStatement>(expr(e.fExpression));
352 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400353 case Statement::Kind::kFor: {
John Stiles44e96be2020-08-31 13:16:04 -0400354 const ForStatement& f = statement.as<ForStatement>();
355 // need to ensure initializer is evaluated first so that we've already remapped its
356 // declarations by the time we evaluate test & next
357 std::unique_ptr<Statement> initializer = stmt(f.fInitializer);
358 return std::make_unique<ForStatement>(offset, std::move(initializer), expr(f.fTest),
359 expr(f.fNext), stmt(f.fStatement), f.fSymbols);
360 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400361 case Statement::Kind::kIf: {
John Stiles44e96be2020-08-31 13:16:04 -0400362 const IfStatement& i = statement.as<IfStatement>();
363 return std::make_unique<IfStatement>(offset, i.fIsStatic, expr(i.fTest),
364 stmt(i.fIfTrue), stmt(i.fIfFalse));
365 }
John Stiles98c1f822020-09-09 14:18:53 -0400366 case Statement::Kind::kInlineMarker:
Ethan Nicholase6592142020-09-08 10:22:09 -0400367 case Statement::Kind::kNop:
John Stiles44e96be2020-08-31 13:16:04 -0400368 return statement.clone();
Ethan Nicholase6592142020-09-08 10:22:09 -0400369 case Statement::Kind::kReturn: {
John Stiles44e96be2020-08-31 13:16:04 -0400370 const ReturnStatement& r = statement.as<ReturnStatement>();
371 if (r.fExpression) {
372 auto assignment = std::make_unique<ExpressionStatement>(
373 std::make_unique<BinaryExpression>(
374 offset,
375 std::make_unique<VariableReference>(offset, *returnVar,
376 VariableReference::kWrite_RefKind),
377 Token::Kind::TK_EQ,
378 expr(r.fExpression),
379 returnVar->fType));
380 if (haveEarlyReturns) {
381 std::vector<std::unique_ptr<Statement>> block;
382 block.push_back(std::move(assignment));
383 block.emplace_back(new BreakStatement(offset));
384 return std::make_unique<Block>(offset, std::move(block), /*symbols=*/nullptr,
385 /*isScope=*/true);
386 } else {
387 return std::move(assignment);
388 }
389 } else {
390 if (haveEarlyReturns) {
391 return std::make_unique<BreakStatement>(offset);
392 } else {
393 return std::make_unique<Nop>();
394 }
395 }
396 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400397 case Statement::Kind::kSwitch: {
John Stiles44e96be2020-08-31 13:16:04 -0400398 const SwitchStatement& ss = statement.as<SwitchStatement>();
399 std::vector<std::unique_ptr<SwitchCase>> cases;
400 for (const auto& sc : ss.fCases) {
401 cases.emplace_back(new SwitchCase(offset, expr(sc->fValue),
402 stmts(sc->fStatements)));
403 }
404 return std::make_unique<SwitchStatement>(offset, ss.fIsStatic, expr(ss.fValue),
405 std::move(cases), ss.fSymbols);
406 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400407 case Statement::Kind::kVarDeclaration: {
John Stiles44e96be2020-08-31 13:16:04 -0400408 const VarDeclaration& decl = statement.as<VarDeclaration>();
409 std::vector<std::unique_ptr<Expression>> sizes;
410 for (const auto& size : decl.fSizes) {
411 sizes.push_back(expr(size));
412 }
413 std::unique_ptr<Expression> initialValue = expr(decl.fValue);
414 const Variable* old = decl.fVar;
415 // need to copy the var name in case the originating function is discarded and we lose
416 // its symbols
417 std::unique_ptr<String> name(new String(old->fName));
418 const String* namePtr = symbolTableForStatement->takeOwnershipOfString(std::move(name));
419 const Type* typePtr = copy_if_needed(&old->fType, *symbolTableForStatement);
420 const Variable* clone = symbolTableForStatement->takeOwnershipOfSymbol(
421 std::make_unique<Variable>(offset,
422 old->fModifiers,
423 namePtr->c_str(),
424 *typePtr,
425 old->fStorage,
426 initialValue.get()));
427 (*varMap)[old] = clone;
428 return std::make_unique<VarDeclaration>(clone, std::move(sizes),
429 std::move(initialValue));
430 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400431 case Statement::Kind::kVarDeclarations: {
John Stiles44e96be2020-08-31 13:16:04 -0400432 const VarDeclarations& decls = *statement.as<VarDeclarationsStatement>().fDeclaration;
433 std::vector<std::unique_ptr<VarDeclaration>> vars;
434 for (const auto& var : decls.fVars) {
435 vars.emplace_back(&stmt(var).release()->as<VarDeclaration>());
436 }
437 const Type* typePtr = copy_if_needed(&decls.fBaseType, *symbolTableForStatement);
438 return std::unique_ptr<Statement>(new VarDeclarationsStatement(
439 std::make_unique<VarDeclarations>(offset, typePtr, std::move(vars))));
440 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400441 case Statement::Kind::kWhile: {
John Stiles44e96be2020-08-31 13:16:04 -0400442 const WhileStatement& w = statement.as<WhileStatement>();
443 return std::make_unique<WhileStatement>(offset, expr(w.fTest), stmt(w.fStatement));
444 }
445 default:
446 SkASSERT(false);
447 return nullptr;
448 }
449}
450
John Stiles6eadf132020-09-08 10:16:10 -0400451Inliner::InlinedCall Inliner::inlineCall(FunctionCall* call,
John Stiles44e96be2020-08-31 13:16:04 -0400452 SymbolTable* symbolTableForCall) {
453 // Inlining is more complicated here than in a typical compiler, because we have to have a
454 // high-level IR and can't just drop statements into the middle of an expression or even use
455 // gotos.
456 //
457 // Since we can't insert statements into an expression, we run the inline function as extra
458 // statements before the statement we're currently processing, relying on a lack of execution
459 // order guarantees. Since we can't use gotos (which are normally used to replace return
460 // statements), we wrap the whole function in a loop and use break statements to jump to the
461 // end.
462 SkASSERT(fSettings);
463 SkASSERT(fContext);
464 SkASSERT(call);
465 SkASSERT(this->isSafeToInline(*call, /*inlineThreshold=*/INT_MAX));
466
John Stiles44e96be2020-08-31 13:16:04 -0400467 std::vector<std::unique_ptr<Expression>>& arguments = call->fArguments;
John Stiles6eadf132020-09-08 10:16:10 -0400468 const int offset = call->fOffset;
John Stiles44e96be2020-08-31 13:16:04 -0400469 const FunctionDefinition& function = *call->fFunction.fDefinition;
John Stiles6eadf132020-09-08 10:16:10 -0400470 const bool hasEarlyReturn = has_early_return(function);
471
John Stiles44e96be2020-08-31 13:16:04 -0400472 InlinedCall inlinedCall;
John Stiles6eadf132020-09-08 10:16:10 -0400473 inlinedCall.fInlinedBody = std::make_unique<Block>(offset,
474 std::vector<std::unique_ptr<Statement>>{},
475 /*symbols=*/nullptr,
476 /*isScope=*/false);
John Stiles98c1f822020-09-09 14:18:53 -0400477
John Stiles6eadf132020-09-08 10:16:10 -0400478 std::vector<std::unique_ptr<Statement>>& inlinedBody = inlinedCall.fInlinedBody->fStatements;
John Stiles98c1f822020-09-09 14:18:53 -0400479 inlinedBody.reserve(1 + // Inline marker
480 1 + // Result variable
481 arguments.size() + // Function arguments (passing in)
482 arguments.size() + // Function arguments (copy out-parameters back)
483 1); // Inlined code (either as a Block or do-while loop)
484
485 inlinedBody.push_back(std::make_unique<InlineMarker>(call->fFunction));
John Stiles44e96be2020-08-31 13:16:04 -0400486
John Stilesa003e812020-09-11 09:43:49 -0400487 auto makeInlineVar = [&](const String& baseName, const Type* type, Modifiers modifiers,
John Stiles44e96be2020-08-31 13:16:04 -0400488 std::unique_ptr<Expression>* initialValue) -> const Variable* {
John Stilesa003e812020-09-11 09:43:49 -0400489 // $floatLiteral or $intLiteral aren't real types that we can use for scratch variables, so
490 // replace them if they ever appear here. If this happens, we likely forgot to coerce a type
491 // somewhere during compilation.
492 if (type == fContext->fFloatLiteral_Type.get()) {
493 SkASSERT(!"found a $floatLiteral type while inlining");
494 type = fContext->fFloat_Type.get();
495 } else if (type == fContext->fIntLiteral_Type.get()) {
496 SkASSERT(!"found an $intLiteral type while inlining");
497 type = fContext->fInt_Type.get();
498 }
499
John Stilescf936f92020-08-31 17:18:45 -0400500 // If the base name starts with an underscore, like "_coords", we can't append another
501 // underscore, because some OpenGL platforms error out when they see two consecutive
502 // underscores (anywhere in the string!). But in the general case, using the underscore as
503 // a splitter reads nicely enough that it's worth putting in this special case.
504 const char* splitter = baseName.startsWith("_") ? "_X" : "_";
505
506 // Append a unique numeric prefix to avoid name overlap. Check the symbol table to make sure
507 // we're not reusing an existing name. (Note that within a single compilation pass, this
508 // check isn't fully comprehensive, as code isn't always generated in top-to-bottom order.)
509 String uniqueName;
510 for (;;) {
511 uniqueName = String::printf("_%d%s%s", fInlineVarCounter++, splitter, baseName.c_str());
512 StringFragment frag{uniqueName.data(), uniqueName.length()};
513 if ((*symbolTableForCall)[frag] == nullptr) {
514 break;
515 }
516 }
517
John Stiles44e96be2020-08-31 13:16:04 -0400518 // Add our new variable's name to the symbol table.
John Stilescf936f92020-08-31 17:18:45 -0400519 const String* namePtr = symbolTableForCall->takeOwnershipOfString(
520 std::make_unique<String>(std::move(uniqueName)));
John Stiles44e96be2020-08-31 13:16:04 -0400521 StringFragment nameFrag{namePtr->c_str(), namePtr->length()};
522
523 // Add our new variable to the symbol table.
John Stilesa003e812020-09-11 09:43:49 -0400524 auto newVar = std::make_unique<Variable>(/*offset=*/-1, Modifiers(), nameFrag, *type,
John Stiles44e96be2020-08-31 13:16:04 -0400525 Variable::kLocal_Storage, initialValue->get());
526 const Variable* variableSymbol = symbolTableForCall->add(nameFrag, std::move(newVar));
527
528 // Prepare the variable declaration (taking extra care with `out` params to not clobber any
529 // initial value).
530 std::vector<std::unique_ptr<VarDeclaration>> variables;
531 if (initialValue && (modifiers.fFlags & Modifiers::kOut_Flag)) {
532 variables.push_back(std::make_unique<VarDeclaration>(
533 variableSymbol, /*sizes=*/std::vector<std::unique_ptr<Expression>>{},
534 (*initialValue)->clone()));
535 } else {
536 variables.push_back(std::make_unique<VarDeclaration>(
537 variableSymbol, /*sizes=*/std::vector<std::unique_ptr<Expression>>{},
538 std::move(*initialValue)));
539 }
540
541 // Add the new variable-declaration statement to our block of extra statements.
John Stiles39616ec2020-08-31 14:16:06 -0400542 inlinedBody.push_back(std::make_unique<VarDeclarationsStatement>(
John Stilesa003e812020-09-11 09:43:49 -0400543 std::make_unique<VarDeclarations>(offset, type, std::move(variables))));
John Stiles44e96be2020-08-31 13:16:04 -0400544
545 return variableSymbol;
546 };
547
548 // Create a variable to hold the result in the extra statements (excepting void).
549 const Variable* resultVar = nullptr;
550 if (function.fDeclaration.fReturnType != *fContext->fVoid_Type) {
John Stiles44e96be2020-08-31 13:16:04 -0400551 std::unique_ptr<Expression> noInitialValue;
John Stilescf936f92020-08-31 17:18:45 -0400552 resultVar = makeInlineVar(String(function.fDeclaration.fName),
John Stilesa003e812020-09-11 09:43:49 -0400553 &function.fDeclaration.fReturnType, Modifiers{}, &noInitialValue);
John Stiles44e96be2020-08-31 13:16:04 -0400554 }
555
556 // Create variables in the extra statements to hold the arguments, and assign the arguments to
557 // them.
558 VariableRewriteMap varMap;
John Stiles44e96be2020-08-31 13:16:04 -0400559 for (int i = 0; i < (int) arguments.size(); ++i) {
560 const Variable* param = function.fDeclaration.fParameters[i];
561
John Stilesa003e812020-09-11 09:43:49 -0400562 if (arguments[i]->is<VariableReference>()) {
John Stiles44e96be2020-08-31 13:16:04 -0400563 // The argument is just a variable, so we only need to copy it if it's an out parameter
564 // or it's written to within the function.
565 if ((param->fModifiers.fFlags & Modifiers::kOut_Flag) ||
566 !Analysis::StatementWritesToVariable(*function.fBody, *param)) {
567 varMap[param] = &arguments[i]->as<VariableReference>().fVariable;
568 continue;
569 }
570 }
571
John Stilesa003e812020-09-11 09:43:49 -0400572 varMap[param] = makeInlineVar(String(param->fName), &arguments[i]->fType, param->fModifiers,
John Stilescf936f92020-08-31 17:18:45 -0400573 &arguments[i]);
John Stiles44e96be2020-08-31 13:16:04 -0400574 }
575
576 const Block& body = function.fBody->as<Block>();
John Stiles44e96be2020-08-31 13:16:04 -0400577 auto inlineBlock = std::make_unique<Block>(offset, std::vector<std::unique_ptr<Statement>>{});
578 inlineBlock->fStatements.reserve(body.fStatements.size());
579 for (const std::unique_ptr<Statement>& stmt : body.fStatements) {
580 inlineBlock->fStatements.push_back(this->inlineStatement(
581 offset, &varMap, symbolTableForCall, resultVar, hasEarlyReturn, *stmt));
582 }
583 if (hasEarlyReturn) {
584 // Since we output to backends that don't have a goto statement (which would normally be
585 // used to perform an early return), we fake it by wrapping the function in a
586 // do { } while (false); and then use break statements to jump to the end in order to
587 // emulate a goto.
John Stiles39616ec2020-08-31 14:16:06 -0400588 inlinedBody.push_back(std::make_unique<DoStatement>(
John Stiles44e96be2020-08-31 13:16:04 -0400589 /*offset=*/-1,
590 std::move(inlineBlock),
591 std::make_unique<BoolLiteral>(*fContext, offset, /*value=*/false)));
592 } else {
John Stiles6eadf132020-09-08 10:16:10 -0400593 // No early returns, so we can just dump the code in. We still need to keep the block so we
594 // don't get name conflicts with locals.
John Stiles39616ec2020-08-31 14:16:06 -0400595 inlinedBody.push_back(std::move(inlineBlock));
John Stiles44e96be2020-08-31 13:16:04 -0400596 }
597
598 // Copy the values of `out` parameters into their destinations.
599 for (size_t i = 0; i < arguments.size(); ++i) {
600 const Variable* p = function.fDeclaration.fParameters[i];
601 if (p->fModifiers.fFlags & Modifiers::kOut_Flag) {
602 SkASSERT(varMap.find(p) != varMap.end());
Ethan Nicholase6592142020-09-08 10:22:09 -0400603 if (arguments[i]->kind() == Expression::Kind::kVariableReference &&
John Stiles44e96be2020-08-31 13:16:04 -0400604 &arguments[i]->as<VariableReference>().fVariable == varMap[p]) {
John Stiles6eadf132020-09-08 10:16:10 -0400605 // We didn't create a temporary for this parameter, so there's nothing to copy back
606 // out.
John Stiles44e96be2020-08-31 13:16:04 -0400607 continue;
608 }
609 auto varRef = std::make_unique<VariableReference>(offset, *varMap[p]);
John Stiles39616ec2020-08-31 14:16:06 -0400610 inlinedBody.push_back(std::make_unique<ExpressionStatement>(
John Stiles44e96be2020-08-31 13:16:04 -0400611 std::make_unique<BinaryExpression>(offset,
612 arguments[i]->clone(),
613 Token::Kind::TK_EQ,
614 std::move(varRef),
615 arguments[i]->fType)));
616 }
617 }
618
619 if (function.fDeclaration.fReturnType != *fContext->fVoid_Type) {
620 // Return a reference to the result variable as our replacement expression.
621 inlinedCall.fReplacementExpr = std::make_unique<VariableReference>(offset, *resultVar);
622 } else {
623 // It's a void function, so it doesn't actually result in anything, but we have to return
624 // something non-null as a standin.
625 inlinedCall.fReplacementExpr = std::make_unique<BoolLiteral>(*fContext, offset,
626 /*value=*/false);
627 }
628
John Stiles44e96be2020-08-31 13:16:04 -0400629 return inlinedCall;
630}
631
John Stilesff9dc822020-09-10 14:40:52 -0400632bool Inliner::isSafeToInline(const FunctionCall& functionCall, int inlineThreshold) {
John Stiles44e96be2020-08-31 13:16:04 -0400633 SkASSERT(fSettings);
634
635 if (functionCall.fFunction.fDefinition == nullptr) {
636 // Can't inline something if we don't actually have its definition.
637 return false;
638 }
639 const FunctionDefinition& functionDef = *functionCall.fFunction.fDefinition;
640 if (inlineThreshold < INT_MAX) {
641 if (!(functionDef.fDeclaration.fModifiers.fFlags & Modifiers::kInline_Flag) &&
642 Analysis::NodeCount(functionDef) >= inlineThreshold) {
643 // The function exceeds our maximum inline size and is not flagged 'inline'.
644 return false;
645 }
646 }
John Stiles44e96be2020-08-31 13:16:04 -0400647 if (!fSettings->fCaps || !fSettings->fCaps->canUseDoLoops()) {
648 // We don't have do-while loops. We use do-while loops to simulate early returns, so we
649 // can't inline functions that have an early return.
650 bool hasEarlyReturn = has_early_return(functionDef);
651
652 // If we didn't detect an early return, there shouldn't be any returns in breakable
653 // constructs either.
654 SkASSERT(hasEarlyReturn || count_returns_in_breakable_constructs(functionDef) == 0);
655 return !hasEarlyReturn;
656 }
657 // We have do-while loops, but we don't have any mechanism to simulate early returns within a
658 // breakable construct (switch/for/do/while), so we can't inline if there's a return inside one.
659 bool hasReturnInBreakableConstruct = (count_returns_in_breakable_constructs(functionDef) > 0);
660
661 // If we detected returns in breakable constructs, we should also detect an early return.
662 SkASSERT(!hasReturnInBreakableConstruct || has_early_return(functionDef));
663 return !hasReturnInBreakableConstruct;
664}
665
John Stilesff9dc822020-09-10 14:40:52 -0400666bool Inliner::analyze(Program& program) {
667 // A candidate function for inlining, containing everything that `inlineCall` needs.
668 struct InlineCandidate {
669 SymbolTable* fSymbols;
670 std::unique_ptr<Statement>* fEnclosingStmt;
671 std::unique_ptr<Expression>* fCandidateExpr;
672 };
673
674 // This is structured much like a ProgramVisitor, but does not actually use ProgramVisitor.
675 // The analyzer needs to keep track of the `unique_ptr<T>*` of statements and expressions so
676 // that they can later be replaced, and ProgramVisitor does not provide this; it only provides a
677 // `const T&`.
678 class InlineCandidateAnalyzer {
679 public:
680 // A list of all the inlining candidates we found during analysis.
681 std::vector<InlineCandidate> fInlineCandidates;
682 // A stack of the symbol tables; since most nodes don't have one, expected to be shallower
683 // than the enclosing-statement stack.
684 std::vector<SymbolTable*> fSymbolTableStack;
685 // A stack of "enclosing" statements--these would be suitable for the inliner to use for
686 // adding new instructions. Not all statements are suitable (e.g. a for-loop's initializer).
687 // The inliner might replace a statement with a block containing the statement.
688 std::vector<std::unique_ptr<Statement>*> fEnclosingStmtStack;
689
690 void visit(Program& program) {
691 fSymbolTableStack.push_back(program.fSymbols.get());
692
693 for (ProgramElement& pe : program) {
694 this->visitProgramElement(&pe);
695 }
696
697 fSymbolTableStack.pop_back();
698 }
699
700 void visitProgramElement(ProgramElement* pe) {
701 switch (pe->kind()) {
702 case ProgramElement::Kind::kFunction: {
703 FunctionDefinition& funcDef = pe->as<FunctionDefinition>();
704 this->visitStatement(&funcDef.fBody);
705 break;
706 }
707 default:
708 // The inliner can't operate outside of a function's scope.
709 break;
710 }
711 }
712
713 void visitStatement(std::unique_ptr<Statement>* stmt,
714 bool isViableAsEnclosingStatement = true) {
715 if (!*stmt) {
716 return;
717 }
718
719 size_t oldEnclosingStmtStackSize = fEnclosingStmtStack.size();
720 size_t oldSymbolStackSize = fSymbolTableStack.size();
721
722 if (isViableAsEnclosingStatement) {
723 fEnclosingStmtStack.push_back(stmt);
724 }
725
726 switch ((*stmt)->kind()) {
727 case Statement::Kind::kBreak:
728 case Statement::Kind::kContinue:
729 case Statement::Kind::kDiscard:
730 case Statement::Kind::kInlineMarker:
731 case Statement::Kind::kNop:
732 break;
733
734 case Statement::Kind::kBlock: {
735 Block& block = (*stmt)->as<Block>();
736 if (block.fSymbols) {
737 fSymbolTableStack.push_back(block.fSymbols.get());
738 }
739
740 for (std::unique_ptr<Statement>& blockStmt : block.fStatements) {
741 this->visitStatement(&blockStmt);
742 }
743 break;
744 }
745 case Statement::Kind::kDo: {
746 DoStatement& doStmt = (*stmt)->as<DoStatement>();
747 // The loop body is a candidate for inlining.
748 this->visitStatement(&doStmt.fStatement);
749 // The inliner isn't smart enough to inline the test-expression for a do-while
750 // loop at this time. There are two limitations:
751 // - We would need to insert the inlined-body block at the very end of the do-
752 // statement's inner fStatement. We don't support that today, but it's doable.
753 // - We cannot inline the test expression if the loop uses `continue` anywhere;
754 // that would skip over the inlined block that evaluates the test expression.
755 // There isn't a good fix for this--any workaround would be more complex than
756 // the cost of a function call. However, loops that don't use `continue` would
757 // still be viable candidates for inlining.
758 break;
759 }
760 case Statement::Kind::kExpression: {
761 ExpressionStatement& expr = (*stmt)->as<ExpressionStatement>();
762 this->visitExpression(&expr.fExpression);
763 break;
764 }
765 case Statement::Kind::kFor: {
766 ForStatement& forStmt = (*stmt)->as<ForStatement>();
767 if (forStmt.fSymbols) {
768 fSymbolTableStack.push_back(forStmt.fSymbols.get());
769 }
770
771 // The initializer and loop body are candidates for inlining.
772 this->visitStatement(&forStmt.fInitializer,
773 /*isViableAsEnclosingStatement=*/false);
774 this->visitStatement(&forStmt.fStatement);
775
776 // The inliner isn't smart enough to inline the test- or increment-expressions
777 // of a for loop loop at this time. There are a handful of limitations:
778 // - We would need to insert the test-expression block at the very beginning of
779 // the for-loop's inner fStatement, and the increment-expression block at the
780 // very end. We don't support that today, but it's doable.
781 // - The for-loop's built-in test-expression would need to be dropped entirely,
782 // and the loop would be halted via a break statement at the end of the
783 // inlined test-expression. This is again something we don't support today,
784 // but it could be implemented.
785 // - We cannot inline the increment-expression if the loop uses `continue`
786 // anywhere; that would skip over the inlined block that evaluates the
787 // increment expression. There isn't a good fix for this--any workaround would
788 // be more complex than the cost of a function call. However, loops that don't
789 // use `continue` would still be viable candidates for increment-expression
790 // inlining.
791 break;
792 }
793 case Statement::Kind::kIf: {
794 IfStatement& ifStmt = (*stmt)->as<IfStatement>();
795 this->visitExpression(&ifStmt.fTest);
796 this->visitStatement(&ifStmt.fIfTrue);
797 this->visitStatement(&ifStmt.fIfFalse);
798 break;
799 }
800 case Statement::Kind::kReturn: {
801 ReturnStatement& returnStmt = (*stmt)->as<ReturnStatement>();
802 this->visitExpression(&returnStmt.fExpression);
803 break;
804 }
805 case Statement::Kind::kSwitch: {
806 SwitchStatement& switchStmt = (*stmt)->as<SwitchStatement>();
807 if (switchStmt.fSymbols) {
808 fSymbolTableStack.push_back(switchStmt.fSymbols.get());
809 }
810
811 this->visitExpression(&switchStmt.fValue);
812 for (std::unique_ptr<SwitchCase>& switchCase : switchStmt.fCases) {
813 // The switch-case's fValue cannot be a FunctionCall; skip it.
814 for (std::unique_ptr<Statement>& caseBlock : switchCase->fStatements) {
815 this->visitStatement(&caseBlock);
816 }
817 }
818 break;
819 }
820 case Statement::Kind::kVarDeclaration: {
821 VarDeclaration& varDeclStmt = (*stmt)->as<VarDeclaration>();
822 // Don't need to scan the declaration's sizes; those are always IntLiterals.
823 this->visitExpression(&varDeclStmt.fValue);
824 break;
825 }
826 case Statement::Kind::kVarDeclarations: {
827 VarDeclarationsStatement& varDecls = (*stmt)->as<VarDeclarationsStatement>();
828 for (std::unique_ptr<Statement>& varDecl : varDecls.fDeclaration->fVars) {
829 this->visitStatement(&varDecl, /*isViableAsEnclosingStatement=*/false);
830 }
831 break;
832 }
833 case Statement::Kind::kWhile: {
834 WhileStatement& whileStmt = (*stmt)->as<WhileStatement>();
835 // The loop body is a candidate for inlining.
836 this->visitStatement(&whileStmt.fStatement);
837 // The inliner isn't smart enough to inline the test-expression for a while
838 // loop at this time. There are two limitations:
839 // - We would need to insert the inlined-body block at the very beginning of the
840 // while loop's inner fStatement. We don't support that today, but it's
841 // doable.
842 // - The while-loop's built-in test-expression would need to be replaced with a
843 // `true` BoolLiteral, and the loop would be halted via a break statement at
844 // the end of the inlined test-expression. This is again something we don't
845 // support today, but it could be implemented.
846 break;
847 }
848 default:
849 SkUNREACHABLE;
850 }
851
852 // Pop our symbol and enclosing-statement stacks.
853 fSymbolTableStack.resize(oldSymbolStackSize);
854 fEnclosingStmtStack.resize(oldEnclosingStmtStackSize);
855 }
856
857 void visitExpression(std::unique_ptr<Expression>* expr) {
858 if (!*expr) {
859 return;
860 }
861
862 switch ((*expr)->kind()) {
863 case Expression::Kind::kBoolLiteral:
864 case Expression::Kind::kDefined:
865 case Expression::Kind::kExternalValue:
866 case Expression::Kind::kFieldAccess:
867 case Expression::Kind::kFloatLiteral:
868 case Expression::Kind::kFunctionReference:
869 case Expression::Kind::kIntLiteral:
870 case Expression::Kind::kNullLiteral:
871 case Expression::Kind::kSetting:
872 case Expression::Kind::kTypeReference:
873 case Expression::Kind::kVariableReference:
874 // Nothing to scan here.
875 break;
876
877 case Expression::Kind::kBinary: {
878 BinaryExpression& binaryExpr = (*expr)->as<BinaryExpression>();
879 this->visitExpression(&binaryExpr.fLeft);
880
881 // Logical-and and logical-or binary expressions do not inline the right side,
882 // because that would invalidate short-circuiting. That is, when evaluating
883 // expressions like these:
884 // (false && x()) // always false
885 // (true || y()) // always true
886 // It is illegal for side-effects from x() or y() to occur. The simplest way to
887 // enforce that rule is to avoid inlining the right side entirely. However, it
888 // is safe for other types of binary expression to inline both sides.
889 bool shortCircuitable = (binaryExpr.fOperator == Token::Kind::TK_LOGICALAND ||
890 binaryExpr.fOperator == Token::Kind::TK_LOGICALOR);
891 if (!shortCircuitable) {
892 this->visitExpression(&binaryExpr.fRight);
893 }
894 break;
895 }
896 case Expression::Kind::kConstructor: {
897 Constructor& constructorExpr = (*expr)->as<Constructor>();
898 for (std::unique_ptr<Expression>& arg : constructorExpr.fArguments) {
899 this->visitExpression(&arg);
900 }
901 break;
902 }
903 case Expression::Kind::kExternalFunctionCall: {
904 ExternalFunctionCall& funcCallExpr = (*expr)->as<ExternalFunctionCall>();
905 for (std::unique_ptr<Expression>& arg : funcCallExpr.fArguments) {
906 this->visitExpression(&arg);
907 }
908 break;
909 }
910 case Expression::Kind::kFunctionCall: {
911 FunctionCall& funcCallExpr = (*expr)->as<FunctionCall>();
912 for (std::unique_ptr<Expression>& arg : funcCallExpr.fArguments) {
913 this->visitExpression(&arg);
914 }
915 this->addInlineCandidate(expr);
916 break;
917 }
918 case Expression::Kind::kIndex:{
919 IndexExpression& indexExpr = (*expr)->as<IndexExpression>();
920 this->visitExpression(&indexExpr.fBase);
921 this->visitExpression(&indexExpr.fIndex);
922 break;
923 }
924 case Expression::Kind::kPostfix: {
925 PostfixExpression& postfixExpr = (*expr)->as<PostfixExpression>();
926 this->visitExpression(&postfixExpr.fOperand);
927 break;
928 }
929 case Expression::Kind::kPrefix: {
930 PrefixExpression& prefixExpr = (*expr)->as<PrefixExpression>();
931 this->visitExpression(&prefixExpr.fOperand);
932 break;
933 }
934 case Expression::Kind::kSwizzle: {
935 Swizzle& swizzleExpr = (*expr)->as<Swizzle>();
936 this->visitExpression(&swizzleExpr.fBase);
937 break;
938 }
939 case Expression::Kind::kTernary: {
940 TernaryExpression& ternaryExpr = (*expr)->as<TernaryExpression>();
941 // The test expression is a candidate for inlining.
942 this->visitExpression(&ternaryExpr.fTest);
943 // The true- and false-expressions cannot be inlined, because we are only
944 // allowed to evaluate one side.
945 break;
946 }
947 default:
948 SkUNREACHABLE;
949 }
950 }
951
952 void addInlineCandidate(std::unique_ptr<Expression>* candidate) {
953 fInlineCandidates.push_back(InlineCandidate{fSymbolTableStack.back(),
954 fEnclosingStmtStack.back(), candidate});
955 }
956 };
957
958 // TODO(johnstiles): the analyzer can detect inlinable functions; actually inlining them will
959 // be tackled in a followup CL.
960 InlineCandidateAnalyzer analyzer;
961 analyzer.visit(program);
962 std::unordered_map<const FunctionDeclaration*, bool> inlinableMap; // <function, safe-to-inline>
963 for (InlineCandidate& candidate : analyzer.fInlineCandidates) {
964 const FunctionCall& funcCall = (*candidate.fCandidateExpr)->as<FunctionCall>();
965 const FunctionDeclaration* funcDecl = &funcCall.fFunction;
966 if (inlinableMap.find(funcDecl) == inlinableMap.end()) {
967 // We do not perform inlining on recursive calls to avoid an infinite death spiral of
968 // inlining.
969 int inlineThreshold = (funcDecl->fCallCount.load() > 1) ? fSettings->fInlineThreshold
970 : INT_MAX;
971 inlinableMap[funcDecl] = this->isSafeToInline(funcCall, inlineThreshold) &&
972 !contains_recursive_call(*funcDecl);
973/*
974 if (inlinableMap[funcDecl]) {
975 printf("-> Inliner discovered valid candidate: %s\n",
976 String(funcDecl->fName).c_str());
977 }
978*/
979 }
980 }
981
982 return false;
983}
984
John Stiles44e96be2020-08-31 13:16:04 -0400985} // namespace SkSL