1 #ifndef MSP_GL_SL_OPTIMIZE_H_
2 #define MSP_GL_SL_OPTIMIZE_H_
12 /** Assigns values to specialization constants, turning them into normal
14 class ConstantSpecializer: private TraversingVisitor
17 const std::map<std::string, int> *values = 0;
20 void apply(Stage &, const std::map<std::string, int> &);
23 virtual void visit(VariableDeclaration &);
26 /** Finds functions which are candidates for inlining. Currently this means
27 functions which have no flow control statements, no more than one return
28 statement, and are either builtins or only called once. */
29 class InlineableFunctionLocator: private TraversingVisitor
32 std::map<FunctionDeclaration *, unsigned> refcounts;
33 std::set<FunctionDeclaration *> inlineable;
34 FunctionDeclaration *current_function = 0;
35 unsigned return_count = 0;
38 std::set<FunctionDeclaration *> apply(Stage &s) { s.content.visit(*this); return inlineable; }
41 virtual void visit(FunctionCall &);
42 virtual void visit(FunctionDeclaration &);
43 virtual void visit(Conditional &);
44 virtual void visit(Iteration &);
45 virtual void visit(Return &);
48 /** Injects statements from one function into another. Local variables are
49 renamed to avoid conflicts. After inlining, uses NodeReorderer to cause
50 dependencies of the inlined statements to appear before the target function. */
51 class InlineContentInjector: private TraversingVisitor
61 FunctionDeclaration *source_func = 0;
63 Pass pass = REFERENCED;
64 RefPtr<Statement> r_inlined_statement;
65 std::set<Node *> dependencies;
66 std::set<std::string> referenced_names;
67 std::string r_result_name;
70 std::string apply(Stage &, FunctionDeclaration &, Block &, const NodeList<Statement>::iterator &, FunctionCall &);
73 virtual void visit(VariableReference &);
74 virtual void visit(FunctionCall &);
75 virtual void visit(VariableDeclaration &);
76 virtual void visit(Return &);
79 /** Inlines functions. Internally uses InlineableFunctionLocator to find
80 candidate functions. Only functions which consist of a single return statement
82 class FunctionInliner: private TraversingVisitor
86 std::set<FunctionDeclaration *> inlineable;
87 FunctionDeclaration *current_function = 0;
88 NodeList<Statement>::iterator insert_point;
89 RefPtr<Expression> r_inline_result;
90 bool r_any_inlined = false;
91 bool r_inlined_here = false;
97 virtual void visit(RefPtr<Expression> &);
98 virtual void visit(Block &);
99 virtual void visit(FunctionCall &);
100 virtual void visit(FunctionDeclaration &);
101 virtual void visit(Iteration &);
104 /** Inlines variables into expressions. Variables with trivial values (those
105 consisting of a single literal or variable reference) are always inlined.
106 Variables which are only referenced once are also inlined. */
107 class ExpressionInliner: private TraversingVisitor
112 RefPtr<Expression> *reference = 0;
113 Block *ref_scope = 0;
114 bool blocked = false;
117 struct ExpressionInfo
119 Assignment::Target target;
120 RefPtr<Expression> expression;
121 Block *assign_scope = 0;
122 std::vector<ExpressionUse> uses;
123 bool trivial = false;
124 bool blocked = false;
127 std::list<ExpressionInfo> expressions;
128 std::map<Assignment::Target, ExpressionInfo *> assignments;
129 ExpressionInfo *r_ref_info = 0;
130 bool r_trivial = false;
131 bool access_read = true;
132 bool access_write = false;
133 bool iteration_init = false;
134 Block *iteration_body = 0;
135 const Operator *r_oper = 0;
141 virtual void visit(RefPtr<Expression> &);
142 virtual void visit(VariableReference &);
143 virtual void visit(MemberAccess &);
144 virtual void visit(Swizzle &);
145 virtual void visit(UnaryExpression &);
146 virtual void visit(BinaryExpression &);
147 virtual void visit(Assignment &);
148 virtual void visit(TernaryExpression &);
149 virtual void visit(FunctionCall &);
150 virtual void visit(VariableDeclaration &);
151 virtual void visit(Iteration &);
155 Breaks aggregates up into separate variables if only the individual fields are
156 accessed and not the aggregate as a whole.
158 class AggregateDismantler: public TraversingVisitor
161 struct AggregateMember
163 const VariableDeclaration *declaration = 0;
165 RefPtr<Expression> initializer;
166 std::vector<RefPtr<Expression> *> references;
171 VariableDeclaration *declaration = 0;
172 Block *decl_scope = 0;
173 NodeList<Statement>::iterator insert_point;
174 std::vector<AggregateMember> members;
175 bool referenced = false;
176 bool members_referenced = false;
179 NodeList<Statement>::iterator insert_point;
180 std::map<Statement *, Aggregate> aggregates;
181 bool composite_reference = false;
182 Assignment::Target r_reference;
183 Aggregate *r_aggregate_ref = 0;
189 virtual void visit(Block &);
190 virtual void visit(RefPtr<Expression> &);
191 virtual void visit(VariableReference &);
192 void visit_composite(RefPtr<Expression> &);
193 virtual void visit(MemberAccess &);
194 virtual void visit(BinaryExpression &);
195 virtual void visit(StructDeclaration &) { }
196 virtual void visit(VariableDeclaration &);
197 virtual void visit(FunctionDeclaration &);
200 /** Replaces expressions consisting entirely of literals with the results of
201 evaluating the expression.*/
202 class ConstantFolder: private TraversingVisitor
205 VariableDeclaration *iteration_var = 0;
206 Variant iter_init_value;
207 Variant r_constant_value;
208 bool iteration_init = false;
209 bool r_constant = false;
210 bool r_literal = false;
211 bool r_uses_iter_var = false;
212 bool r_any_folded = false;
215 bool apply(Stage &s) { s.content.visit(*this); return r_any_folded; }
219 static T evaluate_logical(char, T, T);
221 static bool evaluate_relation(const char *, T, T);
223 static T evaluate_arithmetic(char, T, T);
225 static T evaluate_int_special_op(char, T, T);
227 void convert_to_result(const Variant &);
228 void set_result(const Variant &, bool = false);
230 virtual void visit(RefPtr<Expression> &);
231 virtual void visit(Literal &);
232 virtual void visit(VariableReference &);
233 virtual void visit(MemberAccess &);
234 virtual void visit(Swizzle &);
235 virtual void visit(UnaryExpression &);
236 virtual void visit(BinaryExpression &);
237 virtual void visit(Assignment &);
238 virtual void visit(TernaryExpression &);
239 virtual void visit(FunctionCall &);
240 virtual void visit(VariableDeclaration &);
241 virtual void visit(Iteration &);
244 /** Removes conditional statements and loops where the condition can be
245 determined as constant at compile time. Also removes such statements where
246 the body is empty and the condition has no side effects. */
247 class ConstantConditionEliminator: private TraversingVisitor
257 NodeList<Statement>::iterator insert_point;
258 std::set<Node *> nodes_to_remove;
259 RefPtr<Expression> r_ternary_result;
260 bool r_external_side_effects = false;
266 ConstantStatus check_constant_condition(const Expression &);
268 virtual void visit(Block &);
269 virtual void visit(RefPtr<Expression> &);
270 virtual void visit(UnaryExpression &);
271 virtual void visit(Assignment &);
272 virtual void visit(TernaryExpression &);
273 virtual void visit(FunctionCall &);
274 virtual void visit(Conditional &);
275 virtual void visit(Iteration &);
278 /** Removes code which is never executed due to flow control statements. */
279 class UnreachableCodeRemover: private TraversingVisitor
282 bool reachable = true;
283 std::set<Node *> unreachable_nodes;
286 virtual bool apply(Stage &);
289 virtual void visit(Block &);
290 virtual void visit(FunctionDeclaration &);
291 virtual void visit(Conditional &);
292 virtual void visit(Iteration &);
293 virtual void visit(Return &) { reachable = false; }
294 virtual void visit(Jump &) { reachable = false; }
297 /** Removes types which are not used anywhere. */
298 class UnusedTypeRemover: private TraversingVisitor
301 std::set<Node *> unused_nodes;
307 virtual void visit(RefPtr<Expression> &);
308 virtual void visit(BasicTypeDeclaration &);
309 virtual void visit(ImageTypeDeclaration &);
310 virtual void visit(StructDeclaration &);
311 virtual void visit(VariableDeclaration &);
312 virtual void visit(FunctionDeclaration &);
315 /** Removes variable declarations with no references to them. Assignment
316 statements where the result is not used are also removed. */
317 class UnusedVariableRemover: private TraversingVisitor
320 struct AssignmentInfo
323 Assignment::Target target;
324 std::vector<Node *> used_by;
325 unsigned in_loop = 0;
330 std::vector<AssignmentInfo *> assignments;
331 bool initialized = false;
333 bool referenced = false;
336 typedef std::map<Statement *, VariableInfo> BlockVariableMap;
339 BlockVariableMap variables;
340 std::list<AssignmentInfo> assignments;
341 Assignment *r_assignment = 0;
342 bool assignment_target = false;
343 bool r_side_effects = false;
344 bool in_struct = false;
345 bool composite_reference = false;
346 unsigned in_loop = 0;
347 std::vector<Node *> loop_ext_refs;
348 Assignment::Target r_reference;
349 std::set<Node *> unused_nodes;
355 void referenced(const Assignment::Target &, Node &);
356 virtual void visit(VariableReference &);
357 void visit_composite(Expression &);
358 virtual void visit(MemberAccess &);
359 virtual void visit(Swizzle &);
360 virtual void visit(UnaryExpression &);
361 virtual void visit(BinaryExpression &);
362 virtual void visit(Assignment &);
363 virtual void visit(TernaryExpression &);
364 virtual void visit(FunctionCall &);
365 void record_assignment(const Assignment::Target &, Node &);
366 virtual void visit(ExpressionStatement &);
367 virtual void visit(StructDeclaration &);
368 virtual void visit(VariableDeclaration &);
369 void merge_variables(const BlockVariableMap &);
370 virtual void visit(FunctionDeclaration &);
371 virtual void visit(Conditional &);
372 virtual void visit(Iteration &);
375 /** Removes function declarations with no references to them. */
376 class UnusedFunctionRemover: private TraversingVisitor
379 std::set<Node *> unused_nodes;
380 std::set<FunctionDeclaration *> used_definitions;
383 bool apply(Stage &s);
386 virtual void visit(FunctionCall &);
387 virtual void visit(FunctionDeclaration &);