X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;ds=sidebyside;f=source%2Fglsl%2Foptimize.h;h=6d4b1bcb5d2c2e5d883d7ab640390481c8c7e84e;hb=4790c6a06072814b21f5b3f24b53c6936915308d;hp=4663c12ec12e6ffcaf4fe946fff5bbc36cc5ed90;hpb=daff631cf87db75bcae616605e759d281258d9e4;p=libs%2Fgl.git diff --git a/source/glsl/optimize.h b/source/glsl/optimize.h index 4663c12e..6d4b1bcb 100644 --- a/source/glsl/optimize.h +++ b/source/glsl/optimize.h @@ -3,7 +3,6 @@ #include #include -#include "evaluate.h" #include "visitor.h" namespace Msp { @@ -11,8 +10,8 @@ namespace GL { namespace SL { /** Finds functions which are candidates for inlining. Currently this means -functions which have no parameters, contain no more than one return statement, -and are only called once. */ +functions which have no flow control statements, no more than one return +statement, and are only called once. */ class InlineableFunctionLocator: private TraversingVisitor { private: @@ -40,23 +39,29 @@ dependencies of the inlined statements to appear before the target function. */ class InlineContentInjector: private TraversingVisitor { private: + enum Pass + { + DEPENDS, + REFERENCED, + INLINE, + RENAME + }; + FunctionDeclaration *source_func; - Block *target_block; - std::map variable_map; - bool remap_names; - bool deps_only; + Block staging_block; + std::string remap_prefix; + Pass pass; RefPtr r_inlined_statement; std::set dependencies; + std::set referenced_names; std::string r_result_name; public: InlineContentInjector(); - const std::string &apply(Stage &, FunctionDeclaration &, Block &, const NodeList::iterator &, FunctionDeclaration &); + const std::string &apply(Stage &, FunctionDeclaration &, Block &, const NodeList::iterator &, FunctionCall &); private: - std::string create_unused_name(const std::string &, bool); - virtual void visit(VariableReference &); virtual void visit(InterfaceBlockReference &); virtual void visit(FunctionCall &); @@ -76,6 +81,7 @@ private: NodeList::iterator insert_point; RefPtr r_inline_result; bool r_any_inlined; + bool r_inlined_here; public: FunctionInliner(); @@ -83,21 +89,11 @@ public: bool apply(Stage &); private: - void visit_and_inline(RefPtr &); - + virtual void visit(RefPtr &); virtual void visit(Block &); - virtual void visit(UnaryExpression &); - virtual void visit(BinaryExpression &); - virtual void visit(Assignment &a) { visit(static_cast(a)); } - virtual void visit(MemberAccess &); - virtual void visit(Swizzle &); virtual void visit(FunctionCall &); - virtual void visit(ExpressionStatement &); - virtual void visit(VariableDeclaration &); virtual void visit(FunctionDeclaration &); - virtual void visit(Conditional &); virtual void visit(Iteration &); - virtual void visit(Return &); }; /** Inlines variables into expressions. Variables with trivial values (those @@ -111,9 +107,6 @@ private: Expression *expression; Block *assign_scope; RefPtr *inline_point; - const Operator *inner_oper; - const Operator *outer_oper; - bool inline_on_rhs; bool trivial; bool available; @@ -135,20 +128,60 @@ public: bool apply(Stage &); private: - void visit_and_record(RefPtr &, const Operator *, bool); - void inline_expression(Expression &, RefPtr &, const Operator *, const Operator *, bool); + void inline_expression(Expression &, RefPtr &); virtual void visit(Block &); + virtual void visit(RefPtr &); virtual void visit(VariableReference &); virtual void visit(MemberAccess &); virtual void visit(Swizzle &); virtual void visit(UnaryExpression &); virtual void visit(BinaryExpression &); virtual void visit(Assignment &); + virtual void visit(TernaryExpression &); + virtual void visit(FunctionCall &); + virtual void visit(VariableDeclaration &); + virtual void visit(Iteration &); +}; + +/** Replaces expressions consisting entirely of literals with the results of +evaluating the expression.*/ +class ConstantFolder: private TraversingVisitor +{ +private: + VariableDeclaration *iteration_var; + Variant iter_init_value; + Variant r_constant_value; + bool iteration_init; + bool r_constant; + bool r_literal; + bool r_uses_iter_var; + bool r_any_folded; + +public: + bool apply(Stage &s) { s.content.visit(*this); return r_any_folded; } + +private: + static BasicTypeDeclaration::Kind get_value_kind(const Variant &); + template + static T evaluate_logical(char, T, T); + template + static bool evaluate_relation(const char *, T, T); + template + static T evaluate_arithmetic(char, T, T); + void set_result(const Variant &, bool = false); + + virtual void visit(RefPtr &); + virtual void visit(Literal &); + virtual void visit(VariableReference &); + virtual void visit(MemberAccess &); + virtual void visit(Swizzle &); + virtual void visit(UnaryExpression &); + virtual void visit(BinaryExpression &); + virtual void visit(Assignment &); + virtual void visit(TernaryExpression &); virtual void visit(FunctionCall &); virtual void visit(VariableDeclaration &); - virtual void visit(Conditional &); virtual void visit(Iteration &); - virtual void visit(Return &); }; /** Removes conditional statements and loops where the condition can be @@ -156,14 +189,26 @@ determined as constant at compile time. */ class ConstantConditionEliminator: private TraversingVisitor { private: + enum ConstantStatus + { + CONSTANT_FALSE, + CONSTANT_TRUE, + NOT_CONSTANT + }; + NodeList::iterator insert_point; std::set nodes_to_remove; + RefPtr r_ternary_result; public: void apply(Stage &); private: + ConstantStatus check_constant_condition(const Expression &); + virtual void visit(Block &); + virtual void visit(RefPtr &); + virtual void visit(TernaryExpression &); virtual void visit(Conditional &); virtual void visit(Iteration &); }; @@ -181,6 +226,7 @@ private: virtual void visit(Literal &); virtual void visit(UnaryExpression &); virtual void visit(BinaryExpression &); + virtual void visit(TernaryExpression &); virtual void visit(FunctionCall &); virtual void visit(BasicTypeDeclaration &); virtual void visit(ImageTypeDeclaration &); @@ -195,27 +241,36 @@ statements where the result is not used are also removed. */ class UnusedVariableRemover: private TraversingVisitor { private: + struct AssignmentInfo + { + Node *node; + Assignment::Target target; + std::vector used_by; + + AssignmentInfo(): node(0) { } + }; + struct VariableInfo { - std::vector assignments; - bool local; + InterfaceBlock *interface_block; + std::vector assignments; + bool initialized; bool output; - bool conditionally_assigned; bool referenced; - InterfaceBlock *interface_block; - VariableInfo(); + VariableInfo(): interface_block(0), initialized(false), output(false), referenced(false) { } }; - typedef std::map BlockVariableMap; + typedef std::map BlockVariableMap; Stage *stage; - std::set unused_nodes; - std::vector variables; + BlockVariableMap variables; + std::list assignments; InterfaceBlock *interface_block; Assignment *r_assignment; bool assignment_target; bool r_side_effects; + std::set unused_nodes; public: UnusedVariableRemover(); @@ -223,22 +278,21 @@ public: bool apply(Stage &); private: - void reference_used(Statement &); + void referenced(const Assignment::Target &, Node &); virtual void visit(VariableReference &); virtual void visit(InterfaceBlockReference &); virtual void visit(UnaryExpression &); virtual void visit(BinaryExpression &); virtual void visit(Assignment &); - void record_assignment(const Assignment::Target &, Node &, bool); - void clear_assignments(VariableInfo &, bool); virtual void visit(FunctionCall &); + void record_assignment(const Assignment::Target &, Node &); virtual void visit(ExpressionStatement &); // Ignore structs because their members can't be accessed directly. virtual void visit(StructDeclaration &) { } virtual void visit(VariableDeclaration &); virtual void visit(InterfaceBlock &); + void merge_variables(const BlockVariableMap &); virtual void visit(FunctionDeclaration &); - void merge_down_variables(); virtual void visit(Conditional &); virtual void visit(Iteration &); };