WebSVN – Kolibri OS – Blame – /programs/develop/libraries/Mesa/src/glsl/lower_if_to_cond_assign.cpp

Rev	Author	Line No.	Line
1901	serge	1	/*
		2	* Copyright © 2010 Intel Corporation
		3	*
		4	* Permission is hereby granted, free of charge, to any person obtaining a
		5	* copy of this software and associated documentation files (the "Software"),
		6	* to deal in the Software without restriction, including without limitation
		7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		8	* and/or sell copies of the Software, and to permit persons to whom the
		9	* Software is furnished to do so, subject to the following conditions:
		10	*
		11	* The above copyright notice and this permission notice (including the next
		12	* paragraph) shall be included in all copies or substantial portions of the
		13	* Software.
		14	*
		15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		18	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
		20	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
		21	* DEALINGS IN THE SOFTWARE.
		22	*/
		23
		24	/**
		25	* \file lower_if_to_cond_assign.cpp
		26	*
		27	* This attempts to flatten if-statements to conditional assignments for
		28	* GPUs with limited or no flow control support.
		29	*
		30	* It can't handle other control flow being inside of its block, such
		31	* as calls or loops. Hopefully loop unrolling and inlining will take
		32	* care of those.
		33	*
		34	* Drivers for GPUs with no control flow support should simply call
		35	*
		36	* lower_if_to_cond_assign(instructions)
		37	*
		38	* to attempt to flatten all if-statements.
		39	*
		40	* Some GPUs (such as i965 prior to gen6) do support control flow, but have a
		41	* maximum nesting depth N. Drivers for such hardware can call
		42	*
		43	* lower_if_to_cond_assign(instructions, N)
		44	*
		45	* to attempt to flatten any if-statements appearing at depth > N.
		46	*/
		47
		48	#include "glsl_types.h"
		49	#include "ir.h"
		50
		51	class ir_if_to_cond_assign_visitor : public ir_hierarchical_visitor {
		52	public:
		53	ir_if_to_cond_assign_visitor(unsigned max_depth)
		54	{
		55	this->progress = false;
		56	this->max_depth = max_depth;
		57	this->depth = 0;
		58	}
		59
		60	ir_visitor_status visit_enter(ir_if *);
		61	ir_visitor_status visit_leave(ir_if *);
		62
		63	bool progress;
		64	unsigned max_depth;
		65	unsigned depth;
		66	};
		67
		68	bool
		69	lower_if_to_cond_assign(exec_list *instructions, unsigned max_depth)
		70	{
		71	ir_if_to_cond_assign_visitor v(max_depth);
		72
		73	visit_list_elements(&v, instructions);
		74
		75	return v.progress;
		76	}
		77
		78	void
		79	check_control_flow(ir_instruction ir, void data)
		80	{
		81	bool found_control_flow = (bool )data;
		82	switch (ir->ir_type) {
		83	case ir_type_call:
		84	case ir_type_discard:
		85	case ir_type_loop:
		86	case ir_type_loop_jump:
		87	case ir_type_return:
		88	*found_control_flow = true;
		89	break;
		90	default:
		91	break;
		92	}
		93	}
		94
		95	void
		96	move_block_to_cond_assign(void *mem_ctx,
		97	ir_if if_ir, ir_variable cond_var, bool then)
		98	{
		99	exec_list *instructions;
		100
		101	if (then) {
		102	instructions = &if_ir->then_instructions;
		103	} else {
		104	instructions = &if_ir->else_instructions;
		105	}
		106
		107	foreach_iter(exec_list_iterator, iter, *instructions) {
		108	ir_instruction ir = (ir_instruction )iter.get();
		109
		110	if (ir->ir_type == ir_type_assignment) {
		111	ir_assignment assign = (ir_assignment )ir;
		112	ir_rvalue *cond_expr;
		113	ir_dereference *deref = new(mem_ctx) ir_dereference_variable(cond_var);
		114
		115	if (then) {
		116	cond_expr = deref;
		117	} else {
		118	cond_expr = new(mem_ctx) ir_expression(ir_unop_logic_not,
		119	glsl_type::bool_type,
		120	deref,
		121	NULL);
		122	}
		123
		124	if (!assign->condition) {
		125	assign->condition = cond_expr;
		126	} else {
		127	assign->condition = new(mem_ctx) ir_expression(ir_binop_logic_and,
		128	glsl_type::bool_type,
		129	cond_expr,
		130	assign->condition);
		131	}
		132	}
		133
		134	/* Now, move from the if block to the block surrounding it. */
		135	ir->remove();
		136	if_ir->insert_before(ir);
		137	}
		138	}
		139
		140	ir_visitor_status
		141	ir_if_to_cond_assign_visitor::visit_enter(ir_if *ir)
		142	{
		143	(void) ir;
		144	this->depth++;
		145	return visit_continue;
		146	}
		147
		148	ir_visitor_status
		149	ir_if_to_cond_assign_visitor::visit_leave(ir_if *ir)
		150	{
		151	/* Only flatten when beyond the GPU's maximum supported nesting depth. */
		152	if (this->depth <= this->max_depth)
		153	return visit_continue;
		154
		155	this->depth--;
		156
		157	bool found_control_flow = false;
		158	ir_variable *cond_var;
		159	ir_assignment *assign;
		160	ir_dereference_variable *deref;
		161
		162	/* Check that both blocks don't contain anything we can't support. */
		163	foreach_iter(exec_list_iterator, then_iter, ir->then_instructions) {
		164	ir_instruction then_ir = (ir_instruction )then_iter.get();
		165	visit_tree(then_ir, check_control_flow, &found_control_flow);
		166	}
		167	foreach_iter(exec_list_iterator, else_iter, ir->else_instructions) {
		168	ir_instruction else_ir = (ir_instruction )else_iter.get();
		169	visit_tree(else_ir, check_control_flow, &found_control_flow);
		170	}
		171	if (found_control_flow)
		172	return visit_continue;
		173
		174	void *mem_ctx = ralloc_parent(ir);
		175
		176	/* Store the condition to a variable so the assignment conditions are
		177	* simpler.
		178	*/
		179	cond_var = new(mem_ctx) ir_variable(glsl_type::bool_type,
		180	"if_to_cond_assign_condition",
		181	ir_var_temporary);
		182	ir->insert_before(cond_var);
		183
		184	deref = new(mem_ctx) ir_dereference_variable(cond_var);
		185	assign = new(mem_ctx) ir_assignment(deref,
		186	ir->condition, NULL);
		187	ir->insert_before(assign);
		188
		189	/* Now, move all of the instructions out of the if blocks, putting
		190	* conditions on assignments.
		191	*/
		192	move_block_to_cond_assign(mem_ctx, ir, cond_var, true);
		193	move_block_to_cond_assign(mem_ctx, ir, cond_var, false);
		194
		195	ir->remove();
		196
		197	this->progress = true;
		198
		199	return visit_continue;
		200	}

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/Mesa/src/glsl/lower_if_to_cond_assign.cpp – Rev 2783