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