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 "evaluate.h"
   7 #include "visitor.h"
   8
   9 namespace Msp {
  10 namespace GL {
  11 namespace SL {
  12
  13 class InlineableFunctionLocator: private TraversingVisitor
  14 {
  15 private:
  16         std::map<FunctionDeclaration *, unsigned> refcounts;
  17         std::set<FunctionDeclaration *> inlineable;
  18         FunctionDeclaration *in_function;
  19
  20 public:
  21         InlineableFunctionLocator();
  22
  23         const std::set<FunctionDeclaration *> &apply(Stage &s) { s.content.visit(*this); return inlineable; }
  24
  25 private:
  26         virtual void visit(FunctionCall &);
  27         virtual void visit(FunctionDeclaration &);
  28 };
  29
  30 class FunctionInliner: private TraversingVisitor
  31 {
  32 private:
  33         std::set<FunctionDeclaration *> inlineable;
  34         unsigned extract_result;
  35         RefPtr<Expression> inline_result;
  36
  37 public:
  38         FunctionInliner();
  39
  40         void apply(Stage &);
  41
  42 private:
  43         void visit_and_inline(RefPtr<Expression> &);
  44
  45         virtual void visit(Block &);
  46         virtual void visit(UnaryExpression &);
  47         virtual void visit(BinaryExpression &);
  48         virtual void visit(MemberAccess &);
  49         virtual void visit(FunctionCall &);
  50         virtual void visit(VariableDeclaration &);
  51         virtual void visit(Return &);
  52 };
  53
  54 class ConstantConditionEliminator: private TraversingVisitor
  55 {
  56 private:
  57         bool record_only;
  58         ExpressionEvaluator::ValueMap variable_values;
  59         NodeList<Statement>::iterator insert_point;
  60         std::set<Node *> nodes_to_remove;
  61
  62 public:
  63         ConstantConditionEliminator();
  64
  65         void apply(Stage &);
  66
  67 private:
  68         virtual void visit(Block &);
  69         virtual void visit(UnaryExpression &);
  70         virtual void visit(Assignment &);
  71         virtual void visit(VariableDeclaration &);
  72         virtual void visit(Conditional &);
  73         virtual void visit(Iteration &);
  74 };
  75
  76 class UnusedVariableRemover: private TraversingVisitor
  77 {
  78 private:
  79         struct VariableInfo
  80         {
  81                 bool local;
  82                 std::vector<Node *> assignments;
  83                 bool conditionally_assigned;
  84                 bool referenced;
  85
  86                 VariableInfo();
  87         };
  88
  89         typedef std::map<VariableDeclaration *, VariableInfo> BlockVariableMap;
  90
  91         std::set<Node *> unused_nodes;
  92         std::map<VariableDeclaration *, Node *> aggregates;
  93         Node *aggregate;
  94         std::vector<BlockVariableMap> variables;
  95         Assignment *assignment;
  96         bool assignment_target;
  97         bool assign_to_subscript;
  98
  99 public:
 100         UnusedVariableRemover();
 101
 102         bool apply(Stage &);
 103
 104 private:
 105         virtual void visit(VariableReference &);
 106         virtual void visit(MemberAccess &);
 107         virtual void visit(BinaryExpression &);
 108         virtual void visit(Assignment &);
 109         void record_assignment(VariableDeclaration &, Node &, bool);
 110         void clear_assignments(VariableInfo &, bool);
 111         virtual void visit(ExpressionStatement &);
 112         virtual void visit(StructDeclaration &);
 113         virtual void visit(VariableDeclaration &);
 114         virtual void visit(InterfaceBlock &);
 115         virtual void visit(FunctionDeclaration &);
 116         void merge_down_variables();
 117         virtual void visit(Conditional &);
 118         virtual void visit(Iteration &);
 119 };
 120
 121 class UnusedFunctionRemover: private TraversingVisitor
 122 {
 123 private:
 124         std::set<Node *> unused_nodes;
 125         std::set<FunctionDeclaration *> used_definitions;
 126
 127 public:
 128         bool apply(Stage &s);
 129
 130 private:
 131         virtual void visit(FunctionCall &);
 132         virtual void visit(FunctionDeclaration &);
 133 };
 134
 135 } // namespace SL
 136 } // namespace GL
 137 } // namespace Msp
 138
 139 #endif