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 };
 199
 200 /** Replaces expressions consisting entirely of literals with the results of
 201 evaluating the expression.*/
 202 class ConstantFolder: private TraversingVisitor
 203 {
 204 private:
 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;
 213
 214 public:
 215         bool apply(Stage &s) { s.content.visit(*this); return r_any_folded; }
 216
 217 private:
 218         template<typename T>
 219         static T evaluate_logical(char, T, T);
 220         template<typename T>
 221         static bool evaluate_relation(const char *, T, T);
 222         template<typename T>
 223         static T evaluate_arithmetic(char, T, T);
 224         template<typename T>
 225         static T evaluate_int_special_op(char, T, T);
 226         template<typename T>
 227         void convert_to_result(const Variant &);
 228         void set_result(const Variant &, bool = false);
 229
 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 &);
 242 };
 243
 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
 248 {
 249 private:
 250         enum ConstantStatus
 251         {
 252                 CONSTANT_FALSE,
 253                 CONSTANT_TRUE,
 254                 NOT_CONSTANT
 255         };
 256
 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;
 261
 262 public:
 263         void apply(Stage &);
 264
 265 private:
 266         ConstantStatus check_constant_condition(const Expression &);
 267
 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 &);
 276 };
 277
 278 class UnreachableCodeRemover: private TraversingVisitor
 279 {
 280 private:
 281         bool reachable = true;
 282         std::set<Node *> unreachable_nodes;
 283
 284 public:
 285         virtual bool apply(Stage &);
 286
 287 private:
 288         virtual void visit(Block &);
 289         virtual void visit(FunctionDeclaration &);
 290         virtual void visit(Conditional &);
 291         virtual void visit(Iteration &);
 292         virtual void visit(Return &) { reachable = false; }
 293         virtual void visit(Jump &) { reachable = false; }
 294 };
 295
 296 /** Removes types which are not used anywhere. */
 297 class UnusedTypeRemover: private TraversingVisitor
 298 {
 299 private:
 300         std::set<Node *> unused_nodes;
 301
 302 public:
 303         bool apply(Stage &);
 304
 305 private:
 306         virtual void visit(RefPtr<Expression> &);
 307         virtual void visit(BasicTypeDeclaration &);
 308         virtual void visit(ImageTypeDeclaration &);
 309         virtual void visit(StructDeclaration &);
 310         virtual void visit(VariableDeclaration &);
 311         virtual void visit(InterfaceBlock &);
 312         virtual void visit(FunctionDeclaration &);
 313 };
 314
 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
 318 {
 319 private:
 320         struct AssignmentInfo
 321         {
 322                 Node *node = 0;
 323                 Assignment::Target target;
 324                 std::vector<Node *> used_by;
 325                 unsigned in_loop = 0;
 326         };
 327
 328         struct VariableInfo
 329         {
 330                 InterfaceBlock *interface_block = 0;
 331                 std::vector<AssignmentInfo *> assignments;
 332                 bool initialized = false;
 333                 bool output = false;
 334                 bool referenced = false;
 335         };
 336
 337         typedef std::map<Statement *, VariableInfo> BlockVariableMap;
 338
 339         Stage *stage = 0;
 340         BlockVariableMap variables;
 341         std::list<AssignmentInfo> assignments;
 342         InterfaceBlock *interface_block = 0;
 343         Assignment *r_assignment = 0;
 344         bool assignment_target = false;
 345         bool r_side_effects = false;
 346         bool in_struct = false;
 347         bool composite_reference = false;
 348         unsigned in_loop = 0;
 349         std::vector<Node *> loop_ext_refs;
 350         Assignment::Target r_reference;
 351         std::set<Node *> unused_nodes;
 352
 353 public:
 354         bool apply(Stage &);
 355
 356 private:
 357         void referenced(const Assignment::Target &, Node &);
 358         virtual void visit(VariableReference &);
 359         virtual void visit(InterfaceBlockReference &);
 360         void visit_composite(Expression &);
 361         virtual void visit(MemberAccess &);
 362         virtual void visit(Swizzle &);
 363         virtual void visit(UnaryExpression &);
 364         virtual void visit(BinaryExpression &);
 365         virtual void visit(Assignment &);
 366         virtual void visit(TernaryExpression &);
 367         virtual void visit(FunctionCall &);
 368         void record_assignment(const Assignment::Target &, Node &);
 369         virtual void visit(ExpressionStatement &);
 370         virtual void visit(StructDeclaration &);
 371         virtual void visit(VariableDeclaration &);
 372         virtual void visit(InterfaceBlock &);
 373         void merge_variables(const BlockVariableMap &);
 374         virtual void visit(FunctionDeclaration &);
 375         virtual void visit(Conditional &);
 376         virtual void visit(Iteration &);
 377 };
 378
 379 /** Removes function declarations with no references to them. */
 380 class UnusedFunctionRemover: private TraversingVisitor
 381 {
 382 private:
 383         std::set<Node *> unused_nodes;
 384         std::set<FunctionDeclaration *> used_definitions;
 385
 386 public:
 387         bool apply(Stage &s);
 388
 389 private:
 390         virtual void visit(FunctionCall &);
 391         virtual void visit(FunctionDeclaration &);
 392 };
 393
 394 } // namespace SL
 395 } // namespace GL
 396 } // namespace Msp
 397
 398 #endif