X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Foptimize.h;h=82fc78cc546e562b5c77ea096112ae2ec59fab38;hp=390dd64ea98f668639e6733447f29ac5895368f2;hb=3fe1aab63922eec99d8bf6fd4fd60bec10df173c;hpb=d5c7c7f0b15c407b3da2184936e6deed18554c6a diff --git a/source/glsl/optimize.h b/source/glsl/optimize.h index 390dd64e..82fc78cc 100644 --- a/source/glsl/optimize.h +++ b/source/glsl/optimize.h @@ -3,28 +3,39 @@ #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 = 0; + +public: + 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 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 either builtins or only called once. */ class InlineableFunctionLocator: private TraversingVisitor { private: std::map refcounts; std::set inlineable; - FunctionDeclaration *current_function; - unsigned return_count; + FunctionDeclaration *current_function = 0; + unsigned return_count = 0; public: - InlineableFunctionLocator(); - - const std::set &apply(Stage &s) { s.content.visit(*this); return inlineable; } + std::set apply(Stage &s) { s.content.visit(*this); return inlineable; } private: virtual void visit(FunctionCall &); @@ -40,23 +51,25 @@ 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 inlined_statement; + enum Pass + { + REFERENCED, + INLINE, + RENAME + }; + + FunctionDeclaration *source_func = 0; + Block staging_block; + Pass pass = REFERENCED; + RefPtr r_inlined_statement; std::set dependencies; - std::string result_name; + std::set referenced_names; + std::string r_result_name; public: - InlineContentInjector(); - - const std::string &apply(Stage &, FunctionDeclaration &, Block &, const NodeList::iterator &, FunctionDeclaration &); + 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 &); @@ -70,54 +83,236 @@ are inlined. */ class FunctionInliner: private TraversingVisitor { private: - Stage *stage; + Stage *stage = 0; std::set inlineable; - FunctionDeclaration *current_function; + FunctionDeclaration *current_function = 0; NodeList::iterator insert_point; - RefPtr inline_result; - bool any_inlined; + RefPtr r_inline_result; + bool r_any_inlined = false; + bool r_inlined_here = false; public: - FunctionInliner(); + bool apply(Stage &); + +private: + 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 ExpressionUse + { + RefPtr *reference = 0; + Block *ref_scope = 0; + bool blocked = false; + }; + + struct ExpressionInfo + { + Assignment::Target target; + RefPtr expression; + Block *assign_scope = 0; + std::vector uses; + bool trivial = false; + bool blocked = false; + }; + std::list expressions; + std::map assignments; + ExpressionInfo *r_ref_info = 0; + bool r_trivial = false; + bool access_read = true; + bool access_write = false; + bool iteration_init = false; + Block *iteration_body = 0; + const Operator *r_oper = 0; + +public: bool apply(Stage &); private: - void visit_and_inline(RefPtr &); + 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 &); +}; +/** +Breaks aggregates up into separate variables if only the individual fields are +accessed and not the aggregate as a whole. +*/ +class AggregateDismantler: public TraversingVisitor +{ +private: + struct AggregateMember + { + const VariableDeclaration *declaration = 0; + unsigned index = 0; + RefPtr initializer; + std::vector *> references; + }; + + struct Aggregate + { + VariableDeclaration *declaration = 0; + Block *decl_scope = 0; + NodeList::iterator insert_point; + std::vector members; + bool referenced = false; + bool members_referenced = false; + }; + + NodeList::iterator insert_point; + std::map aggregates; + bool composite_reference = false; + Assignment::Target r_reference; + Aggregate *r_aggregate_ref = 0; + +public: + bool apply(Stage &); + +private: virtual void visit(Block &); - virtual void visit(UnaryExpression &); + virtual void visit(RefPtr &); + virtual void visit(VariableReference &); + void visit_composite(RefPtr &); + virtual void visit(MemberAccess &); virtual void visit(BinaryExpression &); + virtual void visit(StructDeclaration &) { } + virtual void visit(VariableDeclaration &); + virtual void visit(InterfaceBlock &) { } + virtual void visit(FunctionDeclaration &); +}; + +/** Replaces expressions consisting entirely of literals with the results of +evaluating the expression.*/ +class ConstantFolder: private TraversingVisitor +{ +private: + VariableDeclaration *iteration_var = 0; + Variant iter_init_value; + Variant r_constant_value; + bool iteration_init = false; + bool r_constant = false; + bool r_literal = false; + bool r_uses_iter_var = false; + bool r_any_folded = false; + +public: + bool apply(Stage &s) { s.content.visit(*this); return r_any_folded; } + +private: + 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); + template + static T evaluate_int_special_op(char, T, T); + template + void convert_to_result(const Variant &); + 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(ExpressionStatement &); virtual void visit(VariableDeclaration &); - virtual void visit(FunctionDeclaration &); - virtual void visit(Return &); + virtual void visit(Iteration &); }; /** Removes conditional statements and loops where the condition can be -determined as constant at compile time. */ +determined as constant at compile time. Also removes such statements where +the body is empty and the condition has no side effects. */ class ConstantConditionEliminator: private TraversingVisitor { private: - 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; + bool r_external_side_effects = false; public: - ConstantConditionEliminator(); - void apply(Stage &); private: + ConstantStatus check_constant_condition(const Expression &); + virtual void visit(Block &); + virtual void visit(RefPtr &); virtual void visit(UnaryExpression &); virtual void visit(Assignment &); - virtual void visit(VariableDeclaration &); + virtual void visit(TernaryExpression &); + virtual void visit(FunctionCall &); + virtual void visit(Conditional &); + virtual void visit(Iteration &); +}; + +/** Removes code which is never executed due to flow control statements. */ +class UnreachableCodeRemover: private TraversingVisitor +{ +private: + bool reachable = true; + std::set unreachable_nodes; + +public: + virtual bool apply(Stage &); + +private: + virtual void visit(Block &); + virtual void visit(FunctionDeclaration &); virtual void visit(Conditional &); virtual void visit(Iteration &); + virtual void visit(Return &) { reachable = false; } + virtual void visit(Jump &) { reachable = false; } +}; + +/** 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 @@ -125,48 +320,59 @@ statements where the result is not used are also removed. */ class UnusedVariableRemover: private TraversingVisitor { private: - struct VariableInfo + struct AssignmentInfo { - bool local; - std::vector assignments; - bool conditionally_assigned; - bool referenced; - - VariableInfo(); + Node *node = 0; + Assignment::Target target; + std::vector used_by; + unsigned in_loop = 0; }; - typedef std::map BlockVariableMap; + struct VariableInfo + { + std::vector assignments; + bool initialized = false; + bool output = false; + bool referenced = false; + }; + typedef std::map BlockVariableMap; + + Stage *stage = 0; + BlockVariableMap variables; + std::list assignments; + Assignment *r_assignment = 0; + bool assignment_target = false; + bool r_side_effects = false; + bool in_struct = false; + bool composite_reference = false; + unsigned in_loop = 0; + std::vector loop_ext_refs; + Assignment::Target r_reference; std::set unused_nodes; - std::map aggregates; - Node *aggregate; - std::vector variables; - Assignment *assignment; - bool assignment_target; - bool assign_to_subscript; - bool side_effects; public: - UnusedVariableRemover(); - 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 &); 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 &); };