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 StageVisitor
  14 {
  15 public:
  16         typedef std::set<FunctionDeclaration *> ResultType;
  17
  18 private:
  19         std::map<FunctionDeclaration *, unsigned> refcounts;
  20         std::set<FunctionDeclaration *> inlineable;
  21         FunctionDeclaration *in_function;
  22
  23 public:
  24         InlineableFunctionLocator();
  25
  26         const ResultType &get_result() const { return inlineable; }
  27         using StageVisitor::visit;
  28         virtual void visit(FunctionCall &);
  29         virtual void visit(FunctionDeclaration &);
  30 };
  31
  32 class FunctionInliner: public StageVisitor
  33 {
  34 private:
  35         std::set<FunctionDeclaration *> inlineable;
  36         unsigned extract_result;
  37         RefPtr<Expression> inline_result;
  38
  39 public:
  40         FunctionInliner();
  41         FunctionInliner(const std::set<FunctionDeclaration *> &);
  42
  43 private:
  44         void visit_and_inline(RefPtr<Expression> &);
  45 public:
  46         using StageVisitor::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         using StageVisitor::visit;
  67         virtual void visit(Block &);
  68         virtual void visit(UnaryExpression &);
  69         virtual void visit(Assignment &);
  70         virtual void visit(VariableDeclaration &);
  71         virtual void visit(Conditional &);
  72         virtual void visit(Iteration &);
  73 };
  74
  75 class UnusedVariableLocator: public StageVisitor
  76 {
  77 public:
  78         typedef std::set<Node *> ResultType;
  79
  80 private:
  81         struct VariableInfo
  82         {
  83                 bool local;
  84                 std::vector<Node *> assignments;
  85                 bool conditionally_assigned;
  86                 bool referenced;
  87
  88                 VariableInfo();
  89         };
  90
  91         typedef std::map<VariableDeclaration *, VariableInfo> BlockVariableMap;
  92
  93         std::set<Node *> unused_nodes;
  94         std::map<VariableDeclaration *, Node *> aggregates;
  95         Node *aggregate;
  96         std::vector<BlockVariableMap> variables;
  97         Assignment *assignment;
  98         bool assignment_target;
  99         bool assign_to_subscript;
 100         bool global_scope;
 101
 102 public:
 103         UnusedVariableLocator();
 104
 105         virtual void apply(Stage &);
 106         const ResultType &get_result() const { return unused_nodes; }
 107 private:
 108         using StageVisitor::visit;
 109         virtual void visit(VariableReference &);
 110         virtual void visit(MemberAccess &);
 111         virtual void visit(BinaryExpression &);
 112         virtual void visit(Assignment &);
 113         void record_assignment(VariableDeclaration &, Node &, bool);
 114         void clear_assignments(VariableInfo &, bool);
 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         void merge_down_variables();
 121         virtual void visit(Conditional &);
 122         virtual void visit(Iteration &);
 123 };
 124
 125 class UnusedFunctionLocator: public StageVisitor
 126 {
 127 public:
 128         typedef std::set<Node *> ResultType;
 129
 130 private:
 131         std::set<Node *> unused_nodes;
 132         std::set<FunctionDeclaration *> used_definitions;
 133
 134 public:
 135         const ResultType &get_result() const { return unused_nodes; }
 136         using StageVisitor::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