X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Foptimize.h;h=249a859a03763c6e198b9c0f04020dc0589ea360;hb=3415ed0f925d781df9d8243e0f4c454516b1c450;hp=ea772b3d841b1ef78171d99ebb9afef064a76dfd;hpb=ab5f2e6f1ddd35f8f117460530d76c0ba0c9bc87;p=libs%2Fgl.git diff --git a/source/glsl/optimize.h b/source/glsl/optimize.h index ea772b3d..249a859a 100644 --- a/source/glsl/optimize.h +++ b/source/glsl/optimize.h @@ -3,104 +3,286 @@ #include #include -#include "evaluate.h" #include "visitor.h" namespace Msp { namespace GL { namespace SL { +/** Assigns values to specialization constants, turning them into normal +constants. */ +class ConstantSpecializer: private TraversingVisitor +{ +private: + const std::map *values; + +public: + ConstantSpecializer(); + + void apply(Stage &, const std::map &); + +private: + virtual void visit(VariableDeclaration &); +}; + +/** Finds functions which are candidates for inlining. Currently this means +functions which have no flow control statements, no more than one return +statement, and are only called once. */ class InlineableFunctionLocator: private TraversingVisitor { private: std::map refcounts; std::set inlineable; - FunctionDeclaration *in_function; + FunctionDeclaration *current_function; + unsigned return_count; public: InlineableFunctionLocator(); - const std::set &apply(Stage &s) { visit(s.content); return inlineable; } + std::set apply(Stage &s) { s.content.visit(*this); return inlineable; } private: virtual void visit(FunctionCall &); virtual void visit(FunctionDeclaration &); - using TraversingVisitor::visit; + virtual void visit(Conditional &); + virtual void visit(Iteration &); + virtual void visit(Return &); }; +/** Injects statements from one function into another. Local variables are +renamed to avoid conflicts. After inlining, uses NodeReorderer to cause +dependencies of the inlined statements to appear before the target function. */ +class InlineContentInjector: private TraversingVisitor +{ +private: + enum Pass + { + REFERENCED, + INLINE, + RENAME + }; + + FunctionDeclaration *source_func; + Block staging_block; + Pass pass; + RefPtr r_inlined_statement; + std::set dependencies; + std::set referenced_names; + std::string r_result_name; + +public: + InlineContentInjector(); + + std::string apply(Stage &, FunctionDeclaration &, Block &, const NodeList::iterator &, FunctionCall &); + +private: + virtual void visit(VariableReference &); + virtual void visit(InterfaceBlockReference &); + virtual void visit(FunctionCall &); + virtual void visit(VariableDeclaration &); + virtual void visit(Return &); +}; + +/** Inlines functions. Internally uses InlineableFunctionLocator to find +candidate functions. Only functions which consist of a single return statement +are inlined. */ class FunctionInliner: private TraversingVisitor { private: + Stage *stage; std::set inlineable; - unsigned extract_result; - RefPtr inline_result; + FunctionDeclaration *current_function; + NodeList::iterator insert_point; + RefPtr r_inline_result; + bool r_any_inlined; + bool r_inlined_here; public: FunctionInliner(); - void apply(Stage &); + bool apply(Stage &); private: - void visit_and_inline(RefPtr &); + virtual void visit(RefPtr &); + virtual void visit(Block &); + virtual void visit(FunctionCall &); + virtual void visit(FunctionDeclaration &); + virtual void visit(Iteration &); +}; +/** Inlines variables into expressions. Variables with trivial values (those +consisting of a single literal or variable reference) are always inlined. +Variables which are only referenced once are also inlined. */ +class ExpressionInliner: private TraversingVisitor +{ +private: + struct ExpressionInfo + { + Expression *expression; + Block *assign_scope; + RefPtr *inline_point; + bool trivial; + bool available; + + ExpressionInfo(): expression(0), assign_scope(0), inline_point(0), trivial(false), available(true) { } + }; + + std::map expressions; + ExpressionInfo *r_ref_info; + bool r_any_inlined; + bool r_trivial; + bool mutating; + bool iteration_init; + Block *iteration_body; + const Operator *r_oper; + +public: + ExpressionInliner(); + + bool apply(Stage &); + +private: + 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(Return &); - using TraversingVisitor::visit; + virtual void visit(Iteration &); }; +/** Removes conditional statements and loops where the condition can be +determined as constant at compile time. */ class ConstantConditionEliminator: private TraversingVisitor { private: - unsigned scope_level; - Block *current_block; - bool record_only; - ExpressionEvaluator::ValueMap variable_values; + enum ConstantStatus + { + CONSTANT_FALSE, + CONSTANT_TRUE, + NOT_CONSTANT + }; + NodeList::iterator insert_point; std::set nodes_to_remove; + RefPtr r_ternary_result; public: - ConstantConditionEliminator(); - void apply(Stage &); private: + ConstantStatus check_constant_condition(const Expression &); + virtual void visit(Block &); - virtual void visit(UnaryExpression &); - virtual void visit(Assignment &); - virtual void visit(VariableDeclaration &); + virtual void visit(RefPtr &); + virtual void visit(TernaryExpression &); virtual void visit(Conditional &); virtual void visit(Iteration &); - using TraversingVisitor::visit; }; +/** Removes types which are not used anywhere. */ +class UnusedTypeRemover: private TraversingVisitor +{ +private: + std::set unused_nodes; + +public: + bool apply(Stage &); + +private: + virtual void visit(RefPtr &); + virtual void visit(BasicTypeDeclaration &); + virtual void visit(ImageTypeDeclaration &); + virtual void visit(StructDeclaration &); + virtual void visit(VariableDeclaration &); + virtual void visit(InterfaceBlock &); + virtual void visit(FunctionDeclaration &); +}; + +/** Removes variable declarations with no references to them. Assignment +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 { - bool local; - std::vector assignments; - bool conditionally_assigned; + InterfaceBlock *interface_block; + std::vector assignments; + bool initialized; + bool output; bool referenced; - VariableInfo(); + VariableInfo(): interface_block(0), initialized(false), output(false), referenced(false) { } }; - typedef std::map BlockVariableMap; + typedef std::map BlockVariableMap; - std::set unused_nodes; - std::map aggregates; - Node *aggregate; - std::vector variables; - Assignment *assignment; + Stage *stage; + BlockVariableMap variables; + std::list assignments; + InterfaceBlock *interface_block; + Assignment *r_assignment; bool assignment_target; - bool assign_to_subscript; - bool global_scope; + bool r_side_effects; + bool composite_reference; + Assignment::Target r_reference; + std::set unused_nodes; public: UnusedVariableRemover(); @@ -108,23 +290,30 @@ public: bool apply(Stage &); private: + void referenced(const Assignment::Target &, Node &); virtual void visit(VariableReference &); + virtual void visit(InterfaceBlockReference &); + void visit_composite(Expression &); virtual void visit(MemberAccess &); + virtual void visit(Swizzle &); + virtual void visit(UnaryExpression &); virtual void visit(BinaryExpression &); virtual void visit(Assignment &); - void record_assignment(VariableDeclaration &, Node &, bool); - void clear_assignments(VariableInfo &, bool); + virtual void visit(TernaryExpression &); + virtual void visit(FunctionCall &); + void record_assignment(const Assignment::Target &, Node &); virtual void visit(ExpressionStatement &); - virtual void visit(StructDeclaration &); + // 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 &); - using TraversingVisitor::visit; }; +/** Removes function declarations with no references to them. */ class UnusedFunctionRemover: private TraversingVisitor { private: @@ -137,7 +326,6 @@ public: private: virtual void visit(FunctionCall &); virtual void visit(FunctionDeclaration &); - using TraversingVisitor::visit; }; } // namespace SL