X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Foptimize.h;h=6250130fb30a39bfd9b18c82cdc9acf654c347ad;hb=c4aeeced7b397d46772577775bd3a0d6c4706cba;hp=698aa0b2617efd3ef1f6a98348aa754b19f04862;hpb=696a97bd7411d69953c1a9e4b5f3dfb4c1d848f1;p=libs%2Fgl.git

diff --git a/source/glsl/optimize.h b/source/glsl/optimize.h
index 698aa0b2..6250130f 100644
--- a/source/glsl/optimize.h
+++ b/source/glsl/optimize.h
@@ -3,137 +3,361 @@
 
 #include <map>
 #include <set>
-#include "evaluate.h"
 #include "visitor.h"
 
 namespace Msp {
 namespace GL {
 namespace SL {
 
-class InlineableFunctionLocator: public StageVisitor
+/** Assigns values to specialization constants, turning them into normal
+constants. */
+class ConstantSpecializer: private TraversingVisitor
 {
+private:
+	const std::map<std::string, int> *values;
+
 public:
-	typedef std::set<FunctionDeclaration *> ResultType;
+	ConstantSpecializer();
+
+	void apply(Stage &, const std::map<std::string, int> &);
+
+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 either builtins or only called once. */
+class InlineableFunctionLocator: private TraversingVisitor
+{
 private:
 	std::map<FunctionDeclaration *, unsigned> refcounts;
 	std::set<FunctionDeclaration *> inlineable;
-	FunctionDeclaration *in_function;
+	FunctionDeclaration *current_function;
+	unsigned return_count;
 
 public:
 	InlineableFunctionLocator();
 
-	const ResultType &get_result() const { return inlineable; }
-	using StageVisitor::visit;
+	std::set<FunctionDeclaration *> apply(Stage &s) { s.content.visit(*this); return inlineable; }
+
+private:
 	virtual void visit(FunctionCall &);
 	virtual void visit(FunctionDeclaration &);
+	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<Statement> r_inlined_statement;
+	std::set<Node *> dependencies;
+	std::set<std::string> referenced_names;
+	std::string r_result_name;
+
+public:
+	InlineContentInjector();
+
+	std::string apply(Stage &, FunctionDeclaration &, Block &, const NodeList<Statement>::iterator &, FunctionCall &);
+
+private:
+	virtual void visit(VariableReference &);
+	virtual void visit(InterfaceBlockReference &);
+	virtual void visit(FunctionCall &);
+	virtual void visit(VariableDeclaration &);
+	virtual void visit(Return &);
 };
 
-class FunctionInliner: public StageVisitor
+/** 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<FunctionDeclaration *> inlineable;
-	unsigned extract_result;
-	RefPtr<Expression> inline_result;
+	FunctionDeclaration *current_function;
+	NodeList<Statement>::iterator insert_point;
+	RefPtr<Expression> r_inline_result;
+	bool r_any_inlined;
+	bool r_inlined_here;
 
 public:
 	FunctionInliner();
-	FunctionInliner(const std::set<FunctionDeclaration *> &);
+
+	bool apply(Stage &);
 
 private:
-	void visit_and_inline(RefPtr<Expression> &);
-public:
-	using StageVisitor::visit;
+	virtual void visit(RefPtr<Expression> &);
 	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<Expression> *reference;
+		Block *ref_scope;
+		bool blocked;
+
+		ExpressionUse(): reference(0), ref_scope(0), blocked(false) { }
+	};
+
+	struct ExpressionInfo
+	{
+		Assignment::Target target;
+		RefPtr<Expression> expression;
+		Block *assign_scope;
+		std::vector<ExpressionUse> uses;
+		bool trivial;
+
+		ExpressionInfo(): expression(0), assign_scope(0), trivial(false) { }
+	};
+
+	std::list<ExpressionInfo> expressions;
+	std::map<Assignment::Target, ExpressionInfo *> assignments;
+	ExpressionInfo *r_ref_info;
+	bool r_trivial;
+	bool access_read;
+	bool access_write;
+	bool iteration_init;
+	Block *iteration_body;
+	const Operator *r_oper;
+
+public:
+	ExpressionInliner();
+
+	bool apply(Stage &);
+
+private:
+	virtual void visit(RefPtr<Expression> &);
+	virtual void visit(VariableReference &);
+	virtual void visit(MemberAccess &);
+	virtual void visit(Swizzle &);
 	virtual void visit(UnaryExpression &);
 	virtual void visit(BinaryExpression &);
-	virtual void visit(MemberAccess &);
+	virtual void visit(Assignment &);
+	virtual void visit(TernaryExpression &);
 	virtual void visit(FunctionCall &);
 	virtual void visit(VariableDeclaration &);
-	virtual void visit(Return &);
+	virtual void visit(Iteration &);
 };
 
-class ConstantConditionEliminator: public BlockModifier
+/** Replaces expressions consisting entirely of literals with the results of
+evaluating the expression.*/
+class ConstantFolder: private TraversingVisitor
 {
 private:
-	unsigned scope_level;
-	bool record_only;
-	ExpressionEvaluator::ValueMap variable_values;
+	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:
-	ConstantConditionEliminator();
+	bool apply(Stage &s) { s.content.visit(*this); return r_any_folded; }
 
-	using StageVisitor::visit;
-	virtual void visit(Block &);
+private:
+	template<typename T>
+	static T evaluate_logical(char, T, T);
+	template<typename T>
+	static bool evaluate_relation(const char *, T, T);
+	template<typename T>
+	static T evaluate_arithmetic(char, T, T);
+	template<typename T>
+	static T evaluate_int_special_op(char, T, T);
+	template<typename T>
+	void convert_to_result(const Variant &);
+	void set_result(const Variant &, bool = false);
+
+	virtual void visit(RefPtr<Expression> &);
+	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(Iteration &);
+};
+
+/** Removes conditional statements and loops where the condition can be
+determined as constant at compile time. */
+class ConstantConditionEliminator: private TraversingVisitor
+{
+private:
+	enum ConstantStatus
+	{
+		CONSTANT_FALSE,
+		CONSTANT_TRUE,
+		NOT_CONSTANT
+	};
+
+	NodeList<Statement>::iterator insert_point;
+	std::set<Node *> nodes_to_remove;
+	RefPtr<Expression> r_ternary_result;
+
+public:
+	void apply(Stage &);
+
+private:
+	ConstantStatus check_constant_condition(const Expression &);
+
+	virtual void visit(Block &);
+	virtual void visit(RefPtr<Expression> &);
+	virtual void visit(TernaryExpression &);
 	virtual void visit(Conditional &);
 	virtual void visit(Iteration &);
 };
 
-class UnusedVariableLocator: public StageVisitor
+class UnreachableCodeRemover: private TraversingVisitor
 {
+private:
+	bool reachable;
+	std::set<Node *> unreachable_nodes;
+
 public:
-	typedef std::set<Node *> ResultType;
+	UnreachableCodeRemover();
+
+	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<Node *> unused_nodes;
+
+public:
+	bool apply(Stage &);
+
+private:
+	virtual void visit(RefPtr<Expression> &);
+	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<Node *> used_by;
+		unsigned in_loop;
+
+		AssignmentInfo(): node(0) { }
+	};
+
 	struct VariableInfo
 	{
-		bool local;
-		std::vector<Node *> assignments;
-		bool conditionally_assigned;
+		InterfaceBlock *interface_block;
+		std::vector<AssignmentInfo *> assignments;
+		bool initialized;
+		bool output;
 		bool referenced;
 
-		VariableInfo();
+		VariableInfo(): interface_block(0), initialized(false), output(false), referenced(false) { }
 	};
 
-	typedef std::map<VariableDeclaration *, VariableInfo> BlockVariableMap;
+	typedef std::map<Statement *, VariableInfo> BlockVariableMap;
 
-	std::set<Node *> unused_nodes;
-	std::map<VariableDeclaration *, Node *> aggregates;
-	Node *aggregate;
-	std::vector<BlockVariableMap> variables;
-	Assignment *assignment;
+	Stage *stage;
+	BlockVariableMap variables;
+	std::list<AssignmentInfo> assignments;
+	InterfaceBlock *interface_block;
+	Assignment *r_assignment;
 	bool assignment_target;
-	bool assign_to_subscript;
-	bool global_scope;
+	bool r_side_effects;
+	bool in_struct;
+	bool composite_reference;
+	unsigned in_loop;
+	std::vector<Node *> loop_ext_refs;
+	Assignment::Target r_reference;
+	std::set<Node *> unused_nodes;
 
 public:
-	UnusedVariableLocator();
+	UnusedVariableRemover();
+
+	bool apply(Stage &);
 
-	virtual void apply(Stage &);
-	const ResultType &get_result() const { return unused_nodes; }
 private:
-	using StageVisitor::visit;
+	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 &);
 };
 
-class UnusedFunctionLocator: public StageVisitor
+/** Removes function declarations with no references to them. */
+class UnusedFunctionRemover: private TraversingVisitor
 {
-public:
-	typedef std::set<Node *> ResultType;
-
 private:
 	std::set<Node *> unused_nodes;
 	std::set<FunctionDeclaration *> used_definitions;
 
 public:
-	const ResultType &get_result() const { return unused_nodes; }
-	using StageVisitor::visit;
+	bool apply(Stage &s);
+
+private:
 	virtual void visit(FunctionCall &);
 	virtual void visit(FunctionDeclaration &);
 };