source/glsl/optimize.h

   1 #ifndef MSP_GL_SL_OPTIMIZE_H_
   2 #define MSP_GL_SL_OPTIMIZE_H_
   3
   4 #include <map>
   5 #include <set>
   6 #include "visitor.h"
   7
   8 namespace Msp {
   9 namespace GL {
  10 namespace SL {
  11
  12 /** Assigns values to specialization constants, turning them into normal
  13 constants. */
  14 class ConstantSpecializer: private TraversingVisitor
  15 {
  16 private:
  17         const std::map<std::string, int> *values = 0;
  18
  19 public:
  20         void apply(Stage &, const std::map<std::string, int> &);
  21
  22 private:
  23         virtual void visit(VariableDeclaration &);
  24 };
  25
  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
  30 {
  31 private:
  32         std::map<FunctionDeclaration *, unsigned> refcounts;
  33         std::set<FunctionDeclaration *> inlineable;
  34         FunctionDeclaration *current_function = 0;
  35         unsigned return_count = 0;
  36
  37 public:
  38         std::set<FunctionDeclaration *> apply(Stage &s) { s.content.visit(*this); return inlineable; }
  39
  40 private:
  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 &);
  46 };
  47
  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
  52 {
  53 private:
  54         enum Pass
  55         {
  56                 REFERENCED,
  57                 INLINE,
  58                 RENAME
  59         };
  60
  61         FunctionDeclaration *source_func = 0;
  62         Block staging_block;
  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;
  68
  69 public:
  70         std::string apply(Stage &, FunctionDeclaration &, Block &, const NodeList<Statement>::iterator &, FunctionCall &);
  71
  72 private:
  73         virtual void visit(VariableReference &);
  74         virtual void visit(InterfaceBlockReference &);
  75         virtual void visit(FunctionCall &);
  76         virtual void visit(VariableDeclaration &);
  77         virtual void visit(Return &);
  78 };
  79
  80 /** Inlines functions.  Internally uses InlineableFunctionLocator to find
  81 candidate functions.  Only functions which consist of a single return statement
  82 are inlined. */
  83 class FunctionInliner: private TraversingVisitor
  84 {
  85 private:
  86         Stage *stage = 0;
  87         std::set<FunctionDeclaration *> inlineable;
  88         FunctionDeclaration *current_function = 0;
  89         NodeList<Statement>::iterator insert_point;
  90         RefPtr<Expression> r_inline_result;
  91         bool r_any_inlined = false;
  92         bool r_inlined_here = false;
  93
  94 public:
  95         bool apply(Stage &);
  96
  97 private:
  98         virtual void visit(RefPtr<Expression> &);
  99         virtual void visit(Block &);
 100         virtual void visit(FunctionCall &);
 101         virtual void visit(FunctionDeclaration &);
 102         virtual void visit(Iteration &);
 103 };
 104
 105 /** Inlines variables into expressions.  Variables with trivial values (those
 106 consisting of a single literal or variable reference) are always inlined.
 107 Variables which are only referenced once are also inlined. */
 108 class ExpressionInliner: private TraversingVisitor
 109 {
 110 private:
 111         struct ExpressionUse
 112         {
 113                 RefPtr<Expression> *reference = 0;
 114                 Block *ref_scope = 0;
 115                 bool blocked = false;
 116         };
 117
 118         struct ExpressionInfo
 119         {
 120                 Assignment::Target target;
 121                 RefPtr<Expression> expression;
 122                 Block *assign_scope = 0;
 123                 std::vector<ExpressionUse> uses;
 124                 bool trivial = false;
 125         };
 126
 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;
 136
 137 public:
 138         bool apply(Stage &);
 139
 140 private:
 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 &);
 152 };
 153
 154 /**
 155 Breaks aggregates up into separate variables if only the individual fields are
 156 accessed and not the aggregate as a whole.
 157 */
 158 class AggregateDismantler: public TraversingVisitor
 159 {
 160 private:
 161         struct AggregateMember
 162         {
 163                 const VariableDeclaration *declaration = 0;
 164                 unsigned index = 0;
 165                 RefPtr<Expression> initializer;
 166                 std::vector<RefPtr<Expression> *> references;
 167         };
 168
 169         struct Aggregate
 170         {
 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;
 177         };
 178
 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;
 184
 185 public:
 186         bool apply(Stage &);
 187
 188 private:
 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(InterfaceBlock &) { }
 198         virtual void visit(FunctionDeclaration &);
 199 };
 200
 201 /** Replaces expressions consisting entirely of literals with the results of
 202 evaluating the expression.*/
 203 class ConstantFolder: private TraversingVisitor
 204 {
 205 private:
 206         VariableDeclaration *iteration_var = 0;
 207         Variant iter_init_value;
 208         Variant r_constant_value;
 209         bool iteration_init = false;
 210         bool r_constant = false;
 211         bool r_literal = false;
 212         bool r_uses_iter_var = false;
 213         bool r_any_folded = false;
 214
 215 public:
 216         bool apply(Stage &s) { s.content.visit(*this); return r_any_folded; }
 217
 218 private:
 219         template<typename T>
 220         static T evaluate_logical(char, T, T);
 221         template<typename T>
 222         static bool evaluate_relation(const char *, T, T);
 223         template<typename T>
 224         static T evaluate_arithmetic(char, T, T);
 225         template<typename T>
 226         static T evaluate_int_special_op(char, T, T);
 227         template<typename T>
 228         void convert_to_result(const Variant &);
 229         void set_result(const Variant &, bool = false);
 230
 231         virtual void visit(RefPtr<Expression> &);
 232         virtual void visit(Literal &);
 233         virtual void visit(VariableReference &);
 234         virtual void visit(MemberAccess &);
 235         virtual void visit(Swizzle &);
 236         virtual void visit(UnaryExpression &);
 237         virtual void visit(BinaryExpression &);
 238         virtual void visit(Assignment &);
 239         virtual void visit(TernaryExpression &);
 240         virtual void visit(FunctionCall &);
 241         virtual void visit(VariableDeclaration &);
 242         virtual void visit(Iteration &);
 243 };
 244
 245 /** Removes conditional statements and loops where the condition can be
 246 determined as constant at compile time.  Also removes such statements where
 247 the body is empty and the condition has no side effects. */
 248 class ConstantConditionEliminator: private TraversingVisitor
 249 {
 250 private:
 251         enum ConstantStatus
 252         {
 253                 CONSTANT_FALSE,
 254                 CONSTANT_TRUE,
 255                 NOT_CONSTANT
 256         };
 257
 258         NodeList<Statement>::iterator insert_point;
 259         std::set<Node *> nodes_to_remove;
 260         RefPtr<Expression> r_ternary_result;
 261         bool r_external_side_effects = false;
 262
 263 public:
 264         void apply(Stage &);
 265
 266 private:
 267         ConstantStatus check_constant_condition(const Expression &);
 268
 269         virtual void visit(Block &);
 270         virtual void visit(RefPtr<Expression> &);
 271         virtual void visit(UnaryExpression &);
 272         virtual void visit(Assignment &);
 273         virtual void visit(TernaryExpression &);
 274         virtual void visit(FunctionCall &);
 275         virtual void visit(Conditional &);
 276         virtual void visit(Iteration &);
 277 };
 278
 279 class UnreachableCodeRemover: private TraversingVisitor
 280 {
 281 private:
 282         bool reachable = true;
 283         std::set<Node *> unreachable_nodes;
 284
 285 public:
 286         virtual bool apply(Stage &);
 287
 288 private:
 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; }
 295 };
 296
 297 /** Removes types which are not used anywhere. */
 298 class UnusedTypeRemover: private TraversingVisitor
 299 {
 300 private:
 301         std::set<Node *> unused_nodes;
 302
 303 public:
 304         bool apply(Stage &);
 305
 306 private:
 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(InterfaceBlock &);
 313         virtual void visit(FunctionDeclaration &);
 314 };
 315
 316 /** Removes variable declarations with no references to them.  Assignment
 317 statements where the result is not used are also removed. */
 318 class UnusedVariableRemover: private TraversingVisitor
 319 {
 320 private:
 321         struct AssignmentInfo
 322         {
 323                 Node *node = 0;
 324                 Assignment::Target target;
 325                 std::vector<Node *> used_by;
 326                 unsigned in_loop = 0;
 327         };
 328
 329         struct VariableInfo
 330         {
 331                 InterfaceBlock *interface_block = 0;
 332                 std::vector<AssignmentInfo *> assignments;
 333                 bool initialized = false;
 334                 bool output = false;
 335                 bool referenced = false;
 336         };
 337
 338         typedef std::map<Statement *, VariableInfo> BlockVariableMap;
 339
 340         Stage *stage = 0;
 341         BlockVariableMap variables;
 342         std::list<AssignmentInfo> assignments;
 343         InterfaceBlock *interface_block = 0;
 344         Assignment *r_assignment = 0;
 345         bool assignment_target = false;
 346         bool r_side_effects = false;
 347         bool in_struct = false;
 348         bool composite_reference = false;
 349         unsigned in_loop = 0;
 350         std::vector<Node *> loop_ext_refs;
 351         Assignment::Target r_reference;
 352         std::set<Node *> unused_nodes;
 353
 354 public:
 355         bool apply(Stage &);
 356
 357 private:
 358         void referenced(const Assignment::Target &, Node &);
 359         virtual void visit(VariableReference &);
 360         virtual void visit(InterfaceBlockReference &);
 361         void visit_composite(Expression &);
 362         virtual void visit(MemberAccess &);
 363         virtual void visit(Swizzle &);
 364         virtual void visit(UnaryExpression &);
 365         virtual void visit(BinaryExpression &);
 366         virtual void visit(Assignment &);
 367         virtual void visit(TernaryExpression &);
 368         virtual void visit(FunctionCall &);
 369         void record_assignment(const Assignment::Target &, Node &);
 370         virtual void visit(ExpressionStatement &);
 371         virtual void visit(StructDeclaration &);
 372         virtual void visit(VariableDeclaration &);
 373         virtual void visit(InterfaceBlock &);
 374         void merge_variables(const BlockVariableMap &);
 375         virtual void visit(FunctionDeclaration &);
 376         virtual void visit(Conditional &);
 377         virtual void visit(Iteration &);
 378 };
 379
 380 /** Removes function declarations with no references to them. */
 381 class UnusedFunctionRemover: private TraversingVisitor
 382 {
 383 private:
 384         std::set<Node *> unused_nodes;
 385         std::set<FunctionDeclaration *> used_definitions;
 386
 387 public:
 388         bool apply(Stage &s);
 389
 390 private:
 391         virtual void visit(FunctionCall &);
 392         virtual void visit(FunctionDeclaration &);
 393 };
 394
 395 } // namespace SL
 396 } // namespace GL
 397 } // namespace Msp
 398
 399 #endif