X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Foptimize.h;h=551e2d56976155a0d5b8b1e5c56e848fe95281e1;hp=cfebf0f782c46aee0c2bbc0730baf555b0081b8a;hb=041ba4b1acd55337239c5ce24cc310118c621206;hpb=0ca367ce305ae6f2025739b3b199a7f75d4132db diff --git a/source/glsl/optimize.h b/source/glsl/optimize.h index cfebf0f7..551e2d56 100644 --- a/source/glsl/optimize.h +++ b/source/glsl/optimize.h @@ -10,36 +10,77 @@ namespace Msp { 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. */ 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; } + const 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: + FunctionDeclaration *source_func; + Block *target_block; + std::map variable_map; + bool remap_names; + bool deps_only; + RefPtr r_inlined_statement; + std::set dependencies; + std::string r_result_name; + +public: + InlineContentInjector(); + + const std::string &apply(Stage &, FunctionDeclaration &, Block &, const NodeList::iterator &, FunctionDeclaration &); + +private: + std::string create_unused_name(const std::string &, bool); + + 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; public: FunctionInliner(); - FunctionInliner(const std::set &); - void apply(Stage &s) { visit(s.content); } + bool apply(Stage &); private: void visit_and_inline(RefPtr &); @@ -47,36 +88,109 @@ private: 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(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 &); - using TraversingVisitor::visit; }; -class ConstantConditionEliminator: private BlockModifier +/** 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: - unsigned scope_level; - bool record_only; - ExpressionEvaluator::ValueMap variable_values; + struct ExpressionInfo + { + Expression *expression; + Block *assign_scope; + RefPtr *inline_point; + const Operator *inner_oper; + const Operator *outer_oper; + bool inline_on_rhs; + bool trivial; + bool available; + + ExpressionInfo(); + }; + + 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: - ConstantConditionEliminator(); + ExpressionInliner(); - void apply(Stage &s) { visit(s.content); } + bool apply(Stage &); private: + void visit_and_record(RefPtr &, const Operator *, bool); + void inline_expression(Expression &, RefPtr &, const Operator *, const Operator *, bool); virtual void visit(Block &); + virtual void visit(VariableReference &); + virtual void visit(MemberAccess &); virtual void visit(UnaryExpression &); + virtual void visit(BinaryExpression &); virtual void visit(Assignment &); + virtual void visit(FunctionCall &); virtual void visit(VariableDeclaration &); virtual void visit(Conditional &); virtual void visit(Iteration &); - using BlockModifier::visit; + virtual void visit(Return &); }; -class UnusedVariableLocator: private TraversingVisitor +/** Removes conditional statements and loops where the condition can be +determined as constant at compile time. */ +class ConstantConditionEliminator: private TraversingVisitor +{ +private: + NodeList::iterator insert_point; + std::set nodes_to_remove; + +public: + void apply(Stage &); + +private: + virtual void visit(Block &); + virtual void visit(Conditional &); + virtual void visit(Iteration &); +}; + +/** Removes types which are not used anywhere. */ +class UnusedTypeRemover: private TraversingVisitor +{ +private: + std::set unused_nodes; + +public: + bool apply(Stage &); + +private: + virtual void visit(Literal &); + virtual void visit(UnaryExpression &); + virtual void visit(BinaryExpression &); + virtual void visit(FunctionCall &); + 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 VariableInfo @@ -95,23 +209,26 @@ private: std::map aggregates; Node *aggregate; std::vector variables; - Assignment *assignment; + Assignment *r_assignment; bool assignment_target; - bool assign_to_subscript; - bool global_scope; + bool r_assign_to_subfield; + bool r_side_effects; public: - UnusedVariableLocator(); + UnusedVariableRemover(); - const std::set &apply(Stage &); + bool apply(Stage &); private: virtual void visit(VariableReference &); + virtual void visit(InterfaceBlockReference &); virtual void visit(MemberAccess &); + 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(FunctionCall &); virtual void visit(ExpressionStatement &); virtual void visit(StructDeclaration &); virtual void visit(VariableDeclaration &); @@ -120,22 +237,21 @@ private: void merge_down_variables(); virtual void visit(Conditional &); virtual void visit(Iteration &); - using TraversingVisitor::visit; }; -class UnusedFunctionLocator: private TraversingVisitor +/** Removes function declarations with no references to them. */ +class UnusedFunctionRemover: private TraversingVisitor { private: std::set unused_nodes; std::set used_definitions; public: - const std::set &apply(Stage &s) { visit(s.content); return unused_nodes; } + bool apply(Stage &s); private: virtual void visit(FunctionCall &); virtual void visit(FunctionDeclaration &); - using TraversingVisitor::visit; }; } // namespace SL