WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/mesa-10.6.0/src/glsl/ast_function.cpp

Rev	Author	Line No.	Line
5564	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	#include "glsl_symbol_table.h"
		25	#include "ast.h"
		26	#include "glsl_types.h"
		27	#include "ir.h"
		28	#include "main/core.h" /* for MIN2 */
		29
		30	static ir_rvalue *
		31	convert_component(ir_rvalue src, const glsl_type desired_type);
		32
		33	bool
		34	apply_implicit_conversion(const glsl_type to, ir_rvalue &from,
		35	struct _mesa_glsl_parse_state *state);
		36
		37	static unsigned
		38	process_parameters(exec_list instructions, exec_list actual_parameters,
		39	exec_list *parameters,
		40	struct _mesa_glsl_parse_state *state)
		41	{
		42	unsigned count = 0;
		43
		44	foreach_list_typed(ast_node, ast, link, parameters) {
		45	ir_rvalue *result = ast->hir(instructions, state);
		46
		47	ir_constant *const constant = result->constant_expression_value();
		48	if (constant != NULL)
		49	result = constant;
		50
		51	actual_parameters->push_tail(result);
		52	count++;
		53	}
		54
		55	return count;
		56	}
		57
		58
		59	/**
		60	* Generate a source prototype for a function signature
		61	*
		62	* \param return_type Return type of the function. May be \c NULL.
		63	* \param name Name of the function.
		64	* \param parameters List of \c ir_instruction nodes representing the
		65	* parameter list for the function. This may be either a
		66	* formal (\c ir_variable) or actual (\c ir_rvalue)
		67	* parameter list. Only the type is used.
		68	*
		69	* \return
		70	* A ralloced string representing the prototype of the function.
		71	*/
		72	char *
		73	prototype_string(const glsl_type return_type, const char name,
		74	exec_list *parameters)
		75	{
		76	char *str = NULL;
		77
		78	if (return_type != NULL)
		79	str = ralloc_asprintf(NULL, "%s ", return_type->name);
		80
		81	ralloc_asprintf_append(&str, "%s(", name);
		82
		83	const char *comma = "";
		84	foreach_in_list(const ir_variable, param, parameters) {
		85	ralloc_asprintf_append(&str, "%s%s", comma, param->type->name);
		86	comma = ", ";
		87	}
		88
		89	ralloc_strcat(&str, ")");
		90	return str;
		91	}
		92
		93	static bool
		94	verify_image_parameter(YYLTYPE loc, _mesa_glsl_parse_state state,
		95	const ir_variable formal, const ir_variable actual)
		96	{
		97	/**
		98	* From the ARB_shader_image_load_store specification:
		99	*
		100	* "The values of image variables qualified with coherent,
		101	* volatile, restrict, readonly, or writeonly may not be passed
		102	* to functions whose formal parameters lack such
		103	* qualifiers. [...] It is legal to have additional qualifiers
		104	* on a formal parameter, but not to have fewer."
		105	*/
		106	if (actual->data.image_coherent && !formal->data.image_coherent) {
		107	_mesa_glsl_error(loc, state,
		108	"function call parameter `%s' drops "
		109	"`coherent' qualifier", formal->name);
		110	return false;
		111	}
		112
		113	if (actual->data.image_volatile && !formal->data.image_volatile) {
		114	_mesa_glsl_error(loc, state,
		115	"function call parameter `%s' drops "
		116	"`volatile' qualifier", formal->name);
		117	return false;
		118	}
		119
		120	if (actual->data.image_restrict && !formal->data.image_restrict) {
		121	_mesa_glsl_error(loc, state,
		122	"function call parameter `%s' drops "
		123	"`restrict' qualifier", formal->name);
		124	return false;
		125	}
		126
		127	if (actual->data.image_read_only && !formal->data.image_read_only) {
		128	_mesa_glsl_error(loc, state,
		129	"function call parameter `%s' drops "
		130	"`readonly' qualifier", formal->name);
		131	return false;
		132	}
		133
		134	if (actual->data.image_write_only && !formal->data.image_write_only) {
		135	_mesa_glsl_error(loc, state,
		136	"function call parameter `%s' drops "
		137	"`writeonly' qualifier", formal->name);
		138	return false;
		139	}
		140
		141	return true;
		142	}
		143
		144	/**
		145	* Verify that 'out' and 'inout' actual parameters are lvalues. Also, verify
		146	* that 'const_in' formal parameters (an extension in our IR) correspond to
		147	* ir_constant actual parameters.
		148	*/
		149	static bool
		150	verify_parameter_modes(_mesa_glsl_parse_state *state,
		151	ir_function_signature *sig,
		152	exec_list &actual_ir_parameters,
		153	exec_list &actual_ast_parameters)
		154	{
		155	exec_node *actual_ir_node = actual_ir_parameters.head;
		156	exec_node *actual_ast_node = actual_ast_parameters.head;
		157
		158	foreach_in_list(const ir_variable, formal, &sig->parameters) {
		159	/* The lists must be the same length. */
		160	assert(!actual_ir_node->is_tail_sentinel());
		161	assert(!actual_ast_node->is_tail_sentinel());
		162
		163	const ir_rvalue const actual = (ir_rvalue ) actual_ir_node;
		164	const ast_expression *const actual_ast =
		165	exec_node_data(ast_expression, actual_ast_node, link);
		166
		167	/* FIXME: 'loc' is incorrect (as of 2011-01-21). It is always
		168	* FIXME: 0:0(0).
		169	*/
		170	YYLTYPE loc = actual_ast->get_location();
		171
		172	/* Verify that 'const_in' parameters are ir_constants. */
		173	if (formal->data.mode == ir_var_const_in &&
		174	actual->ir_type != ir_type_constant) {
		175	_mesa_glsl_error(&loc, state,
		176	"parameter `in %s' must be a constant expression",
		177	formal->name);
		178	return false;
		179	}
		180
		181	/* Verify that shader_in parameters are shader inputs */
		182	if (formal->data.must_be_shader_input) {
		183	ir_variable *var = actual->variable_referenced();
		184	if (var && var->data.mode != ir_var_shader_in) {
		185	_mesa_glsl_error(&loc, state,
		186	"parameter `%s` must be a shader input",
		187	formal->name);
		188	return false;
		189	}
		190
		191	if (actual->ir_type == ir_type_swizzle) {
		192	_mesa_glsl_error(&loc, state,
		193	"parameter `%s` must not be swizzled",
		194	formal->name);
		195	return false;
		196	}
		197	}
		198
		199	/* Verify that 'out' and 'inout' actual parameters are lvalues. */
		200	if (formal->data.mode == ir_var_function_out
		201	\|\| formal->data.mode == ir_var_function_inout) {
		202	const char *mode = NULL;
		203	switch (formal->data.mode) {
		204	case ir_var_function_out: mode = "out"; break;
		205	case ir_var_function_inout: mode = "inout"; break;
		206	default: assert(false); break;
		207	}
		208
		209	/* This AST-based check catches errors like f(i++). The IR-based
		210	* is_lvalue() is insufficient because the actual parameter at the
		211	* IR-level is just a temporary value, which is an l-value.
		212	*/
		213	if (actual_ast->non_lvalue_description != NULL) {
		214	_mesa_glsl_error(&loc, state,
		215	"function parameter '%s %s' references a %s",
		216	mode, formal->name,
		217	actual_ast->non_lvalue_description);
		218	return false;
		219	}
		220
		221	ir_variable *var = actual->variable_referenced();
		222	if (var)
		223	var->data.assigned = true;
		224
		225	if (var && var->data.read_only) {
		226	_mesa_glsl_error(&loc, state,
		227	"function parameter '%s %s' references the "
		228	"read-only variable '%s'",
		229	mode, formal->name,
		230	actual->variable_referenced()->name);
		231	return false;
		232	} else if (!actual->is_lvalue()) {
		233	/* Even though ir_binop_vector_extract is not an l-value, let it
		234	* slop through. generate_call will handle it correctly.
		235	*/
		236	ir_expression const expr = ((ir_rvalue ) actual)->as_expression();
		237	if (expr == NULL
		238	\|\| expr->operation != ir_binop_vector_extract
		239	\|\| !expr->operands[0]->is_lvalue()) {
		240	_mesa_glsl_error(&loc, state,
		241	"function parameter '%s %s' is not an lvalue",
		242	mode, formal->name);
		243	return false;
		244	}
		245	}
		246	}
		247
		248	if (formal->type->is_image() &&
		249	actual->variable_referenced()) {
		250	if (!verify_image_parameter(&loc, state, formal,
		251	actual->variable_referenced()))
		252	return false;
		253	}
		254
		255	actual_ir_node = actual_ir_node->next;
		256	actual_ast_node = actual_ast_node->next;
		257	}
		258	return true;
		259	}
		260
		261	static void
		262	fix_parameter(void mem_ctx, ir_rvalue actual, const glsl_type *formal_type,
		263	exec_list before_instructions, exec_list after_instructions,
		264	bool parameter_is_inout)
		265	{
		266	ir_expression *const expr = actual->as_expression();
		267
		268	/* If the types match exactly and the parameter is not a vector-extract,
		269	* nothing needs to be done to fix the parameter.
		270	*/
		271	if (formal_type == actual->type
		272	&& (expr == NULL \|\| expr->operation != ir_binop_vector_extract))
		273	return;
		274
		275	/* To convert an out parameter, we need to create a temporary variable to
		276	* hold the value before conversion, and then perform the conversion after
		277	* the function call returns.
		278	*
		279	* This has the effect of transforming code like this:
		280	*
		281	* void f(out int x);
		282	* float value;
		283	* f(value);
		284	*
		285	* Into IR that's equivalent to this:
		286	*
		287	* void f(out int x);
		288	* float value;
		289	* int out_parameter_conversion;
		290	* f(out_parameter_conversion);
		291	* value = float(out_parameter_conversion);
		292	*
		293	* If the parameter is an ir_expression of ir_binop_vector_extract,
		294	* additional conversion is needed in the post-call re-write.
		295	*/
		296	ir_variable *tmp =
		297	new(mem_ctx) ir_variable(formal_type, "inout_tmp", ir_var_temporary);
		298
		299	before_instructions->push_tail(tmp);
		300
		301	/* If the parameter is an inout parameter, copy the value of the actual
		302	* parameter to the new temporary. Note that no type conversion is allowed
		303	* here because inout parameters must match types exactly.
		304	*/
		305	if (parameter_is_inout) {
		306	/* Inout parameters should never require conversion, since that would
		307	* require an implicit conversion to exist both to and from the formal
		308	* parameter type, and there are no bidirectional implicit conversions.
		309	*/
		310	assert (actual->type == formal_type);
		311
		312	ir_dereference_variable *const deref_tmp_1 =
		313	new(mem_ctx) ir_dereference_variable(tmp);
		314	ir_assignment *const assignment =
		315	new(mem_ctx) ir_assignment(deref_tmp_1, actual);
		316	before_instructions->push_tail(assignment);
		317	}
		318
		319	/* Replace the parameter in the call with a dereference of the new
		320	* temporary.
		321	*/
		322	ir_dereference_variable *const deref_tmp_2 =
		323	new(mem_ctx) ir_dereference_variable(tmp);
		324	actual->replace_with(deref_tmp_2);
		325
		326
		327	/* Copy the temporary variable to the actual parameter with optional
		328	* type conversion applied.
		329	*/
		330	ir_rvalue *rhs = new(mem_ctx) ir_dereference_variable(tmp);
		331	if (actual->type != formal_type)
		332	rhs = convert_component(rhs, actual->type);
		333
		334	ir_rvalue *lhs = actual;
		335	if (expr != NULL && expr->operation == ir_binop_vector_extract) {
		336	rhs = new(mem_ctx) ir_expression(ir_triop_vector_insert,
		337	expr->operands[0]->type,
		338	expr->operands[0]->clone(mem_ctx, NULL),
		339	rhs,
		340	expr->operands[1]->clone(mem_ctx, NULL));
		341	lhs = expr->operands[0]->clone(mem_ctx, NULL);
		342	}
		343
		344	ir_assignment *const assignment_2 = new(mem_ctx) ir_assignment(lhs, rhs);
		345	after_instructions->push_tail(assignment_2);
		346	}
		347
		348	/**
		349	* Generate a function call.
		350	*
		351	* For non-void functions, this returns a dereference of the temporary variable
		352	* which stores the return value for the call. For void functions, this returns
		353	* NULL.
		354	*/
		355	static ir_rvalue *
		356	generate_call(exec_list instructions, ir_function_signature sig,
		357	exec_list *actual_parameters,
		358	struct _mesa_glsl_parse_state *state)
		359	{
		360	void *ctx = state;
		361	exec_list post_call_conversions;
		362
		363	/* Perform implicit conversion of arguments. For out parameters, we need
		364	* to place them in a temporary variable and do the conversion after the
		365	* call takes place. Since we haven't emitted the call yet, we'll place
		366	* the post-call conversions in a temporary exec_list, and emit them later.
		367	*/
		368	foreach_two_lists(formal_node, &sig->parameters,
		369	actual_node, actual_parameters) {
		370	ir_rvalue actual = (ir_rvalue ) actual_node;
		371	ir_variable formal = (ir_variable ) formal_node;
		372
		373	if (formal->type->is_numeric() \|\| formal->type->is_boolean()) {
		374	switch (formal->data.mode) {
		375	case ir_var_const_in:
		376	case ir_var_function_in: {
		377	ir_rvalue *converted
		378	= convert_component(actual, formal->type);
		379	actual->replace_with(converted);
		380	break;
		381	}
		382	case ir_var_function_out:
		383	case ir_var_function_inout:
		384	fix_parameter(ctx, actual, formal->type,
		385	instructions, &post_call_conversions,
		386	formal->data.mode == ir_var_function_inout);
		387	break;
		388	default:
		389	assert (!"Illegal formal parameter mode");
		390	break;
		391	}
		392	}
		393	}
		394
		395	/* If the function call is a constant expression, don't generate any
		396	* instructions; just generate an ir_constant.
		397	*
		398	* Function calls were first allowed to be constant expressions in GLSL
		399	* 1.20 and GLSL ES 3.00.
		400	*/
		401	if (state->is_version(120, 300)) {
		402	ir_constant *value = sig->constant_expression_value(actual_parameters, NULL);
		403	if (value != NULL) {
		404	return value;
		405	}
		406	}
		407
		408	ir_dereference_variable *deref = NULL;
		409	if (!sig->return_type->is_void()) {
		410	/* Create a new temporary to hold the return value. */
		411	char *const name = ir_variable::temporaries_allocate_names
		412	? ralloc_asprintf(ctx, "%s_retval", sig->function_name())
		413	: NULL;
		414
		415	ir_variable *var;
		416
		417	var = new(ctx) ir_variable(sig->return_type, name, ir_var_temporary);
		418	instructions->push_tail(var);
		419
		420	ralloc_free(name);
		421
		422	deref = new(ctx) ir_dereference_variable(var);
		423	}
		424	ir_call *call = new(ctx) ir_call(sig, deref, actual_parameters);
		425	instructions->push_tail(call);
		426
		427	/* Also emit any necessary out-parameter conversions. */
		428	instructions->append_list(&post_call_conversions);
		429
		430	return deref ? deref->clone(ctx, NULL) : NULL;
		431	}
		432
		433	/**
		434	* Given a function name and parameter list, find the matching signature.
		435	*/
		436	static ir_function_signature *
		437	match_function_by_name(const char *name,
		438	exec_list *actual_parameters,
		439	struct _mesa_glsl_parse_state *state)
		440	{
		441	void *ctx = state;
		442	ir_function *f = state->symbols->get_function(name);
		443	ir_function_signature *local_sig = NULL;
		444	ir_function_signature *sig = NULL;
		445
		446	/* Is the function hidden by a record type constructor? */
		447	if (state->symbols->get_type(name))
		448	goto done; /* no match */
		449
		450	/* Is the function hidden by a variable (impossible in 1.10)? */
		451	if (!state->symbols->separate_function_namespace
		452	&& state->symbols->get_variable(name))
		453	goto done; /* no match */
		454
		455	if (f != NULL) {
		456	/* In desktop GL, the presence of a user-defined signature hides any
		457	* built-in signatures, so we must ignore them. In contrast, in ES2
		458	* user-defined signatures add new overloads, so we must consider them.
		459	*/
		460	bool allow_builtins = state->es_shader \|\| !f->has_user_signature();
		461
		462	/* Look for a match in the local shader. If exact, we're done. */
		463	bool is_exact = false;
		464	sig = local_sig = f->matching_signature(state, actual_parameters,
		465	allow_builtins, &is_exact);
		466	if (is_exact)
		467	goto done;
		468
		469	if (!allow_builtins)
		470	goto done;
		471	}
		472
		473	/* Local shader has no exact candidates; check the built-ins. */
		474	_mesa_glsl_initialize_builtin_functions();
		475	sig = _mesa_glsl_find_builtin_function(state, name, actual_parameters);
		476
		477	done:
		478	if (sig != NULL) {
		479	/* If the match is from a linked built-in shader, import the prototype. */
		480	if (sig != local_sig) {
		481	if (f == NULL) {
		482	f = new(ctx) ir_function(name);
		483	state->symbols->add_global_function(f);
		484	emit_function(state, f);
		485	}
		486	f->add_signature(sig->clone_prototype(f, NULL));
		487	}
		488	}
		489	return sig;
		490	}
		491
		492	static void
		493	print_function_prototypes(_mesa_glsl_parse_state state, YYLTYPE loc,
		494	ir_function *f)
		495	{
		496	if (f == NULL)
		497	return;
		498
		499	foreach_in_list(ir_function_signature, sig, &f->signatures) {
		500	if (sig->is_builtin() && !sig->is_builtin_available(state))
		501	continue;
		502
		503	char *str = prototype_string(sig->return_type, f->name, &sig->parameters);
		504	_mesa_glsl_error(loc, state, " %s", str);
		505	ralloc_free(str);
		506	}
		507	}
		508
		509	/**
		510	* Raise a "no matching function" error, listing all possible overloads the
		511	* compiler considered so developers can figure out what went wrong.
		512	*/
		513	static void
		514	no_matching_function_error(const char *name,
		515	YYLTYPE *loc,
		516	exec_list *actual_parameters,
		517	_mesa_glsl_parse_state *state)
		518	{
		519	gl_shader *sh = _mesa_glsl_get_builtin_function_shader();
		520
		521	if (state->symbols->get_function(name) == NULL
		522	&& (!state->uses_builtin_functions
		523	\|\| sh->symbols->get_function(name) == NULL)) {
		524	_mesa_glsl_error(loc, state, "no function with name '%s'", name);
		525	} else {
		526	char *str = prototype_string(NULL, name, actual_parameters);
		527	_mesa_glsl_error(loc, state,
		528	"no matching function for call to `%s'; candidates are:",
		529	str);
		530	ralloc_free(str);
		531
		532	print_function_prototypes(state, loc, state->symbols->get_function(name));
		533
		534	if (state->uses_builtin_functions) {
		535	print_function_prototypes(state, loc, sh->symbols->get_function(name));
		536	}
		537	}
		538	}
		539
		540	/**
		541	* Perform automatic type conversion of constructor parameters
		542	*
		543	* This implements the rules in the "Conversion and Scalar Constructors"
		544	* section (GLSL 1.10 section 5.4.1), not the "Implicit Conversions" rules.
		545	*/
		546	static ir_rvalue *
		547	convert_component(ir_rvalue src, const glsl_type desired_type)
		548	{
		549	void *ctx = ralloc_parent(src);
		550	const unsigned a = desired_type->base_type;
		551	const unsigned b = src->type->base_type;
		552	ir_expression *result = NULL;
		553
		554	if (src->type->is_error())
		555	return src;
		556
		557	assert(a <= GLSL_TYPE_BOOL);
		558	assert(b <= GLSL_TYPE_BOOL);
		559
		560	if (a == b)
		561	return src;
		562
		563	switch (a) {
		564	case GLSL_TYPE_UINT:
		565	switch (b) {
		566	case GLSL_TYPE_INT:
		567	result = new(ctx) ir_expression(ir_unop_i2u, src);
		568	break;
		569	case GLSL_TYPE_FLOAT:
		570	result = new(ctx) ir_expression(ir_unop_f2u, src);
		571	break;
		572	case GLSL_TYPE_BOOL:
		573	result = new(ctx) ir_expression(ir_unop_i2u,
		574	new(ctx) ir_expression(ir_unop_b2i, src));
		575	break;
		576	case GLSL_TYPE_DOUBLE:
		577	result = new(ctx) ir_expression(ir_unop_d2u, src);
		578	break;
		579	}
		580	break;
		581	case GLSL_TYPE_INT:
		582	switch (b) {
		583	case GLSL_TYPE_UINT:
		584	result = new(ctx) ir_expression(ir_unop_u2i, src);
		585	break;
		586	case GLSL_TYPE_FLOAT:
		587	result = new(ctx) ir_expression(ir_unop_f2i, src);
		588	break;
		589	case GLSL_TYPE_BOOL:
		590	result = new(ctx) ir_expression(ir_unop_b2i, src);
		591	break;
		592	case GLSL_TYPE_DOUBLE:
		593	result = new(ctx) ir_expression(ir_unop_d2i, src);
		594	break;
		595	}
		596	break;
		597	case GLSL_TYPE_FLOAT:
		598	switch (b) {
		599	case GLSL_TYPE_UINT:
		600	result = new(ctx) ir_expression(ir_unop_u2f, desired_type, src, NULL);
		601	break;
		602	case GLSL_TYPE_INT:
		603	result = new(ctx) ir_expression(ir_unop_i2f, desired_type, src, NULL);
		604	break;
		605	case GLSL_TYPE_BOOL:
		606	result = new(ctx) ir_expression(ir_unop_b2f, desired_type, src, NULL);
		607	break;
		608	case GLSL_TYPE_DOUBLE:
		609	result = new(ctx) ir_expression(ir_unop_d2f, desired_type, src, NULL);
		610	break;
		611	}
		612	break;
		613	case GLSL_TYPE_BOOL:
		614	switch (b) {
		615	case GLSL_TYPE_UINT:
		616	result = new(ctx) ir_expression(ir_unop_i2b,
		617	new(ctx) ir_expression(ir_unop_u2i, src));
		618	break;
		619	case GLSL_TYPE_INT:
		620	result = new(ctx) ir_expression(ir_unop_i2b, desired_type, src, NULL);
		621	break;
		622	case GLSL_TYPE_FLOAT:
		623	result = new(ctx) ir_expression(ir_unop_f2b, desired_type, src, NULL);
		624	break;
		625	case GLSL_TYPE_DOUBLE:
		626	result = new(ctx) ir_expression(ir_unop_d2b, desired_type, src, NULL);
		627	break;
		628	}
		629	break;
		630	case GLSL_TYPE_DOUBLE:
		631	switch (b) {
		632	case GLSL_TYPE_INT:
		633	result = new(ctx) ir_expression(ir_unop_i2d, src);
		634	break;
		635	case GLSL_TYPE_UINT:
		636	result = new(ctx) ir_expression(ir_unop_u2d, src);
		637	break;
		638	case GLSL_TYPE_BOOL:
		639	result = new(ctx) ir_expression(ir_unop_f2d,
		640	new(ctx) ir_expression(ir_unop_b2f, src));
		641	break;
		642	case GLSL_TYPE_FLOAT:
		643	result = new(ctx) ir_expression(ir_unop_f2d, desired_type, src, NULL);
		644	break;
		645	}
		646	}
		647
		648	assert(result != NULL);
		649	assert(result->type == desired_type);
		650
		651	/* Try constant folding; it may fold in the conversion we just added. */
		652	ir_constant *const constant = result->constant_expression_value();
		653	return (constant != NULL) ? (ir_rvalue ) constant : (ir_rvalue ) result;
		654	}
		655
		656	/**
		657	* Dereference a specific component from a scalar, vector, or matrix
		658	*/
		659	static ir_rvalue *
		660	dereference_component(ir_rvalue *src, unsigned component)
		661	{
		662	void *ctx = ralloc_parent(src);
		663	assert(component < src->type->components());
		664
		665	/* If the source is a constant, just create a new constant instead of a
		666	* dereference of the existing constant.
		667	*/
		668	ir_constant *constant = src->as_constant();
		669	if (constant)
		670	return new(ctx) ir_constant(constant, component);
		671
		672	if (src->type->is_scalar()) {
		673	return src;
		674	} else if (src->type->is_vector()) {
		675	return new(ctx) ir_swizzle(src, component, 0, 0, 0, 1);
		676	} else {
		677	assert(src->type->is_matrix());
		678
		679	/* Dereference a row of the matrix, then call this function again to get
		680	* a specific element from that row.
		681	*/
		682	const int c = component / src->type->column_type()->vector_elements;
		683	const int r = component % src->type->column_type()->vector_elements;
		684	ir_constant *const col_index = new(ctx) ir_constant(c);
		685	ir_dereference *const col = new(ctx) ir_dereference_array(src, col_index);
		686
		687	col->type = src->type->column_type();
		688
		689	return dereference_component(col, r);
		690	}
		691
		692	assert(!"Should not get here.");
		693	return NULL;
		694	}
		695
		696
		697	static ir_rvalue *
		698	process_vec_mat_constructor(exec_list *instructions,
		699	const glsl_type *constructor_type,
		700	YYLTYPE loc, exec_list parameters,
		701	struct _mesa_glsl_parse_state *state)
		702	{
		703	void *ctx = state;
		704
		705	/* The ARB_shading_language_420pack spec says:
		706	*
		707	* "If an initializer is a list of initializers enclosed in curly braces,
		708	* the variable being declared must be a vector, a matrix, an array, or a
		709	* structure.
		710	*
		711	* int i = { 1 }; // illegal, i is not an aggregate"
		712	*/
		713	if (constructor_type->vector_elements <= 1) {
		714	_mesa_glsl_error(loc, state, "aggregates can only initialize vectors, "
		715	"matrices, arrays, and structs");
		716	return ir_rvalue::error_value(ctx);
		717	}
		718
		719	exec_list actual_parameters;
		720	const unsigned parameter_count =
		721	process_parameters(instructions, &actual_parameters, parameters, state);
		722
		723	if (parameter_count == 0
		724	\|\| (constructor_type->is_vector() &&
		725	constructor_type->vector_elements != parameter_count)
		726	\|\| (constructor_type->is_matrix() &&
		727	constructor_type->matrix_columns != parameter_count)) {
		728	_mesa_glsl_error(loc, state, "%s constructor must have %u parameters",
		729	constructor_type->is_vector() ? "vector" : "matrix",
		730	constructor_type->vector_elements);
		731	return ir_rvalue::error_value(ctx);
		732	}
		733
		734	bool all_parameters_are_constant = true;
		735
		736	/* Type cast each parameter and, if possible, fold constants. */
		737	foreach_in_list_safe(ir_rvalue, ir, &actual_parameters) {
		738	ir_rvalue *result = ir;
		739
		740	/* Apply implicit conversions (not the scalar constructor rules!). See
		741	* the spec quote above. */
		742	if (constructor_type->base_type != result->type->base_type) {
		743	const glsl_type *desired_type =
		744	glsl_type::get_instance(constructor_type->base_type,
		745	ir->type->vector_elements,
		746	ir->type->matrix_columns);
		747	if (result->type->can_implicitly_convert_to(desired_type, state)) {
		748	/* Even though convert_component() implements the constructor
		749	* conversion rules (not the implicit conversion rules), its safe
		750	* to use it here because we already checked that the implicit
		751	* conversion is legal.
		752	*/
		753	result = convert_component(ir, desired_type);
		754	}
		755	}
		756
		757	if (constructor_type->is_matrix()) {
		758	if (result->type != constructor_type->column_type()) {
		759	_mesa_glsl_error(loc, state, "type error in matrix constructor: "
		760	"expected: %s, found %s",
		761	constructor_type->column_type()->name,
		762	result->type->name);
		763	return ir_rvalue::error_value(ctx);
		764	}
		765	} else if (result->type != constructor_type->get_scalar_type()) {
		766	_mesa_glsl_error(loc, state, "type error in vector constructor: "
		767	"expected: %s, found %s",
		768	constructor_type->get_scalar_type()->name,
		769	result->type->name);
		770	return ir_rvalue::error_value(ctx);
		771	}
		772
		773	/* Attempt to convert the parameter to a constant valued expression.
		774	* After doing so, track whether or not all the parameters to the
		775	* constructor are trivially constant valued expressions.
		776	*/
		777	ir_rvalue *const constant = result->constant_expression_value();
		778
		779	if (constant != NULL)
		780	result = constant;
		781	else
		782	all_parameters_are_constant = false;
		783
		784	ir->replace_with(result);
		785	}
		786
		787	if (all_parameters_are_constant)
		788	return new(ctx) ir_constant(constructor_type, &actual_parameters);
		789
		790	ir_variable *var = new(ctx) ir_variable(constructor_type, "vec_mat_ctor",
		791	ir_var_temporary);
		792	instructions->push_tail(var);
		793
		794	int i = 0;
		795
		796	foreach_in_list(ir_rvalue, rhs, &actual_parameters) {
		797	ir_instruction *assignment = NULL;
		798
		799	if (var->type->is_matrix()) {
		800	ir_rvalue *lhs = new(ctx) ir_dereference_array(var,
		801	new(ctx) ir_constant(i));
		802	assignment = new(ctx) ir_assignment(lhs, rhs, NULL);
		803	} else {
		804	/* use writemask rather than index for vector */
		805	assert(var->type->is_vector());
		806	assert(i < 4);
		807	ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
		808	assignment = new(ctx) ir_assignment(lhs, rhs, NULL, (unsigned)(1 << i));
		809	}
		810
		811	instructions->push_tail(assignment);
		812
		813	i++;
		814	}
		815
		816	return new(ctx) ir_dereference_variable(var);
		817	}
		818
		819
		820	static ir_rvalue *
		821	process_array_constructor(exec_list *instructions,
		822	const glsl_type *constructor_type,
		823	YYLTYPE loc, exec_list parameters,
		824	struct _mesa_glsl_parse_state *state)
		825	{
		826	void *ctx = state;
		827	/* Array constructors come in two forms: sized and unsized. Sized array
		828	* constructors look like 'vec4[2](a, b)', where 'a' and 'b' are vec4
		829	* variables. In this case the number of parameters must exactly match the
		830	* specified size of the array.
		831	*
		832	* Unsized array constructors look like 'vec4[](a, b)', where 'a' and 'b'
		833	* are vec4 variables. In this case the size of the array being constructed
		834	* is determined by the number of parameters.
		835	*
		836	* From page 52 (page 58 of the PDF) of the GLSL 1.50 spec:
		837	*
		838	* "There must be exactly the same number of arguments as the size of
		839	* the array being constructed. If no size is present in the
		840	* constructor, then the array is explicitly sized to the number of
		841	* arguments provided. The arguments are assigned in order, starting at
		842	* element 0, to the elements of the constructed array. Each argument
		843	* must be the same type as the element type of the array, or be a type
		844	* that can be converted to the element type of the array according to
		845	* Section 4.1.10 "Implicit Conversions.""
		846	*/
		847	exec_list actual_parameters;
		848	const unsigned parameter_count =
		849	process_parameters(instructions, &actual_parameters, parameters, state);
		850	bool is_unsized_array = constructor_type->is_unsized_array();
		851
		852	if ((parameter_count == 0) \|\|
		853	(!is_unsized_array && (constructor_type->length != parameter_count))) {
		854	const unsigned min_param = is_unsized_array
		855	? 1 : constructor_type->length;
		856
		857	_mesa_glsl_error(loc, state, "array constructor must have %s %u "
		858	"parameter%s",
		859	is_unsized_array ? "at least" : "exactly",
		860	min_param, (min_param <= 1) ? "" : "s");
		861	return ir_rvalue::error_value(ctx);
		862	}
		863
		864	if (is_unsized_array) {
		865	constructor_type =
		866	glsl_type::get_array_instance(constructor_type->element_type(),
		867	parameter_count);
		868	assert(constructor_type != NULL);
		869	assert(constructor_type->length == parameter_count);
		870	}
		871
		872	bool all_parameters_are_constant = true;
		873
		874	/* Type cast each parameter and, if possible, fold constants. */
		875	foreach_in_list_safe(ir_rvalue, ir, &actual_parameters) {
		876	ir_rvalue *result = ir;
		877
		878	const glsl_base_type element_base_type =
		879	constructor_type->element_type()->base_type;
		880
		881	/* Apply implicit conversions (not the scalar constructor rules!). See
		882	* the spec quote above. */
		883	if (element_base_type != result->type->base_type) {
		884	const glsl_type *desired_type =
		885	glsl_type::get_instance(element_base_type,
		886	ir->type->vector_elements,
		887	ir->type->matrix_columns);
		888
		889	if (result->type->can_implicitly_convert_to(desired_type, state)) {
		890	/* Even though convert_component() implements the constructor
		891	* conversion rules (not the implicit conversion rules), its safe
		892	* to use it here because we already checked that the implicit
		893	* conversion is legal.
		894	*/
		895	result = convert_component(ir, desired_type);
		896	}
		897	}
		898
		899	if (result->type != constructor_type->element_type()) {
		900	_mesa_glsl_error(loc, state, "type error in array constructor: "
		901	"expected: %s, found %s",
		902	constructor_type->element_type()->name,
		903	result->type->name);
		904	return ir_rvalue::error_value(ctx);
		905	}
		906
		907	/* Attempt to convert the parameter to a constant valued expression.
		908	* After doing so, track whether or not all the parameters to the
		909	* constructor are trivially constant valued expressions.
		910	*/
		911	ir_rvalue *const constant = result->constant_expression_value();
		912
		913	if (constant != NULL)
		914	result = constant;
		915	else
		916	all_parameters_are_constant = false;
		917
		918	ir->replace_with(result);
		919	}
		920
		921	if (all_parameters_are_constant)
		922	return new(ctx) ir_constant(constructor_type, &actual_parameters);
		923
		924	ir_variable *var = new(ctx) ir_variable(constructor_type, "array_ctor",
		925	ir_var_temporary);
		926	instructions->push_tail(var);
		927
		928	int i = 0;
		929	foreach_in_list(ir_rvalue, rhs, &actual_parameters) {
		930	ir_rvalue *lhs = new(ctx) ir_dereference_array(var,
		931	new(ctx) ir_constant(i));
		932
		933	ir_instruction *assignment = new(ctx) ir_assignment(lhs, rhs, NULL);
		934	instructions->push_tail(assignment);
		935
		936	i++;
		937	}
		938
		939	return new(ctx) ir_dereference_variable(var);
		940	}
		941
		942
		943	/**
		944	* Try to convert a record constructor to a constant expression
		945	*/
		946	static ir_constant *
		947	constant_record_constructor(const glsl_type *constructor_type,
		948	exec_list parameters, void mem_ctx)
		949	{
		950	foreach_in_list(ir_instruction, node, parameters) {
		951	ir_constant *constant = node->as_constant();
		952	if (constant == NULL)
		953	return NULL;
		954	node->replace_with(constant);
		955	}
		956
		957	return new(mem_ctx) ir_constant(constructor_type, parameters);
		958	}
		959
		960
		961	/**
		962	* Determine if a list consists of a single scalar r-value
		963	*/
		964	bool
		965	single_scalar_parameter(exec_list *parameters)
		966	{
		967	const ir_rvalue const p = (ir_rvalue ) parameters->head;
		968	assert(((ir_rvalue *)p)->as_rvalue() != NULL);
		969
		970	return (p->type->is_scalar() && p->next->is_tail_sentinel());
		971	}
		972
		973
		974	/**
		975	* Generate inline code for a vector constructor
		976	*
		977	* The generated constructor code will consist of a temporary variable
		978	* declaration of the same type as the constructor. A sequence of assignments
		979	* from constructor parameters to the temporary will follow.
		980	*
		981	* \return
		982	* An \c ir_dereference_variable of the temprorary generated in the constructor
		983	* body.
		984	*/
		985	ir_rvalue *
		986	emit_inline_vector_constructor(const glsl_type *type,
		987	exec_list *instructions,
		988	exec_list *parameters,
		989	void *ctx)
		990	{
		991	assert(!parameters->is_empty());
		992
		993	ir_variable *var = new(ctx) ir_variable(type, "vec_ctor", ir_var_temporary);
		994	instructions->push_tail(var);
		995
		996	/* There are two kinds of vector constructors.
		997	*
		998	* - Construct a vector from a single scalar by replicating that scalar to
		999	* all components of the vector.
		1000	*
		1001	* - Construct a vector from an arbirary combination of vectors and
		1002	* scalars. The components of the constructor parameters are assigned
		1003	* to the vector in order until the vector is full.
		1004	*/
		1005	const unsigned lhs_components = type->components();
		1006	if (single_scalar_parameter(parameters)) {
		1007	ir_rvalue first_param = (ir_rvalue )parameters->head;
		1008	ir_rvalue *rhs = new(ctx) ir_swizzle(first_param, 0, 0, 0, 0,
		1009	lhs_components);
		1010	ir_dereference_variable *lhs = new(ctx) ir_dereference_variable(var);
		1011	const unsigned mask = (1U << lhs_components) - 1;
		1012
		1013	assert(rhs->type == lhs->type);
		1014
		1015	ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL, mask);
		1016	instructions->push_tail(inst);
		1017	} else {
		1018	unsigned base_component = 0;
		1019	unsigned base_lhs_component = 0;
		1020	ir_constant_data data;
		1021	unsigned constant_mask = 0, constant_components = 0;
		1022
		1023	memset(&data, 0, sizeof(data));
		1024
		1025	foreach_in_list(ir_rvalue, param, parameters) {
		1026	unsigned rhs_components = param->type->components();
		1027
		1028	/* Do not try to assign more components to the vector than it has!
		1029	*/
		1030	if ((rhs_components + base_lhs_component) > lhs_components) {
		1031	rhs_components = lhs_components - base_lhs_component;
		1032	}
		1033
		1034	const ir_constant *const c = param->as_constant();
		1035	if (c != NULL) {
		1036	for (unsigned i = 0; i < rhs_components; i++) {
		1037	switch (c->type->base_type) {
		1038	case GLSL_TYPE_UINT:
		1039	data.u[i + base_component] = c->get_uint_component(i);
		1040	break;
		1041	case GLSL_TYPE_INT:
		1042	data.i[i + base_component] = c->get_int_component(i);
		1043	break;
		1044	case GLSL_TYPE_FLOAT:
		1045	data.f[i + base_component] = c->get_float_component(i);
		1046	break;
		1047	case GLSL_TYPE_DOUBLE:
		1048	data.d[i + base_component] = c->get_double_component(i);
		1049	break;
		1050	case GLSL_TYPE_BOOL:
		1051	data.b[i + base_component] = c->get_bool_component(i);
		1052	break;
		1053	default:
		1054	assert(!"Should not get here.");
		1055	break;
		1056	}
		1057	}
		1058
		1059	/* Mask of fields to be written in the assignment.
		1060	*/
		1061	constant_mask \|= ((1U << rhs_components) - 1) << base_lhs_component;
		1062	constant_components += rhs_components;
		1063
		1064	base_component += rhs_components;
		1065	}
		1066	/* Advance the component index by the number of components
		1067	* that were just assigned.
		1068	*/
		1069	base_lhs_component += rhs_components;
		1070	}
		1071
		1072	if (constant_mask != 0) {
		1073	ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
		1074	const glsl_type *rhs_type = glsl_type::get_instance(var->type->base_type,
		1075	constant_components,
		1076	1);
		1077	ir_rvalue *rhs = new(ctx) ir_constant(rhs_type, &data);
		1078
		1079	ir_instruction *inst =
		1080	new(ctx) ir_assignment(lhs, rhs, NULL, constant_mask);
		1081	instructions->push_tail(inst);
		1082	}
		1083
		1084	base_component = 0;
		1085	foreach_in_list(ir_rvalue, param, parameters) {
		1086	unsigned rhs_components = param->type->components();
		1087
		1088	/* Do not try to assign more components to the vector than it has!
		1089	*/
		1090	if ((rhs_components + base_component) > lhs_components) {
		1091	rhs_components = lhs_components - base_component;
		1092	}
		1093
		1094	const ir_constant *const c = param->as_constant();
		1095	if (c == NULL) {
		1096	/* Mask of fields to be written in the assignment.
		1097	*/
		1098	const unsigned write_mask = ((1U << rhs_components) - 1)
		1099	<< base_component;
		1100
		1101	ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
		1102
		1103	/* Generate a swizzle so that LHS and RHS sizes match.
		1104	*/
		1105	ir_rvalue *rhs =
		1106	new(ctx) ir_swizzle(param, 0, 1, 2, 3, rhs_components);
		1107
		1108	ir_instruction *inst =
		1109	new(ctx) ir_assignment(lhs, rhs, NULL, write_mask);
		1110	instructions->push_tail(inst);
		1111	}
		1112
		1113	/* Advance the component index by the number of components that were
		1114	* just assigned.
		1115	*/
		1116	base_component += rhs_components;
		1117	}
		1118	}
		1119	return new(ctx) ir_dereference_variable(var);
		1120	}
		1121
		1122
		1123	/**
		1124	* Generate assignment of a portion of a vector to a portion of a matrix column
		1125	*
		1126	* \param src_base First component of the source to be used in assignment
		1127	* \param column Column of destination to be assiged
		1128	* \param row_base First component of the destination column to be assigned
		1129	* \param count Number of components to be assigned
		1130	*
		1131	* \note
		1132	* \c src_base + \c count must be less than or equal to the number of components
		1133	* in the source vector.
		1134	*/
		1135	ir_instruction *
		1136	assign_to_matrix_column(ir_variable *var, unsigned column, unsigned row_base,
		1137	ir_rvalue *src, unsigned src_base, unsigned count,
		1138	void *mem_ctx)
		1139	{
		1140	ir_constant *col_idx = new(mem_ctx) ir_constant(column);
		1141	ir_dereference *column_ref = new(mem_ctx) ir_dereference_array(var, col_idx);
		1142
		1143	assert(column_ref->type->components() >= (row_base + count));
		1144	assert(src->type->components() >= (src_base + count));
		1145
		1146	/* Generate a swizzle that extracts the number of components from the source
		1147	* that are to be assigned to the column of the matrix.
		1148	*/
		1149	if (count < src->type->vector_elements) {
		1150	src = new(mem_ctx) ir_swizzle(src,
		1151	src_base + 0, src_base + 1,
		1152	src_base + 2, src_base + 3,
		1153	count);
		1154	}
		1155
		1156	/* Mask of fields to be written in the assignment.
		1157	*/
		1158	const unsigned write_mask = ((1U << count) - 1) << row_base;
		1159
		1160	return new(mem_ctx) ir_assignment(column_ref, src, NULL, write_mask);
		1161	}
		1162
		1163
		1164	/**
		1165	* Generate inline code for a matrix constructor
		1166	*
		1167	* The generated constructor code will consist of a temporary variable
		1168	* declaration of the same type as the constructor. A sequence of assignments
		1169	* from constructor parameters to the temporary will follow.
		1170	*
		1171	* \return
		1172	* An \c ir_dereference_variable of the temprorary generated in the constructor
		1173	* body.
		1174	*/
		1175	ir_rvalue *
		1176	emit_inline_matrix_constructor(const glsl_type *type,
		1177	exec_list *instructions,
		1178	exec_list *parameters,
		1179	void *ctx)
		1180	{
		1181	assert(!parameters->is_empty());
		1182
		1183	ir_variable *var = new(ctx) ir_variable(type, "mat_ctor", ir_var_temporary);
		1184	instructions->push_tail(var);
		1185
		1186	/* There are three kinds of matrix constructors.
		1187	*
		1188	* - Construct a matrix from a single scalar by replicating that scalar to
		1189	* along the diagonal of the matrix and setting all other components to
		1190	* zero.
		1191	*
		1192	* - Construct a matrix from an arbirary combination of vectors and
		1193	* scalars. The components of the constructor parameters are assigned
		1194	* to the matrix in column-major order until the matrix is full.
		1195	*
		1196	* - Construct a matrix from a single matrix. The source matrix is copied
		1197	* to the upper left portion of the constructed matrix, and the remaining
		1198	* elements take values from the identity matrix.
		1199	*/
		1200	ir_rvalue const first_param = (ir_rvalue ) parameters->head;
		1201	if (single_scalar_parameter(parameters)) {
		1202	/* Assign the scalar to the X component of a vec4, and fill the remaining
		1203	* components with zero.
		1204	*/
		1205	glsl_base_type param_base_type = first_param->type->base_type;
		1206	assert(param_base_type == GLSL_TYPE_FLOAT \|\|
		1207	param_base_type == GLSL_TYPE_DOUBLE);
		1208	ir_variable *rhs_var =
		1209	new(ctx) ir_variable(glsl_type::get_instance(param_base_type, 4, 1),
		1210	"mat_ctor_vec",
		1211	ir_var_temporary);
		1212	instructions->push_tail(rhs_var);
		1213
		1214	ir_constant_data zero;
		1215	for (unsigned i = 0; i < 4; i++)
		1216	if (param_base_type == GLSL_TYPE_FLOAT)
		1217	zero.f[i] = 0.0;
		1218	else
		1219	zero.d[i] = 0.0;
		1220
		1221	ir_instruction *inst =
		1222	new(ctx) ir_assignment(new(ctx) ir_dereference_variable(rhs_var),
		1223	new(ctx) ir_constant(rhs_var->type, &zero),
		1224	NULL);
		1225	instructions->push_tail(inst);
		1226
		1227	ir_dereference *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var);
		1228
		1229	inst = new(ctx) ir_assignment(rhs_ref, first_param, NULL, 0x01);
		1230	instructions->push_tail(inst);
		1231
		1232	/* Assign the temporary vector to each column of the destination matrix
		1233	* with a swizzle that puts the X component on the diagonal of the
		1234	* matrix. In some cases this may mean that the X component does not
		1235	* get assigned into the column at all (i.e., when the matrix has more
		1236	* columns than rows).
		1237	*/
		1238	static const unsigned rhs_swiz[4][4] = {
		1239	{ 0, 1, 1, 1 },
		1240	{ 1, 0, 1, 1 },
		1241	{ 1, 1, 0, 1 },
		1242	{ 1, 1, 1, 0 }
		1243	};
		1244
		1245	const unsigned cols_to_init = MIN2(type->matrix_columns,
		1246	type->vector_elements);
		1247	for (unsigned i = 0; i < cols_to_init; i++) {
		1248	ir_constant *const col_idx = new(ctx) ir_constant(i);
		1249	ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var, col_idx);
		1250
		1251	ir_rvalue *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var);
		1252	ir_rvalue *const rhs = new(ctx) ir_swizzle(rhs_ref, rhs_swiz[i],
		1253	type->vector_elements);
		1254
		1255	inst = new(ctx) ir_assignment(col_ref, rhs, NULL);
		1256	instructions->push_tail(inst);
		1257	}
		1258
		1259	for (unsigned i = cols_to_init; i < type->matrix_columns; i++) {
		1260	ir_constant *const col_idx = new(ctx) ir_constant(i);
		1261	ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var, col_idx);
		1262
		1263	ir_rvalue *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var);
		1264	ir_rvalue *const rhs = new(ctx) ir_swizzle(rhs_ref, 1, 1, 1, 1,
		1265	type->vector_elements);
		1266
		1267	inst = new(ctx) ir_assignment(col_ref, rhs, NULL);
		1268	instructions->push_tail(inst);
		1269	}
		1270	} else if (first_param->type->is_matrix()) {
		1271	/* From page 50 (56 of the PDF) of the GLSL 1.50 spec:
		1272	*
		1273	* "If a matrix is constructed from a matrix, then each component
		1274	* (column i, row j) in the result that has a corresponding
		1275	* component (column i, row j) in the argument will be initialized
		1276	* from there. All other components will be initialized to the
		1277	* identity matrix. If a matrix argument is given to a matrix
		1278	* constructor, it is an error to have any other arguments."
		1279	*/
		1280	assert(first_param->next->is_tail_sentinel());
		1281	ir_rvalue *const src_matrix = first_param;
		1282
		1283	/* If the source matrix is smaller, pre-initialize the relavent parts of
		1284	* the destination matrix to the identity matrix.
		1285	*/
		1286	if ((src_matrix->type->matrix_columns < var->type->matrix_columns)
		1287	\|\| (src_matrix->type->vector_elements < var->type->vector_elements)) {
		1288
		1289	/* If the source matrix has fewer rows, every column of the destination
		1290	* must be initialized. Otherwise only the columns in the destination
		1291	* that do not exist in the source must be initialized.
		1292	*/
		1293	unsigned col =
		1294	(src_matrix->type->vector_elements < var->type->vector_elements)
		1295	? 0 : src_matrix->type->matrix_columns;
		1296
		1297	const glsl_type *const col_type = var->type->column_type();
		1298	for (/* empty */; col < var->type->matrix_columns; col++) {
		1299	ir_constant_data ident;
		1300
		1301	ident.f[0] = 0.0;
		1302	ident.f[1] = 0.0;
		1303	ident.f[2] = 0.0;
		1304	ident.f[3] = 0.0;
		1305
		1306	ident.f[col] = 1.0;
		1307
		1308	ir_rvalue *const rhs = new(ctx) ir_constant(col_type, &ident);
		1309
		1310	ir_rvalue *const lhs =
		1311	new(ctx) ir_dereference_array(var, new(ctx) ir_constant(col));
		1312
		1313	ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL);
		1314	instructions->push_tail(inst);
		1315	}
		1316	}
		1317
		1318	/* Assign columns from the source matrix to the destination matrix.
		1319	*
		1320	* Since the parameter will be used in the RHS of multiple assignments,
		1321	* generate a temporary and copy the paramter there.
		1322	*/
		1323	ir_variable *const rhs_var =
		1324	new(ctx) ir_variable(first_param->type, "mat_ctor_mat",
		1325	ir_var_temporary);
		1326	instructions->push_tail(rhs_var);
		1327
		1328	ir_dereference *const rhs_var_ref =
		1329	new(ctx) ir_dereference_variable(rhs_var);
		1330	ir_instruction *const inst =
		1331	new(ctx) ir_assignment(rhs_var_ref, first_param, NULL);
		1332	instructions->push_tail(inst);
		1333
		1334	const unsigned last_row = MIN2(src_matrix->type->vector_elements,
		1335	var->type->vector_elements);
		1336	const unsigned last_col = MIN2(src_matrix->type->matrix_columns,
		1337	var->type->matrix_columns);
		1338
		1339	unsigned swiz[4] = { 0, 0, 0, 0 };
		1340	for (unsigned i = 1; i < last_row; i++)
		1341	swiz[i] = i;
		1342
		1343	const unsigned write_mask = (1U << last_row) - 1;
		1344
		1345	for (unsigned i = 0; i < last_col; i++) {
		1346	ir_dereference *const lhs =
		1347	new(ctx) ir_dereference_array(var, new(ctx) ir_constant(i));
		1348	ir_rvalue *const rhs_col =
		1349	new(ctx) ir_dereference_array(rhs_var, new(ctx) ir_constant(i));
		1350
		1351	/* If one matrix has columns that are smaller than the columns of the
		1352	* other matrix, wrap the column access of the larger with a swizzle
		1353	* so that the LHS and RHS of the assignment have the same size (and
		1354	* therefore have the same type).
		1355	*
		1356	* It would be perfectly valid to unconditionally generate the
		1357	* swizzles, this this will typically result in a more compact IR tree.
		1358	*/
		1359	ir_rvalue *rhs;
		1360	if (lhs->type->vector_elements != rhs_col->type->vector_elements) {
		1361	rhs = new(ctx) ir_swizzle(rhs_col, swiz, last_row);
		1362	} else {
		1363	rhs = rhs_col;
		1364	}
		1365
		1366	ir_instruction *inst =
		1367	new(ctx) ir_assignment(lhs, rhs, NULL, write_mask);
		1368	instructions->push_tail(inst);
		1369	}
		1370	} else {
		1371	const unsigned cols = type->matrix_columns;
		1372	const unsigned rows = type->vector_elements;
		1373	unsigned remaining_slots = rows * cols;
		1374	unsigned col_idx = 0;
		1375	unsigned row_idx = 0;
		1376
		1377	foreach_in_list(ir_rvalue, rhs, parameters) {
		1378	unsigned rhs_components = rhs->type->components();
		1379	unsigned rhs_base = 0;
		1380
		1381	if (remaining_slots == 0)
		1382	break;
		1383
		1384	/* Since the parameter might be used in the RHS of two assignments,
		1385	* generate a temporary and copy the paramter there.
		1386	*/
		1387	ir_variable *rhs_var =
		1388	new(ctx) ir_variable(rhs->type, "mat_ctor_vec", ir_var_temporary);
		1389	instructions->push_tail(rhs_var);
		1390
		1391	ir_dereference *rhs_var_ref =
		1392	new(ctx) ir_dereference_variable(rhs_var);
		1393	ir_instruction *inst = new(ctx) ir_assignment(rhs_var_ref, rhs, NULL);
		1394	instructions->push_tail(inst);
		1395
		1396	do {
		1397	/* Assign the current parameter to as many components of the matrix
		1398	* as it will fill.
		1399	*
		1400	* NOTE: A single vector parameter can span two matrix columns. A
		1401	* single vec4, for example, can completely fill a mat2.
		1402	*/
		1403	unsigned count = MIN2(rows - row_idx,
		1404	rhs_components - rhs_base);
		1405
		1406	rhs_var_ref = new(ctx) ir_dereference_variable(rhs_var);
		1407	ir_instruction *inst = assign_to_matrix_column(var, col_idx,
		1408	row_idx,
		1409	rhs_var_ref,
		1410	rhs_base,
		1411	count, ctx);
		1412	instructions->push_tail(inst);
		1413	rhs_base += count;
		1414	row_idx += count;
		1415	remaining_slots -= count;
		1416
		1417	/* Sometimes, there is still data left in the parameters and
		1418	* components left to be set in the destination but in other
		1419	* column.
		1420	*/
		1421	if (row_idx >= rows) {
		1422	row_idx = 0;
		1423	col_idx++;
		1424	}
		1425	} while(remaining_slots > 0 && rhs_base < rhs_components);
		1426	}
		1427	}
		1428
		1429	return new(ctx) ir_dereference_variable(var);
		1430	}
		1431
		1432
		1433	ir_rvalue *
		1434	emit_inline_record_constructor(const glsl_type *type,
		1435	exec_list *instructions,
		1436	exec_list *parameters,
		1437	void *mem_ctx)
		1438	{
		1439	ir_variable *const var =
		1440	new(mem_ctx) ir_variable(type, "record_ctor", ir_var_temporary);
		1441	ir_dereference_variable *const d = new(mem_ctx) ir_dereference_variable(var);
		1442
		1443	instructions->push_tail(var);
		1444
		1445	exec_node *node = parameters->head;
		1446	for (unsigned i = 0; i < type->length; i++) {
		1447	assert(!node->is_tail_sentinel());
		1448
		1449	ir_dereference *const lhs =
		1450	new(mem_ctx) ir_dereference_record(d->clone(mem_ctx, NULL),
		1451	type->fields.structure[i].name);
		1452
		1453	ir_rvalue const rhs = ((ir_instruction ) node)->as_rvalue();
		1454	assert(rhs != NULL);
		1455
		1456	ir_instruction *const assign = new(mem_ctx) ir_assignment(lhs, rhs, NULL);
		1457
		1458	instructions->push_tail(assign);
		1459	node = node->next;
		1460	}
		1461
		1462	return d;
		1463	}
		1464
		1465
		1466	static ir_rvalue *
		1467	process_record_constructor(exec_list *instructions,
		1468	const glsl_type *constructor_type,
		1469	YYLTYPE loc, exec_list parameters,
		1470	struct _mesa_glsl_parse_state *state)
		1471	{
		1472	void *ctx = state;
		1473	exec_list actual_parameters;
		1474
		1475	process_parameters(instructions, &actual_parameters,
		1476	parameters, state);
		1477
		1478	exec_node *node = actual_parameters.head;
		1479	for (unsigned i = 0; i < constructor_type->length; i++) {
		1480	ir_rvalue ir = (ir_rvalue ) node;
		1481
		1482	if (node->is_tail_sentinel()) {
		1483	_mesa_glsl_error(loc, state,
		1484	"insufficient parameters to constructor for `%s'",
		1485	constructor_type->name);
		1486	return ir_rvalue::error_value(ctx);
		1487	}
		1488
		1489	if (apply_implicit_conversion(constructor_type->fields.structure[i].type,
		1490	ir, state)) {
		1491	node->replace_with(ir);
		1492	} else {
		1493	_mesa_glsl_error(loc, state,
		1494	"parameter type mismatch in constructor for `%s.%s' "
		1495	"(%s vs %s)",
		1496	constructor_type->name,
		1497	constructor_type->fields.structure[i].name,
		1498	ir->type->name,
		1499	constructor_type->fields.structure[i].type->name);
		1500	return ir_rvalue::error_value(ctx);;
		1501	}
		1502
		1503	node = node->next;
		1504	}
		1505
		1506	if (!node->is_tail_sentinel()) {
		1507	_mesa_glsl_error(loc, state, "too many parameters in constructor "
		1508	"for `%s'", constructor_type->name);
		1509	return ir_rvalue::error_value(ctx);
		1510	}
		1511
		1512	ir_rvalue *const constant =
		1513	constant_record_constructor(constructor_type, &actual_parameters,
		1514	state);
		1515
		1516	return (constant != NULL)
		1517	? constant
		1518	: emit_inline_record_constructor(constructor_type, instructions,
		1519	&actual_parameters, state);
		1520	}
		1521
		1522
		1523	ir_rvalue *
		1524	ast_function_expression::hir(exec_list *instructions,
		1525	struct _mesa_glsl_parse_state *state)
		1526	{
		1527	void *ctx = state;
		1528	/* There are three sorts of function calls.
		1529	*
		1530	* 1. constructors - The first subexpression is an ast_type_specifier.
		1531	* 2. methods - Only the .length() method of array types.
		1532	* 3. functions - Calls to regular old functions.
		1533	*
		1534	* Method calls are actually detected when the ast_field_selection
		1535	* expression is handled.
		1536	*/
		1537	if (is_constructor()) {
		1538	const ast_type_specifier type = (ast_type_specifier ) subexpressions[0];
		1539	YYLTYPE loc = type->get_location();
		1540	const char *name;
		1541
		1542	const glsl_type *const constructor_type = type->glsl_type(& name, state);
		1543
		1544	/* constructor_type can be NULL if a variable with the same name as the
		1545	* structure has come into scope.
		1546	*/
		1547	if (constructor_type == NULL) {
		1548	_mesa_glsl_error(& loc, state, "unknown type `%s' (structure name "
		1549	"may be shadowed by a variable with the same name)",
		1550	type->type_name);
		1551	return ir_rvalue::error_value(ctx);
		1552	}
		1553
		1554
		1555	/* Constructors for opaque types are illegal.
		1556	*/
		1557	if (constructor_type->contains_opaque()) {
		1558	_mesa_glsl_error(& loc, state, "cannot construct opaque type `%s'",
		1559	constructor_type->name);
		1560	return ir_rvalue::error_value(ctx);
		1561	}
		1562
		1563	if (constructor_type->is_array()) {
		1564	if (!state->check_version(120, 300, &loc,
		1565	"array constructors forbidden")) {
		1566	return ir_rvalue::error_value(ctx);
		1567	}
		1568
		1569	return process_array_constructor(instructions, constructor_type,
		1570	& loc, &this->expressions, state);
		1571	}
		1572
		1573
		1574	/* There are two kinds of constructor calls. Constructors for arrays and
		1575	* structures must have the exact number of arguments with matching types
		1576	* in the correct order. These constructors follow essentially the same
		1577	* type matching rules as functions.
		1578	*
		1579	* Constructors for built-in language types, such as mat4 and vec2, are
		1580	* free form. The only requirements are that the parameters must provide
		1581	* enough values of the correct scalar type and that no arguments are
		1582	* given past the last used argument.
		1583	*
		1584	* When using the C-style initializer syntax from GLSL 4.20, constructors
		1585	* must have the exact number of arguments with matching types in the
		1586	* correct order.
		1587	*/
		1588	if (constructor_type->is_record()) {
		1589	return process_record_constructor(instructions, constructor_type,
		1590	&loc, &this->expressions,
		1591	state);
		1592	}
		1593
		1594	if (!constructor_type->is_numeric() && !constructor_type->is_boolean())
		1595	return ir_rvalue::error_value(ctx);
		1596
		1597	/* Total number of components of the type being constructed. */
		1598	const unsigned type_components = constructor_type->components();
		1599
		1600	/* Number of components from parameters that have actually been
		1601	* consumed. This is used to perform several kinds of error checking.
		1602	*/
		1603	unsigned components_used = 0;
		1604
		1605	unsigned matrix_parameters = 0;
		1606	unsigned nonmatrix_parameters = 0;
		1607	exec_list actual_parameters;
		1608
		1609	foreach_list_typed(ast_node, ast, link, &this->expressions) {
		1610	ir_rvalue *result = ast->hir(instructions, state);
		1611
		1612	/* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec:
		1613	*
		1614	* "It is an error to provide extra arguments beyond this
		1615	* last used argument."
		1616	*/
		1617	if (components_used >= type_components) {
		1618	_mesa_glsl_error(& loc, state, "too many parameters to `%s' "
		1619	"constructor",
		1620	constructor_type->name);
		1621	return ir_rvalue::error_value(ctx);
		1622	}
		1623
		1624	if (!result->type->is_numeric() && !result->type->is_boolean()) {
		1625	_mesa_glsl_error(& loc, state, "cannot construct `%s' from a "
		1626	"non-numeric data type",
		1627	constructor_type->name);
		1628	return ir_rvalue::error_value(ctx);
		1629	}
		1630
		1631	/* Count the number of matrix and nonmatrix parameters. This
		1632	* is used below to enforce some of the constructor rules.
		1633	*/
		1634	if (result->type->is_matrix())
		1635	matrix_parameters++;
		1636	else
		1637	nonmatrix_parameters++;
		1638
		1639	actual_parameters.push_tail(result);
		1640	components_used += result->type->components();
		1641	}
		1642
		1643	/* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
		1644	*
		1645	* "It is an error to construct matrices from other matrices. This
		1646	* is reserved for future use."
		1647	*/
		1648	if (matrix_parameters > 0
		1649	&& constructor_type->is_matrix()
		1650	&& !state->check_version(120, 100, &loc,
		1651	"cannot construct `%s' from a matrix",
		1652	constructor_type->name)) {
		1653	return ir_rvalue::error_value(ctx);
		1654	}
		1655
		1656	/* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec:
		1657	*
		1658	* "If a matrix argument is given to a matrix constructor, it is
		1659	* an error to have any other arguments."
		1660	*/
		1661	if ((matrix_parameters > 0)
		1662	&& ((matrix_parameters + nonmatrix_parameters) > 1)
		1663	&& constructor_type->is_matrix()) {
		1664	_mesa_glsl_error(& loc, state, "for matrix `%s' constructor, "
		1665	"matrix must be only parameter",
		1666	constructor_type->name);
		1667	return ir_rvalue::error_value(ctx);
		1668	}
		1669
		1670	/* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
		1671	*
		1672	* "In these cases, there must be enough components provided in the
		1673	* arguments to provide an initializer for every component in the
		1674	* constructed value."
		1675	*/
		1676	if (components_used < type_components && components_used != 1
		1677	&& matrix_parameters == 0) {
		1678	_mesa_glsl_error(& loc, state, "too few components to construct "
		1679	"`%s'",
		1680	constructor_type->name);
		1681	return ir_rvalue::error_value(ctx);
		1682	}
		1683
		1684	/* Later, we cast each parameter to the same base type as the
		1685	* constructor. Since there are no non-floating point matrices, we
		1686	* need to break them up into a series of column vectors.
		1687	*/
		1688	if (constructor_type->base_type != GLSL_TYPE_FLOAT) {
		1689	foreach_in_list_safe(ir_rvalue, matrix, &actual_parameters) {
		1690	if (!matrix->type->is_matrix())
		1691	continue;
		1692
		1693	/* Create a temporary containing the matrix. */
		1694	ir_variable *var = new(ctx) ir_variable(matrix->type, "matrix_tmp",
		1695	ir_var_temporary);
		1696	instructions->push_tail(var);
		1697	instructions->push_tail(new(ctx) ir_assignment(new(ctx)
		1698	ir_dereference_variable(var), matrix, NULL));
		1699	var->constant_value = matrix->constant_expression_value();
		1700
		1701	/* Replace the matrix with dereferences of its columns. */
		1702	for (int i = 0; i < matrix->type->matrix_columns; i++) {
		1703	matrix->insert_before(new (ctx) ir_dereference_array(var,
		1704	new(ctx) ir_constant(i)));
		1705	}
		1706	matrix->remove();
		1707	}
		1708	}
		1709
		1710	bool all_parameters_are_constant = true;
		1711
		1712	/* Type cast each parameter and, if possible, fold constants.*/
		1713	foreach_in_list_safe(ir_rvalue, ir, &actual_parameters) {
		1714	const glsl_type *desired_type =
		1715	glsl_type::get_instance(constructor_type->base_type,
		1716	ir->type->vector_elements,
		1717	ir->type->matrix_columns);
		1718	ir_rvalue *result = convert_component(ir, desired_type);
		1719
		1720	/* Attempt to convert the parameter to a constant valued expression.
		1721	* After doing so, track whether or not all the parameters to the
		1722	* constructor are trivially constant valued expressions.
		1723	*/
		1724	ir_rvalue *const constant = result->constant_expression_value();
		1725
		1726	if (constant != NULL)
		1727	result = constant;
		1728	else
		1729	all_parameters_are_constant = false;
		1730
		1731	if (result != ir) {
		1732	ir->replace_with(result);
		1733	}
		1734	}
		1735
		1736	/* If all of the parameters are trivially constant, create a
		1737	* constant representing the complete collection of parameters.
		1738	*/
		1739	if (all_parameters_are_constant) {
		1740	return new(ctx) ir_constant(constructor_type, &actual_parameters);
		1741	} else if (constructor_type->is_scalar()) {
		1742	return dereference_component((ir_rvalue *) actual_parameters.head,
		1743	0);
		1744	} else if (constructor_type->is_vector()) {
		1745	return emit_inline_vector_constructor(constructor_type,
		1746	instructions,
		1747	&actual_parameters,
		1748	ctx);
		1749	} else {
		1750	assert(constructor_type->is_matrix());
		1751	return emit_inline_matrix_constructor(constructor_type,
		1752	instructions,
		1753	&actual_parameters,
		1754	ctx);
		1755	}
		1756	} else {
		1757	const ast_expression *id = subexpressions[0];
		1758	const char *func_name = id->primary_expression.identifier;
		1759	YYLTYPE loc = get_location();
		1760	exec_list actual_parameters;
		1761
		1762	process_parameters(instructions, &actual_parameters, &this->expressions,
		1763	state);
		1764
		1765	ir_function_signature *sig =
		1766	match_function_by_name(func_name, &actual_parameters, state);
		1767
		1768	ir_rvalue *value = NULL;
		1769	if (sig == NULL) {
		1770	no_matching_function_error(func_name, &loc, &actual_parameters, state);
		1771	value = ir_rvalue::error_value(ctx);
		1772	} else if (!verify_parameter_modes(state, sig, actual_parameters, this->expressions)) {
		1773	/* an error has already been emitted */
		1774	value = ir_rvalue::error_value(ctx);
		1775	} else {
		1776	value = generate_call(instructions, sig, &actual_parameters, state);
		1777	}
		1778
		1779	return value;
		1780	}
		1781
		1782	unreachable("not reached");
		1783	}
		1784
		1785	ir_rvalue *
		1786	ast_aggregate_initializer::hir(exec_list *instructions,
		1787	struct _mesa_glsl_parse_state *state)
		1788	{
		1789	void *ctx = state;
		1790	YYLTYPE loc = this->get_location();
		1791
		1792	if (!this->constructor_type) {
		1793	_mesa_glsl_error(&loc, state, "type of C-style initializer unknown");
		1794	return ir_rvalue::error_value(ctx);
		1795	}
		1796	const glsl_type *const constructor_type = this->constructor_type;
		1797
		1798	if (!state->ARB_shading_language_420pack_enable) {
		1799	_mesa_glsl_error(&loc, state, "C-style initialization requires the "
		1800	"GL_ARB_shading_language_420pack extension");
		1801	return ir_rvalue::error_value(ctx);
		1802	}
		1803
		1804	if (constructor_type->is_array()) {
		1805	return process_array_constructor(instructions, constructor_type, &loc,
		1806	&this->expressions, state);
		1807	}
		1808
		1809	if (constructor_type->is_record()) {
		1810	return process_record_constructor(instructions, constructor_type, &loc,
		1811	&this->expressions, state);
		1812	}
		1813
		1814	return process_vec_mat_constructor(instructions, constructor_type, &loc,
		1815	&this->expressions, state);
		1816	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/mesa-10.6.0/src/glsl/ast_function.cpp – Rev 5568