WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/mesa-10.6.0/src/glsl/ir_constant_expression.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	/**
		25	* \file ir_constant_expression.cpp
		26	* Evaluate and process constant valued expressions
		27	*
		28	* In GLSL, constant valued expressions are used in several places. These
		29	* must be processed and evaluated very early in the compilation process.
		30	*
		31	* * Sizes of arrays
		32	* * Initializers for uniforms
		33	* * Initializers for \c const variables
		34	*/
		35
		36	#include
		37	#include "main/core.h" /* for MAX2, MIN2, CLAMP */
		38	#include "util/rounding.h" /* for _mesa_roundeven */
		39	#include "ir.h"
		40	#include "glsl_types.h"
		41	#include "program/hash_table.h"
		42
		43	#if defined(_MSC_VER) && (_MSC_VER < 1800)
		44	static int isnormal(double x)
		45	{
		46	return _fpclass(x) == _FPCLASS_NN \|\| _fpclass(x) == _FPCLASS_PN;
		47	}
		48	#elif defined(__SUNPRO_CC) && !defined(isnormal)
		49	#include
		50	static int isnormal(double x)
		51	{
		52	return fpclass(x) == FP_NORMAL;
		53	}
		54	#endif
		55
		56	#if defined(_MSC_VER)
		57	static double copysign(double x, double y)
		58	{
		59	return _copysign(x, y);
		60	}
		61	#endif
		62
		63	static float
		64	dot_f(ir_constant op0, ir_constant op1)
		65	{
		66	assert(op0->type->is_float() && op1->type->is_float());
		67
		68	float result = 0;
		69	for (unsigned c = 0; c < op0->type->components(); c++)
		70	result += op0->value.f[c] * op1->value.f[c];
		71
		72	return result;
		73	}
		74
		75	static double
		76	dot_d(ir_constant op0, ir_constant op1)
		77	{
		78	assert(op0->type->is_double() && op1->type->is_double());
		79
		80	double result = 0;
		81	for (unsigned c = 0; c < op0->type->components(); c++)
		82	result += op0->value.d[c] * op1->value.d[c];
		83
		84	return result;
		85	}
		86
		87	/* This method is the only one supported by gcc. Unions in particular
		88	* are iffy, and read-through-converted-pointer is killed by strict
		89	* aliasing. OTOH, the compiler sees through the memcpy, so the
		90	* resulting asm is reasonable.
		91	*/
		92	static float
		93	bitcast_u2f(unsigned int u)
		94	{
		95	assert(sizeof(float) == sizeof(unsigned int));
		96	float f;
		97	memcpy(&f, &u, sizeof(f));
		98	return f;
		99	}
		100
		101	static unsigned int
		102	bitcast_f2u(float f)
		103	{
		104	assert(sizeof(float) == sizeof(unsigned int));
		105	unsigned int u;
		106	memcpy(&u, &f, sizeof(f));
		107	return u;
		108	}
		109
		110	/**
		111	* Evaluate one component of a floating-point 4x8 unpacking function.
		112	*/
		113	typedef uint8_t
		114	(*pack_1x8_func_t)(float);
		115
		116	/**
		117	* Evaluate one component of a floating-point 2x16 unpacking function.
		118	*/
		119	typedef uint16_t
		120	(*pack_1x16_func_t)(float);
		121
		122	/**
		123	* Evaluate one component of a floating-point 4x8 unpacking function.
		124	*/
		125	typedef float
		126	(*unpack_1x8_func_t)(uint8_t);
		127
		128	/**
		129	* Evaluate one component of a floating-point 2x16 unpacking function.
		130	*/
		131	typedef float
		132	(*unpack_1x16_func_t)(uint16_t);
		133
		134	/**
		135	* Evaluate a 2x16 floating-point packing function.
		136	*/
		137	static uint32_t
		138	pack_2x16(pack_1x16_func_t pack_1x16,
		139	float x, float y)
		140	{
		141	/* From section 8.4 of the GLSL ES 3.00 spec:
		142	*
		143	* packSnorm2x16
		144	* -------------
		145	* The first component of the vector will be written to the least
		146	* significant bits of the output; the last component will be written to
		147	* the most significant bits.
		148	*
		149	* The specifications for the other packing functions contain similar
		150	* language.
		151	*/
		152	uint32_t u = 0;
		153	u \|= ((uint32_t) pack_1x16(x) << 0);
		154	u \|= ((uint32_t) pack_1x16(y) << 16);
		155	return u;
		156	}
		157
		158	/**
		159	* Evaluate a 4x8 floating-point packing function.
		160	*/
		161	static uint32_t
		162	pack_4x8(pack_1x8_func_t pack_1x8,
		163	float x, float y, float z, float w)
		164	{
		165	/* From section 8.4 of the GLSL 4.30 spec:
		166	*
		167	* packSnorm4x8
		168	* ------------
		169	* The first component of the vector will be written to the least
		170	* significant bits of the output; the last component will be written to
		171	* the most significant bits.
		172	*
		173	* The specifications for the other packing functions contain similar
		174	* language.
		175	*/
		176	uint32_t u = 0;
		177	u \|= ((uint32_t) pack_1x8(x) << 0);
		178	u \|= ((uint32_t) pack_1x8(y) << 8);
		179	u \|= ((uint32_t) pack_1x8(z) << 16);
		180	u \|= ((uint32_t) pack_1x8(w) << 24);
		181	return u;
		182	}
		183
		184	/**
		185	* Evaluate a 2x16 floating-point unpacking function.
		186	*/
		187	static void
		188	unpack_2x16(unpack_1x16_func_t unpack_1x16,
		189	uint32_t u,
		190	float x, float y)
		191	{
		192	/* From section 8.4 of the GLSL ES 3.00 spec:
		193	*
		194	* unpackSnorm2x16
		195	* ---------------
		196	* The first component of the returned vector will be extracted from
		197	* the least significant bits of the input; the last component will be
		198	* extracted from the most significant bits.
		199	*
		200	* The specifications for the other unpacking functions contain similar
		201	* language.
		202	*/
		203	*x = unpack_1x16((uint16_t) (u & 0xffff));
		204	*y = unpack_1x16((uint16_t) (u >> 16));
		205	}
		206
		207	/**
		208	* Evaluate a 4x8 floating-point unpacking function.
		209	*/
		210	static void
		211	unpack_4x8(unpack_1x8_func_t unpack_1x8, uint32_t u,
		212	float x, float y, float z, float w)
		213	{
		214	/* From section 8.4 of the GLSL 4.30 spec:
		215	*
		216	* unpackSnorm4x8
		217	* --------------
		218	* The first component of the returned vector will be extracted from
		219	* the least significant bits of the input; the last component will be
		220	* extracted from the most significant bits.
		221	*
		222	* The specifications for the other unpacking functions contain similar
		223	* language.
		224	*/
		225	*x = unpack_1x8((uint8_t) (u & 0xff));
		226	*y = unpack_1x8((uint8_t) (u >> 8));
		227	*z = unpack_1x8((uint8_t) (u >> 16));
		228	*w = unpack_1x8((uint8_t) (u >> 24));
		229	}
		230
		231	/**
		232	* Evaluate one component of packSnorm4x8.
		233	*/
		234	static uint8_t
		235	pack_snorm_1x8(float x)
		236	{
		237	/* From section 8.4 of the GLSL 4.30 spec:
		238	*
		239	* packSnorm4x8
		240	* ------------
		241	* The conversion for component c of v to fixed point is done as
		242	* follows:
		243	*
		244	* packSnorm4x8: round(clamp(c, -1, +1) * 127.0)
		245	*
		246	* We must first cast the float to an int, because casting a negative
		247	* float to a uint is undefined.
		248	*/
		249	return (uint8_t) (int)
		250	_mesa_roundevenf(CLAMP(x, -1.0f, +1.0f) * 127.0f);
		251	}
		252
		253	/**
		254	* Evaluate one component of packSnorm2x16.
		255	*/
		256	static uint16_t
		257	pack_snorm_1x16(float x)
		258	{
		259	/* From section 8.4 of the GLSL ES 3.00 spec:
		260	*
		261	* packSnorm2x16
		262	* -------------
		263	* The conversion for component c of v to fixed point is done as
		264	* follows:
		265	*
		266	* packSnorm2x16: round(clamp(c, -1, +1) * 32767.0)
		267	*
		268	* We must first cast the float to an int, because casting a negative
		269	* float to a uint is undefined.
		270	*/
		271	return (uint16_t) (int)
		272	_mesa_roundevenf(CLAMP(x, -1.0f, +1.0f) * 32767.0f);
		273	}
		274
		275	/**
		276	* Evaluate one component of unpackSnorm4x8.
		277	*/
		278	static float
		279	unpack_snorm_1x8(uint8_t u)
		280	{
		281	/* From section 8.4 of the GLSL 4.30 spec:
		282	*
		283	* unpackSnorm4x8
		284	* --------------
		285	* The conversion for unpacked fixed-point value f to floating point is
		286	* done as follows:
		287	*
		288	* unpackSnorm4x8: clamp(f / 127.0, -1, +1)
		289	*/
		290	return CLAMP((int8_t) u / 127.0f, -1.0f, +1.0f);
		291	}
		292
		293	/**
		294	* Evaluate one component of unpackSnorm2x16.
		295	*/
		296	static float
		297	unpack_snorm_1x16(uint16_t u)
		298	{
		299	/* From section 8.4 of the GLSL ES 3.00 spec:
		300	*
		301	* unpackSnorm2x16
		302	* ---------------
		303	* The conversion for unpacked fixed-point value f to floating point is
		304	* done as follows:
		305	*
		306	* unpackSnorm2x16: clamp(f / 32767.0, -1, +1)
		307	*/
		308	return CLAMP((int16_t) u / 32767.0f, -1.0f, +1.0f);
		309	}
		310
		311	/**
		312	* Evaluate one component packUnorm4x8.
		313	*/
		314	static uint8_t
		315	pack_unorm_1x8(float x)
		316	{
		317	/* From section 8.4 of the GLSL 4.30 spec:
		318	*
		319	* packUnorm4x8
		320	* ------------
		321	* The conversion for component c of v to fixed point is done as
		322	* follows:
		323	*
		324	* packUnorm4x8: round(clamp(c, 0, +1) * 255.0)
		325	*/
		326	return (uint8_t) (int) _mesa_roundevenf(CLAMP(x, 0.0f, 1.0f) * 255.0f);
		327	}
		328
		329	/**
		330	* Evaluate one component packUnorm2x16.
		331	*/
		332	static uint16_t
		333	pack_unorm_1x16(float x)
		334	{
		335	/* From section 8.4 of the GLSL ES 3.00 spec:
		336	*
		337	* packUnorm2x16
		338	* -------------
		339	* The conversion for component c of v to fixed point is done as
		340	* follows:
		341	*
		342	* packUnorm2x16: round(clamp(c, 0, +1) * 65535.0)
		343	*/
		344	return (uint16_t) (int)
		345	_mesa_roundevenf(CLAMP(x, 0.0f, 1.0f) * 65535.0f);
		346	}
		347
		348	/**
		349	* Evaluate one component of unpackUnorm4x8.
		350	*/
		351	static float
		352	unpack_unorm_1x8(uint8_t u)
		353	{
		354	/* From section 8.4 of the GLSL 4.30 spec:
		355	*
		356	* unpackUnorm4x8
		357	* --------------
		358	* The conversion for unpacked fixed-point value f to floating point is
		359	* done as follows:
		360	*
		361	* unpackUnorm4x8: f / 255.0
		362	*/
		363	return (float) u / 255.0f;
		364	}
		365
		366	/**
		367	* Evaluate one component of unpackUnorm2x16.
		368	*/
		369	static float
		370	unpack_unorm_1x16(uint16_t u)
		371	{
		372	/* From section 8.4 of the GLSL ES 3.00 spec:
		373	*
		374	* unpackUnorm2x16
		375	* ---------------
		376	* The conversion for unpacked fixed-point value f to floating point is
		377	* done as follows:
		378	*
		379	* unpackUnorm2x16: f / 65535.0
		380	*/
		381	return (float) u / 65535.0f;
		382	}
		383
		384	/**
		385	* Evaluate one component of packHalf2x16.
		386	*/
		387	static uint16_t
		388	pack_half_1x16(float x)
		389	{
		390	return _mesa_float_to_half(x);
		391	}
		392
		393	/**
		394	* Evaluate one component of unpackHalf2x16.
		395	*/
		396	static float
		397	unpack_half_1x16(uint16_t u)
		398	{
		399	return _mesa_half_to_float(u);
		400	}
		401
		402	/**
		403	* Get the constant that is ultimately referenced by an r-value, in a constant
		404	* expression evaluation context.
		405	*
		406	* The offset is used when the reference is to a specific column of a matrix.
		407	*/
		408	static bool
		409	constant_referenced(const ir_dereference *deref,
		410	struct hash_table *variable_context,
		411	ir_constant *&store, int &offset)
		412	{
		413	store = NULL;
		414	offset = 0;
		415
		416	if (variable_context == NULL)
		417	return false;
		418
		419	switch (deref->ir_type) {
		420	case ir_type_dereference_array: {
		421	const ir_dereference_array *const da =
		422	(const ir_dereference_array *) deref;
		423
		424	ir_constant *const index_c =
		425	da->array_index->constant_expression_value(variable_context);
		426
		427	if (!index_c \|\| !index_c->type->is_scalar() \|\| !index_c->type->is_integer())
		428	break;
		429
		430	const int index = index_c->type->base_type == GLSL_TYPE_INT ?
		431	index_c->get_int_component(0) :
		432	index_c->get_uint_component(0);
		433
		434	ir_constant *substore;
		435	int suboffset;
		436
		437	const ir_dereference *const deref = da->array->as_dereference();
		438	if (!deref)
		439	break;
		440
		441	if (!constant_referenced(deref, variable_context, substore, suboffset))
		442	break;
		443
		444	const glsl_type *const vt = da->array->type;
		445	if (vt->is_array()) {
		446	store = substore->get_array_element(index);
		447	offset = 0;
		448	} else if (vt->is_matrix()) {
		449	store = substore;
		450	offset = index * vt->vector_elements;
		451	} else if (vt->is_vector()) {
		452	store = substore;
		453	offset = suboffset + index;
		454	}
		455
		456	break;
		457	}
		458
		459	case ir_type_dereference_record: {
		460	const ir_dereference_record *const dr =
		461	(const ir_dereference_record *) deref;
		462
		463	const ir_dereference *const deref = dr->record->as_dereference();
		464	if (!deref)
		465	break;
		466
		467	ir_constant *substore;
		468	int suboffset;
		469
		470	if (!constant_referenced(deref, variable_context, substore, suboffset))
		471	break;
		472
		473	/* Since we're dropping it on the floor...
		474	*/
		475	assert(suboffset == 0);
		476
		477	store = substore->get_record_field(dr->field);
		478	break;
		479	}
		480
		481	case ir_type_dereference_variable: {
		482	const ir_dereference_variable *const dv =
		483	(const ir_dereference_variable *) deref;
		484
		485	store = (ir_constant *) hash_table_find(variable_context, dv->var);
		486	break;
		487	}
		488
		489	default:
		490	assert(!"Should not get here.");
		491	break;
		492	}
		493
		494	return store != NULL;
		495	}
		496
		497
		498	ir_constant *
		499	ir_rvalue::constant_expression_value(struct hash_table *)
		500	{
		501	assert(this->type->is_error());
		502	return NULL;
		503	}
		504
		505	ir_constant *
		506	ir_expression::constant_expression_value(struct hash_table *variable_context)
		507	{
		508	if (this->type->is_error())
		509	return NULL;
		510
		511	ir_constant *op[ARRAY_SIZE(this->operands)] = { NULL, };
		512	ir_constant_data data;
		513
		514	memset(&data, 0, sizeof(data));
		515
		516	for (unsigned operand = 0; operand < this->get_num_operands(); operand++) {
		517	op[operand] = this->operands[operand]->constant_expression_value(variable_context);
		518	if (!op[operand])
		519	return NULL;
		520	}
		521
		522	if (op[1] != NULL)
		523	switch (this->operation) {
		524	case ir_binop_lshift:
		525	case ir_binop_rshift:
		526	case ir_binop_ldexp:
		527	case ir_binop_interpolate_at_offset:
		528	case ir_binop_interpolate_at_sample:
		529	case ir_binop_vector_extract:
		530	case ir_triop_csel:
		531	case ir_triop_bitfield_extract:
		532	break;
		533
		534	default:
		535	assert(op[0]->type->base_type == op[1]->type->base_type);
		536	break;
		537	}
		538
		539	bool op0_scalar = op[0]->type->is_scalar();
		540	bool op1_scalar = op[1] != NULL && op[1]->type->is_scalar();
		541
		542	/* When iterating over a vector or matrix's components, we want to increase
		543	* the loop counter. However, for scalars, we want to stay at 0.
		544	*/
		545	unsigned c0_inc = op0_scalar ? 0 : 1;
		546	unsigned c1_inc = op1_scalar ? 0 : 1;
		547	unsigned components;
		548	if (op1_scalar \|\| !op[1]) {
		549	components = op[0]->type->components();
		550	} else {
		551	components = op[1]->type->components();
		552	}
		553
		554	void *ctx = ralloc_parent(this);
		555
		556	/* Handle array operations here, rather than below. */
		557	if (op[0]->type->is_array()) {
		558	assert(op[1] != NULL && op[1]->type->is_array());
		559	switch (this->operation) {
		560	case ir_binop_all_equal:
		561	return new(ctx) ir_constant(op[0]->has_value(op[1]));
		562	case ir_binop_any_nequal:
		563	return new(ctx) ir_constant(!op[0]->has_value(op[1]));
		564	default:
		565	break;
		566	}
		567	return NULL;
		568	}
		569
		570	switch (this->operation) {
		571	case ir_unop_bit_not:
		572	switch (op[0]->type->base_type) {
		573	case GLSL_TYPE_INT:
		574	for (unsigned c = 0; c < components; c++)
		575	data.i[c] = ~ op[0]->value.i[c];
		576	break;
		577	case GLSL_TYPE_UINT:
		578	for (unsigned c = 0; c < components; c++)
		579	data.u[c] = ~ op[0]->value.u[c];
		580	break;
		581	default:
		582	assert(0);
		583	}
		584	break;
		585
		586	case ir_unop_logic_not:
		587	assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
		588	for (unsigned c = 0; c < op[0]->type->components(); c++)
		589	data.b[c] = !op[0]->value.b[c];
		590	break;
		591
		592	case ir_unop_f2i:
		593	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		594	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		595	data.i[c] = (int) op[0]->value.f[c];
		596	}
		597	break;
		598	case ir_unop_f2u:
		599	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		600	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		601	data.i[c] = (unsigned) op[0]->value.f[c];
		602	}
		603	break;
		604	case ir_unop_i2f:
		605	assert(op[0]->type->base_type == GLSL_TYPE_INT);
		606	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		607	data.f[c] = (float) op[0]->value.i[c];
		608	}
		609	break;
		610	case ir_unop_u2f:
		611	assert(op[0]->type->base_type == GLSL_TYPE_UINT);
		612	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		613	data.f[c] = (float) op[0]->value.u[c];
		614	}
		615	break;
		616	case ir_unop_b2f:
		617	assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
		618	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		619	data.f[c] = op[0]->value.b[c] ? 1.0F : 0.0F;
		620	}
		621	break;
		622	case ir_unop_f2b:
		623	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		624	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		625	data.b[c] = op[0]->value.f[c] != 0.0F ? true : false;
		626	}
		627	break;
		628	case ir_unop_b2i:
		629	assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
		630	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		631	data.u[c] = op[0]->value.b[c] ? 1 : 0;
		632	}
		633	break;
		634	case ir_unop_i2b:
		635	assert(op[0]->type->is_integer());
		636	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		637	data.b[c] = op[0]->value.u[c] ? true : false;
		638	}
		639	break;
		640	case ir_unop_u2i:
		641	assert(op[0]->type->base_type == GLSL_TYPE_UINT);
		642	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		643	data.i[c] = op[0]->value.u[c];
		644	}
		645	break;
		646	case ir_unop_i2u:
		647	assert(op[0]->type->base_type == GLSL_TYPE_INT);
		648	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		649	data.u[c] = op[0]->value.i[c];
		650	}
		651	break;
		652	case ir_unop_bitcast_i2f:
		653	assert(op[0]->type->base_type == GLSL_TYPE_INT);
		654	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		655	data.f[c] = bitcast_u2f(op[0]->value.i[c]);
		656	}
		657	break;
		658	case ir_unop_bitcast_f2i:
		659	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		660	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		661	data.i[c] = bitcast_f2u(op[0]->value.f[c]);
		662	}
		663	break;
		664	case ir_unop_bitcast_u2f:
		665	assert(op[0]->type->base_type == GLSL_TYPE_UINT);
		666	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		667	data.f[c] = bitcast_u2f(op[0]->value.u[c]);
		668	}
		669	break;
		670	case ir_unop_bitcast_f2u:
		671	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		672	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		673	data.u[c] = bitcast_f2u(op[0]->value.f[c]);
		674	}
		675	break;
		676	case ir_unop_any:
		677	assert(op[0]->type->is_boolean());
		678	data.b[0] = false;
		679	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		680	if (op[0]->value.b[c])
		681	data.b[0] = true;
		682	}
		683	break;
		684	case ir_unop_d2f:
		685	assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
		686	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		687	data.f[c] = op[0]->value.d[c];
		688	}
		689	break;
		690	case ir_unop_f2d:
		691	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		692	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		693	data.d[c] = op[0]->value.f[c];
		694	}
		695	break;
		696	case ir_unop_d2i:
		697	assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
		698	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		699	data.i[c] = op[0]->value.d[c];
		700	}
		701	break;
		702	case ir_unop_i2d:
		703	assert(op[0]->type->base_type == GLSL_TYPE_INT);
		704	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		705	data.d[c] = op[0]->value.i[c];
		706	}
		707	break;
		708	case ir_unop_d2u:
		709	assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
		710	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		711	data.u[c] = op[0]->value.d[c];
		712	}
		713	break;
		714	case ir_unop_u2d:
		715	assert(op[0]->type->base_type == GLSL_TYPE_UINT);
		716	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		717	data.d[c] = op[0]->value.u[c];
		718	}
		719	break;
		720	case ir_unop_d2b:
		721	assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
		722	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		723	data.b[c] = op[0]->value.d[c] != 0.0;
		724	}
		725	break;
		726	case ir_unop_trunc:
		727	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		728	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		729	data.d[c] = trunc(op[0]->value.d[c]);
		730	else
		731	data.f[c] = truncf(op[0]->value.f[c]);
		732	}
		733	break;
		734
		735	case ir_unop_round_even:
		736	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		737	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		738	data.d[c] = _mesa_roundeven(op[0]->value.d[c]);
		739	else
		740	data.f[c] = _mesa_roundevenf(op[0]->value.f[c]);
		741	}
		742	break;
		743
		744	case ir_unop_ceil:
		745	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		746	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		747	data.d[c] = ceil(op[0]->value.d[c]);
		748	else
		749	data.f[c] = ceilf(op[0]->value.f[c]);
		750	}
		751	break;
		752
		753	case ir_unop_floor:
		754	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		755	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		756	data.d[c] = floor(op[0]->value.d[c]);
		757	else
		758	data.f[c] = floorf(op[0]->value.f[c]);
		759	}
		760	break;
		761
		762	case ir_unop_fract:
		763	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		764	switch (this->type->base_type) {
		765	case GLSL_TYPE_UINT:
		766	data.u[c] = 0;
		767	break;
		768	case GLSL_TYPE_INT:
		769	data.i[c] = 0;
		770	break;
		771	case GLSL_TYPE_FLOAT:
		772	data.f[c] = op[0]->value.f[c] - floor(op[0]->value.f[c]);
		773	break;
		774	case GLSL_TYPE_DOUBLE:
		775	data.d[c] = op[0]->value.d[c] - floor(op[0]->value.d[c]);
		776	break;
		777	default:
		778	assert(0);
		779	}
		780	}
		781	break;
		782
		783	case ir_unop_sin:
		784	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		785	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		786	data.f[c] = sinf(op[0]->value.f[c]);
		787	}
		788	break;
		789
		790	case ir_unop_cos:
		791	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		792	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		793	data.f[c] = cosf(op[0]->value.f[c]);
		794	}
		795	break;
		796
		797	case ir_unop_neg:
		798	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		799	switch (this->type->base_type) {
		800	case GLSL_TYPE_UINT:
		801	data.u[c] = -((int) op[0]->value.u[c]);
		802	break;
		803	case GLSL_TYPE_INT:
		804	data.i[c] = -op[0]->value.i[c];
		805	break;
		806	case GLSL_TYPE_FLOAT:
		807	data.f[c] = -op[0]->value.f[c];
		808	break;
		809	case GLSL_TYPE_DOUBLE:
		810	data.d[c] = -op[0]->value.d[c];
		811	break;
		812	default:
		813	assert(0);
		814	}
		815	}
		816	break;
		817
		818	case ir_unop_abs:
		819	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		820	switch (this->type->base_type) {
		821	case GLSL_TYPE_UINT:
		822	data.u[c] = op[0]->value.u[c];
		823	break;
		824	case GLSL_TYPE_INT:
		825	data.i[c] = op[0]->value.i[c];
		826	if (data.i[c] < 0)
		827	data.i[c] = -data.i[c];
		828	break;
		829	case GLSL_TYPE_FLOAT:
		830	data.f[c] = fabs(op[0]->value.f[c]);
		831	break;
		832	case GLSL_TYPE_DOUBLE:
		833	data.d[c] = fabs(op[0]->value.d[c]);
		834	break;
		835	default:
		836	assert(0);
		837	}
		838	}
		839	break;
		840
		841	case ir_unop_sign:
		842	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		843	switch (this->type->base_type) {
		844	case GLSL_TYPE_UINT:
		845	data.u[c] = op[0]->value.i[c] > 0;
		846	break;
		847	case GLSL_TYPE_INT:
		848	data.i[c] = (op[0]->value.i[c] > 0) - (op[0]->value.i[c] < 0);
		849	break;
		850	case GLSL_TYPE_FLOAT:
		851	data.f[c] = float((op[0]->value.f[c] > 0)-(op[0]->value.f[c] < 0));
		852	break;
		853	case GLSL_TYPE_DOUBLE:
		854	data.d[c] = double((op[0]->value.d[c] > 0)-(op[0]->value.d[c] < 0));
		855	break;
		856	default:
		857	assert(0);
		858	}
		859	}
		860	break;
		861
		862	case ir_unop_rcp:
		863	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		864	switch (this->type->base_type) {
		865	case GLSL_TYPE_UINT:
		866	if (op[0]->value.u[c] != 0.0)
		867	data.u[c] = 1 / op[0]->value.u[c];
		868	break;
		869	case GLSL_TYPE_INT:
		870	if (op[0]->value.i[c] != 0.0)
		871	data.i[c] = 1 / op[0]->value.i[c];
		872	break;
		873	case GLSL_TYPE_FLOAT:
		874	if (op[0]->value.f[c] != 0.0)
		875	data.f[c] = 1.0F / op[0]->value.f[c];
		876	break;
		877	case GLSL_TYPE_DOUBLE:
		878	if (op[0]->value.d[c] != 0.0)
		879	data.d[c] = 1.0 / op[0]->value.d[c];
		880	break;
		881	default:
		882	assert(0);
		883	}
		884	}
		885	break;
		886
		887	case ir_unop_rsq:
		888	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		889	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		890	data.d[c] = 1.0 / sqrt(op[0]->value.d[c]);
		891	else
		892	data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]);
		893	}
		894	break;
		895
		896	case ir_unop_sqrt:
		897	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		898	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		899	data.d[c] = sqrt(op[0]->value.d[c]);
		900	else
		901	data.f[c] = sqrtf(op[0]->value.f[c]);
		902	}
		903	break;
		904
		905	case ir_unop_exp:
		906	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		907	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		908	data.f[c] = expf(op[0]->value.f[c]);
		909	}
		910	break;
		911
		912	case ir_unop_exp2:
		913	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		914	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		915	data.f[c] = exp2f(op[0]->value.f[c]);
		916	}
		917	break;
		918
		919	case ir_unop_log:
		920	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		921	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		922	data.f[c] = logf(op[0]->value.f[c]);
		923	}
		924	break;
		925
		926	case ir_unop_log2:
		927	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		928	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		929	data.f[c] = log2f(op[0]->value.f[c]);
		930	}
		931	break;
		932
		933	case ir_unop_dFdx:
		934	case ir_unop_dFdx_coarse:
		935	case ir_unop_dFdx_fine:
		936	case ir_unop_dFdy:
		937	case ir_unop_dFdy_coarse:
		938	case ir_unop_dFdy_fine:
		939	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		940	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		941	data.f[c] = 0.0;
		942	}
		943	break;
		944
		945	case ir_unop_pack_snorm_2x16:
		946	assert(op[0]->type == glsl_type::vec2_type);
		947	data.u[0] = pack_2x16(pack_snorm_1x16,
		948	op[0]->value.f[0],
		949	op[0]->value.f[1]);
		950	break;
		951	case ir_unop_pack_snorm_4x8:
		952	assert(op[0]->type == glsl_type::vec4_type);
		953	data.u[0] = pack_4x8(pack_snorm_1x8,
		954	op[0]->value.f[0],
		955	op[0]->value.f[1],
		956	op[0]->value.f[2],
		957	op[0]->value.f[3]);
		958	break;
		959	case ir_unop_unpack_snorm_2x16:
		960	assert(op[0]->type == glsl_type::uint_type);
		961	unpack_2x16(unpack_snorm_1x16,
		962	op[0]->value.u[0],
		963	&data.f[0], &data.f[1]);
		964	break;
		965	case ir_unop_unpack_snorm_4x8:
		966	assert(op[0]->type == glsl_type::uint_type);
		967	unpack_4x8(unpack_snorm_1x8,
		968	op[0]->value.u[0],
		969	&data.f[0], &data.f[1], &data.f[2], &data.f[3]);
		970	break;
		971	case ir_unop_pack_unorm_2x16:
		972	assert(op[0]->type == glsl_type::vec2_type);
		973	data.u[0] = pack_2x16(pack_unorm_1x16,
		974	op[0]->value.f[0],
		975	op[0]->value.f[1]);
		976	break;
		977	case ir_unop_pack_unorm_4x8:
		978	assert(op[0]->type == glsl_type::vec4_type);
		979	data.u[0] = pack_4x8(pack_unorm_1x8,
		980	op[0]->value.f[0],
		981	op[0]->value.f[1],
		982	op[0]->value.f[2],
		983	op[0]->value.f[3]);
		984	break;
		985	case ir_unop_unpack_unorm_2x16:
		986	assert(op[0]->type == glsl_type::uint_type);
		987	unpack_2x16(unpack_unorm_1x16,
		988	op[0]->value.u[0],
		989	&data.f[0], &data.f[1]);
		990	break;
		991	case ir_unop_unpack_unorm_4x8:
		992	assert(op[0]->type == glsl_type::uint_type);
		993	unpack_4x8(unpack_unorm_1x8,
		994	op[0]->value.u[0],
		995	&data.f[0], &data.f[1], &data.f[2], &data.f[3]);
		996	break;
		997	case ir_unop_pack_half_2x16:
		998	assert(op[0]->type == glsl_type::vec2_type);
		999	data.u[0] = pack_2x16(pack_half_1x16,
		1000	op[0]->value.f[0],
		1001	op[0]->value.f[1]);
		1002	break;
		1003	case ir_unop_unpack_half_2x16:
		1004	assert(op[0]->type == glsl_type::uint_type);
		1005	unpack_2x16(unpack_half_1x16,
		1006	op[0]->value.u[0],
		1007	&data.f[0], &data.f[1]);
		1008	break;
		1009	case ir_binop_pow:
		1010	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
		1011	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		1012	data.f[c] = powf(op[0]->value.f[c], op[1]->value.f[c]);
		1013	}
		1014	break;
		1015
		1016	case ir_binop_dot:
		1017	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		1018	data.d[0] = dot_d(op[0], op[1]);
		1019	else
		1020	data.f[0] = dot_f(op[0], op[1]);
		1021	break;
		1022
		1023	case ir_binop_min:
		1024	assert(op[0]->type == op[1]->type \|\| op0_scalar \|\| op1_scalar);
		1025	for (unsigned c = 0, c0 = 0, c1 = 0;
		1026	c < components;
		1027	c0 += c0_inc, c1 += c1_inc, c++) {
		1028
		1029	switch (op[0]->type->base_type) {
		1030	case GLSL_TYPE_UINT:
		1031	data.u[c] = MIN2(op[0]->value.u[c0], op[1]->value.u[c1]);
		1032	break;
		1033	case GLSL_TYPE_INT:
		1034	data.i[c] = MIN2(op[0]->value.i[c0], op[1]->value.i[c1]);
		1035	break;
		1036	case GLSL_TYPE_FLOAT:
		1037	data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]);
		1038	break;
		1039	case GLSL_TYPE_DOUBLE:
		1040	data.d[c] = MIN2(op[0]->value.d[c0], op[1]->value.d[c1]);
		1041	break;
		1042	default:
		1043	assert(0);
		1044	}
		1045	}
		1046
		1047	break;
		1048	case ir_binop_max:
		1049	assert(op[0]->type == op[1]->type \|\| op0_scalar \|\| op1_scalar);
		1050	for (unsigned c = 0, c0 = 0, c1 = 0;
		1051	c < components;
		1052	c0 += c0_inc, c1 += c1_inc, c++) {
		1053
		1054	switch (op[0]->type->base_type) {
		1055	case GLSL_TYPE_UINT:
		1056	data.u[c] = MAX2(op[0]->value.u[c0], op[1]->value.u[c1]);
		1057	break;
		1058	case GLSL_TYPE_INT:
		1059	data.i[c] = MAX2(op[0]->value.i[c0], op[1]->value.i[c1]);
		1060	break;
		1061	case GLSL_TYPE_FLOAT:
		1062	data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]);
		1063	break;
		1064	case GLSL_TYPE_DOUBLE:
		1065	data.d[c] = MAX2(op[0]->value.d[c0], op[1]->value.d[c1]);
		1066	break;
		1067	default:
		1068	assert(0);
		1069	}
		1070	}
		1071	break;
		1072
		1073	case ir_binop_add:
		1074	assert(op[0]->type == op[1]->type \|\| op0_scalar \|\| op1_scalar);
		1075	for (unsigned c = 0, c0 = 0, c1 = 0;
		1076	c < components;
		1077	c0 += c0_inc, c1 += c1_inc, c++) {
		1078
		1079	switch (op[0]->type->base_type) {
		1080	case GLSL_TYPE_UINT:
		1081	data.u[c] = op[0]->value.u[c0] + op[1]->value.u[c1];
		1082	break;
		1083	case GLSL_TYPE_INT:
		1084	data.i[c] = op[0]->value.i[c0] + op[1]->value.i[c1];
		1085	break;
		1086	case GLSL_TYPE_FLOAT:
		1087	data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1];
		1088	break;
		1089	case GLSL_TYPE_DOUBLE:
		1090	data.d[c] = op[0]->value.d[c0] + op[1]->value.d[c1];
		1091	break;
		1092	default:
		1093	assert(0);
		1094	}
		1095	}
		1096
		1097	break;
		1098	case ir_binop_sub:
		1099	assert(op[0]->type == op[1]->type \|\| op0_scalar \|\| op1_scalar);
		1100	for (unsigned c = 0, c0 = 0, c1 = 0;
		1101	c < components;
		1102	c0 += c0_inc, c1 += c1_inc, c++) {
		1103
		1104	switch (op[0]->type->base_type) {
		1105	case GLSL_TYPE_UINT:
		1106	data.u[c] = op[0]->value.u[c0] - op[1]->value.u[c1];
		1107	break;
		1108	case GLSL_TYPE_INT:
		1109	data.i[c] = op[0]->value.i[c0] - op[1]->value.i[c1];
		1110	break;
		1111	case GLSL_TYPE_FLOAT:
		1112	data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1];
		1113	break;
		1114	case GLSL_TYPE_DOUBLE:
		1115	data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1];
		1116	break;
		1117	default:
		1118	assert(0);
		1119	}
		1120	}
		1121
		1122	break;
		1123	case ir_binop_mul:
		1124	/* Check for equal types, or unequal types involving scalars */
		1125	if ((op[0]->type == op[1]->type && !op[0]->type->is_matrix())
		1126	\|\| op0_scalar \|\| op1_scalar) {
		1127	for (unsigned c = 0, c0 = 0, c1 = 0;
		1128	c < components;
		1129	c0 += c0_inc, c1 += c1_inc, c++) {
		1130
		1131	switch (op[0]->type->base_type) {
		1132	case GLSL_TYPE_UINT:
		1133	data.u[c] = op[0]->value.u[c0] * op[1]->value.u[c1];
		1134	break;
		1135	case GLSL_TYPE_INT:
		1136	data.i[c] = op[0]->value.i[c0] * op[1]->value.i[c1];
		1137	break;
		1138	case GLSL_TYPE_FLOAT:
		1139	data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1];
		1140	break;
		1141	case GLSL_TYPE_DOUBLE:
		1142	data.d[c] = op[0]->value.d[c0] * op[1]->value.d[c1];
		1143	break;
		1144	default:
		1145	assert(0);
		1146	}
		1147	}
		1148	} else {
		1149	assert(op[0]->type->is_matrix() \|\| op[1]->type->is_matrix());
		1150
		1151	/* Multiply an N-by-M matrix with an M-by-P matrix. Since either
		1152	* matrix can be a GLSL vector, either N or P can be 1.
		1153	*
		1154	* For vec*mat, the vector is treated as a row vector. This
		1155	* means the vector is a 1-row x M-column matrix.
		1156	*
		1157	* For mat*vec, the vector is treated as a column vector. Since
		1158	* matrix_columns is 1 for vectors, this just works.
		1159	*/
		1160	const unsigned n = op[0]->type->is_vector()
		1161	? 1 : op[0]->type->vector_elements;
		1162	const unsigned m = op[1]->type->vector_elements;
		1163	const unsigned p = op[1]->type->matrix_columns;
		1164	for (unsigned j = 0; j < p; j++) {
		1165	for (unsigned i = 0; i < n; i++) {
		1166	for (unsigned k = 0; k < m; k++) {
		1167	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		1168	data.d[i+nj] += op[0]->value.d[i+nk]op[1]->value.d[k+mj];
		1169	else
		1170	data.f[i+nj] += op[0]->value.f[i+nk]op[1]->value.f[k+mj];
		1171	}
		1172	}
		1173	}
		1174	}
		1175
		1176	break;
		1177	case ir_binop_div:
		1178	/* FINISHME: Emit warning when division-by-zero is detected. */
		1179	assert(op[0]->type == op[1]->type \|\| op0_scalar \|\| op1_scalar);
		1180	for (unsigned c = 0, c0 = 0, c1 = 0;
		1181	c < components;
		1182	c0 += c0_inc, c1 += c1_inc, c++) {
		1183
		1184	switch (op[0]->type->base_type) {
		1185	case GLSL_TYPE_UINT:
		1186	if (op[1]->value.u[c1] == 0) {
		1187	data.u[c] = 0;
		1188	} else {
		1189	data.u[c] = op[0]->value.u[c0] / op[1]->value.u[c1];
		1190	}
		1191	break;
		1192	case GLSL_TYPE_INT:
		1193	if (op[1]->value.i[c1] == 0) {
		1194	data.i[c] = 0;
		1195	} else {
		1196	data.i[c] = op[0]->value.i[c0] / op[1]->value.i[c1];
		1197	}
		1198	break;
		1199	case GLSL_TYPE_FLOAT:
		1200	data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1];
		1201	break;
		1202	case GLSL_TYPE_DOUBLE:
		1203	data.d[c] = op[0]->value.d[c0] / op[1]->value.d[c1];
		1204	break;
		1205	default:
		1206	assert(0);
		1207	}
		1208	}
		1209
		1210	break;
		1211	case ir_binop_mod:
		1212	/* FINISHME: Emit warning when division-by-zero is detected. */
		1213	assert(op[0]->type == op[1]->type \|\| op0_scalar \|\| op1_scalar);
		1214	for (unsigned c = 0, c0 = 0, c1 = 0;
		1215	c < components;
		1216	c0 += c0_inc, c1 += c1_inc, c++) {
		1217
		1218	switch (op[0]->type->base_type) {
		1219	case GLSL_TYPE_UINT:
		1220	if (op[1]->value.u[c1] == 0) {
		1221	data.u[c] = 0;
		1222	} else {
		1223	data.u[c] = op[0]->value.u[c0] % op[1]->value.u[c1];
		1224	}
		1225	break;
		1226	case GLSL_TYPE_INT:
		1227	if (op[1]->value.i[c1] == 0) {
		1228	data.i[c] = 0;
		1229	} else {
		1230	data.i[c] = op[0]->value.i[c0] % op[1]->value.i[c1];
		1231	}
		1232	break;
		1233	case GLSL_TYPE_FLOAT:
		1234	/* We don't use fmod because it rounds toward zero; GLSL specifies
		1235	* the use of floor.
		1236	*/
		1237	data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1]
		1238	* floorf(op[0]->value.f[c0] / op[1]->value.f[c1]);
		1239	break;
		1240	case GLSL_TYPE_DOUBLE:
		1241	/* We don't use fmod because it rounds toward zero; GLSL specifies
		1242	* the use of floor.
		1243	*/
		1244	data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1]
		1245	* floor(op[0]->value.d[c0] / op[1]->value.d[c1]);
		1246	break;
		1247	default:
		1248	assert(0);
		1249	}
		1250	}
		1251
		1252	break;
		1253
		1254	case ir_binop_logic_and:
		1255	assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
		1256	for (unsigned c = 0; c < op[0]->type->components(); c++)
		1257	data.b[c] = op[0]->value.b[c] && op[1]->value.b[c];
		1258	break;
		1259	case ir_binop_logic_xor:
		1260	assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
		1261	for (unsigned c = 0; c < op[0]->type->components(); c++)
		1262	data.b[c] = op[0]->value.b[c] ^ op[1]->value.b[c];
		1263	break;
		1264	case ir_binop_logic_or:
		1265	assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
		1266	for (unsigned c = 0; c < op[0]->type->components(); c++)
		1267	data.b[c] = op[0]->value.b[c] \|\| op[1]->value.b[c];
		1268	break;
		1269
		1270	case ir_binop_less:
		1271	assert(op[0]->type == op[1]->type);
		1272	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		1273	switch (op[0]->type->base_type) {
		1274	case GLSL_TYPE_UINT:
		1275	data.b[c] = op[0]->value.u[c] < op[1]->value.u[c];
		1276	break;
		1277	case GLSL_TYPE_INT:
		1278	data.b[c] = op[0]->value.i[c] < op[1]->value.i[c];
		1279	break;
		1280	case GLSL_TYPE_FLOAT:
		1281	data.b[c] = op[0]->value.f[c] < op[1]->value.f[c];
		1282	break;
		1283	case GLSL_TYPE_DOUBLE:
		1284	data.b[c] = op[0]->value.d[c] < op[1]->value.d[c];
		1285	break;
		1286	default:
		1287	assert(0);
		1288	}
		1289	}
		1290	break;
		1291	case ir_binop_greater:
		1292	assert(op[0]->type == op[1]->type);
		1293	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		1294	switch (op[0]->type->base_type) {
		1295	case GLSL_TYPE_UINT:
		1296	data.b[c] = op[0]->value.u[c] > op[1]->value.u[c];
		1297	break;
		1298	case GLSL_TYPE_INT:
		1299	data.b[c] = op[0]->value.i[c] > op[1]->value.i[c];
		1300	break;
		1301	case GLSL_TYPE_FLOAT:
		1302	data.b[c] = op[0]->value.f[c] > op[1]->value.f[c];
		1303	break;
		1304	case GLSL_TYPE_DOUBLE:
		1305	data.b[c] = op[0]->value.d[c] > op[1]->value.d[c];
		1306	break;
		1307	default:
		1308	assert(0);
		1309	}
		1310	}
		1311	break;
		1312	case ir_binop_lequal:
		1313	assert(op[0]->type == op[1]->type);
		1314	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		1315	switch (op[0]->type->base_type) {
		1316	case GLSL_TYPE_UINT:
		1317	data.b[c] = op[0]->value.u[c] <= op[1]->value.u[c];
		1318	break;
		1319	case GLSL_TYPE_INT:
		1320	data.b[c] = op[0]->value.i[c] <= op[1]->value.i[c];
		1321	break;
		1322	case GLSL_TYPE_FLOAT:
		1323	data.b[c] = op[0]->value.f[c] <= op[1]->value.f[c];
		1324	break;
		1325	case GLSL_TYPE_DOUBLE:
		1326	data.b[c] = op[0]->value.d[c] <= op[1]->value.d[c];
		1327	break;
		1328	default:
		1329	assert(0);
		1330	}
		1331	}
		1332	break;
		1333	case ir_binop_gequal:
		1334	assert(op[0]->type == op[1]->type);
		1335	for (unsigned c = 0; c < op[0]->type->components(); c++) {
		1336	switch (op[0]->type->base_type) {
		1337	case GLSL_TYPE_UINT:
		1338	data.b[c] = op[0]->value.u[c] >= op[1]->value.u[c];
		1339	break;
		1340	case GLSL_TYPE_INT:
		1341	data.b[c] = op[0]->value.i[c] >= op[1]->value.i[c];
		1342	break;
		1343	case GLSL_TYPE_FLOAT:
		1344	data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c];
		1345	break;
		1346	case GLSL_TYPE_DOUBLE:
		1347	data.b[c] = op[0]->value.d[c] >= op[1]->value.d[c];
		1348	break;
		1349	default:
		1350	assert(0);
		1351	}
		1352	}
		1353	break;
		1354	case ir_binop_equal:
		1355	assert(op[0]->type == op[1]->type);
		1356	for (unsigned c = 0; c < components; c++) {
		1357	switch (op[0]->type->base_type) {
		1358	case GLSL_TYPE_UINT:
		1359	data.b[c] = op[0]->value.u[c] == op[1]->value.u[c];
		1360	break;
		1361	case GLSL_TYPE_INT:
		1362	data.b[c] = op[0]->value.i[c] == op[1]->value.i[c];
		1363	break;
		1364	case GLSL_TYPE_FLOAT:
		1365	data.b[c] = op[0]->value.f[c] == op[1]->value.f[c];
		1366	break;
		1367	case GLSL_TYPE_BOOL:
		1368	data.b[c] = op[0]->value.b[c] == op[1]->value.b[c];
		1369	break;
		1370	case GLSL_TYPE_DOUBLE:
		1371	data.b[c] = op[0]->value.d[c] == op[1]->value.d[c];
		1372	break;
		1373	default:
		1374	assert(0);
		1375	}
		1376	}
		1377	break;
		1378	case ir_binop_nequal:
		1379	assert(op[0]->type == op[1]->type);
		1380	for (unsigned c = 0; c < components; c++) {
		1381	switch (op[0]->type->base_type) {
		1382	case GLSL_TYPE_UINT:
		1383	data.b[c] = op[0]->value.u[c] != op[1]->value.u[c];
		1384	break;
		1385	case GLSL_TYPE_INT:
		1386	data.b[c] = op[0]->value.i[c] != op[1]->value.i[c];
		1387	break;
		1388	case GLSL_TYPE_FLOAT:
		1389	data.b[c] = op[0]->value.f[c] != op[1]->value.f[c];
		1390	break;
		1391	case GLSL_TYPE_BOOL:
		1392	data.b[c] = op[0]->value.b[c] != op[1]->value.b[c];
		1393	break;
		1394	case GLSL_TYPE_DOUBLE:
		1395	data.b[c] = op[0]->value.d[c] != op[1]->value.d[c];
		1396	break;
		1397	default:
		1398	assert(0);
		1399	}
		1400	}
		1401	break;
		1402	case ir_binop_all_equal:
		1403	data.b[0] = op[0]->has_value(op[1]);
		1404	break;
		1405	case ir_binop_any_nequal:
		1406	data.b[0] = !op[0]->has_value(op[1]);
		1407	break;
		1408
		1409	case ir_binop_lshift:
		1410	for (unsigned c = 0, c0 = 0, c1 = 0;
		1411	c < components;
		1412	c0 += c0_inc, c1 += c1_inc, c++) {
		1413
		1414	if (op[0]->type->base_type == GLSL_TYPE_INT &&
		1415	op[1]->type->base_type == GLSL_TYPE_INT) {
		1416	data.i[c] = op[0]->value.i[c0] << op[1]->value.i[c1];
		1417
		1418	} else if (op[0]->type->base_type == GLSL_TYPE_INT &&
		1419	op[1]->type->base_type == GLSL_TYPE_UINT) {
		1420	data.i[c] = op[0]->value.i[c0] << op[1]->value.u[c1];
		1421
		1422	} else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
		1423	op[1]->type->base_type == GLSL_TYPE_INT) {
		1424	data.u[c] = op[0]->value.u[c0] << op[1]->value.i[c1];
		1425
		1426	} else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
		1427	op[1]->type->base_type == GLSL_TYPE_UINT) {
		1428	data.u[c] = op[0]->value.u[c0] << op[1]->value.u[c1];
		1429	}
		1430	}
		1431	break;
		1432
		1433	case ir_binop_rshift:
		1434	for (unsigned c = 0, c0 = 0, c1 = 0;
		1435	c < components;
		1436	c0 += c0_inc, c1 += c1_inc, c++) {
		1437
		1438	if (op[0]->type->base_type == GLSL_TYPE_INT &&
		1439	op[1]->type->base_type == GLSL_TYPE_INT) {
		1440	data.i[c] = op[0]->value.i[c0] >> op[1]->value.i[c1];
		1441
		1442	} else if (op[0]->type->base_type == GLSL_TYPE_INT &&
		1443	op[1]->type->base_type == GLSL_TYPE_UINT) {
		1444	data.i[c] = op[0]->value.i[c0] >> op[1]->value.u[c1];
		1445
		1446	} else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
		1447	op[1]->type->base_type == GLSL_TYPE_INT) {
		1448	data.u[c] = op[0]->value.u[c0] >> op[1]->value.i[c1];
		1449
		1450	} else if (op[0]->type->base_type == GLSL_TYPE_UINT &&
		1451	op[1]->type->base_type == GLSL_TYPE_UINT) {
		1452	data.u[c] = op[0]->value.u[c0] >> op[1]->value.u[c1];
		1453	}
		1454	}
		1455	break;
		1456
		1457	case ir_binop_bit_and:
		1458	for (unsigned c = 0, c0 = 0, c1 = 0;
		1459	c < components;
		1460	c0 += c0_inc, c1 += c1_inc, c++) {
		1461
		1462	switch (op[0]->type->base_type) {
		1463	case GLSL_TYPE_INT:
		1464	data.i[c] = op[0]->value.i[c0] & op[1]->value.i[c1];
		1465	break;
		1466	case GLSL_TYPE_UINT:
		1467	data.u[c] = op[0]->value.u[c0] & op[1]->value.u[c1];
		1468	break;
		1469	default:
		1470	assert(0);
		1471	}
		1472	}
		1473	break;
		1474
		1475	case ir_binop_bit_or:
		1476	for (unsigned c = 0, c0 = 0, c1 = 0;
		1477	c < components;
		1478	c0 += c0_inc, c1 += c1_inc, c++) {
		1479
		1480	switch (op[0]->type->base_type) {
		1481	case GLSL_TYPE_INT:
		1482	data.i[c] = op[0]->value.i[c0] \| op[1]->value.i[c1];
		1483	break;
		1484	case GLSL_TYPE_UINT:
		1485	data.u[c] = op[0]->value.u[c0] \| op[1]->value.u[c1];
		1486	break;
		1487	default:
		1488	assert(0);
		1489	}
		1490	}
		1491	break;
		1492
		1493	case ir_binop_vector_extract: {
		1494	const int c = CLAMP(op[1]->value.i[0], 0,
		1495	(int) op[0]->type->vector_elements - 1);
		1496
		1497	switch (op[0]->type->base_type) {
		1498	case GLSL_TYPE_UINT:
		1499	data.u[0] = op[0]->value.u[c];
		1500	break;
		1501	case GLSL_TYPE_INT:
		1502	data.i[0] = op[0]->value.i[c];
		1503	break;
		1504	case GLSL_TYPE_FLOAT:
		1505	data.f[0] = op[0]->value.f[c];
		1506	break;
		1507	case GLSL_TYPE_DOUBLE:
		1508	data.d[0] = op[0]->value.d[c];
		1509	break;
		1510	case GLSL_TYPE_BOOL:
		1511	data.b[0] = op[0]->value.b[c];
		1512	break;
		1513	default:
		1514	assert(0);
		1515	}
		1516	break;
		1517	}
		1518
		1519	case ir_binop_bit_xor:
		1520	for (unsigned c = 0, c0 = 0, c1 = 0;
		1521	c < components;
		1522	c0 += c0_inc, c1 += c1_inc, c++) {
		1523
		1524	switch (op[0]->type->base_type) {
		1525	case GLSL_TYPE_INT:
		1526	data.i[c] = op[0]->value.i[c0] ^ op[1]->value.i[c1];
		1527	break;
		1528	case GLSL_TYPE_UINT:
		1529	data.u[c] = op[0]->value.u[c0] ^ op[1]->value.u[c1];
		1530	break;
		1531	default:
		1532	assert(0);
		1533	}
		1534	}
		1535	break;
		1536
		1537	case ir_unop_bitfield_reverse:
		1538	/* http://graphics.stanford.edu/~seander/bithacks.html#BitReverseObvious */
		1539	for (unsigned c = 0; c < components; c++) {
		1540	unsigned int v = op[0]->value.u[c]; // input bits to be reversed
		1541	unsigned int r = v; // r will be reversed bits of v; first get LSB of v
		1542	int s = sizeof(v) * CHAR_BIT - 1; // extra shift needed at end
		1543
		1544	for (v >>= 1; v; v >>= 1) {
		1545	r <<= 1;
		1546	r \|= v & 1;
		1547	s--;
		1548	}
		1549	r <<= s; // shift when v's highest bits are zero
		1550
		1551	data.u[c] = r;
		1552	}
		1553	break;
		1554
		1555	case ir_unop_bit_count:
		1556	for (unsigned c = 0; c < components; c++) {
		1557	unsigned count = 0;
		1558	unsigned v = op[0]->value.u[c];
		1559
		1560	for (; v; count++) {
		1561	v &= v - 1;
		1562	}
		1563	data.u[c] = count;
		1564	}
		1565	break;
		1566
		1567	case ir_unop_find_msb:
		1568	for (unsigned c = 0; c < components; c++) {
		1569	int v = op[0]->value.i[c];
		1570
		1571	if (v == 0 \|\| (op[0]->type->base_type == GLSL_TYPE_INT && v == -1))
		1572	data.i[c] = -1;
		1573	else {
		1574	int count = 0;
		1575	int top_bit = op[0]->type->base_type == GLSL_TYPE_UINT
		1576	? 0 : v & (1 << 31);
		1577
		1578	while (((v & (1 << 31)) == top_bit) && count != 32) {
		1579	count++;
		1580	v <<= 1;
		1581	}
		1582
		1583	data.i[c] = 31 - count;
		1584	}
		1585	}
		1586	break;
		1587
		1588	case ir_unop_find_lsb:
		1589	for (unsigned c = 0; c < components; c++) {
		1590	if (op[0]->value.i[c] == 0)
		1591	data.i[c] = -1;
		1592	else {
		1593	unsigned pos = 0;
		1594	unsigned v = op[0]->value.u[c];
		1595
		1596	for (; !(v & 1); v >>= 1) {
		1597	pos++;
		1598	}
		1599	data.u[c] = pos;
		1600	}
		1601	}
		1602	break;
		1603
		1604	case ir_unop_saturate:
		1605	for (unsigned c = 0; c < components; c++) {
		1606	data.f[c] = CLAMP(op[0]->value.f[c], 0.0f, 1.0f);
		1607	}
		1608	break;
		1609	case ir_unop_pack_double_2x32: {
		1610	/* XXX needs to be checked on big-endian */
		1611	uint64_t temp;
		1612	temp = (uint64_t)op[0]->value.u[0] \| ((uint64_t)op[0]->value.u[1] << 32);
		1613	data.d[0] = (double )&temp;
		1614
		1615	break;
		1616	}
		1617	case ir_unop_unpack_double_2x32:
		1618	/* XXX needs to be checked on big-endian */
		1619	data.u[0] = (uint32_t )&op[0]->value.d[0];
		1620	data.u[1] = ((uint32_t )&op[0]->value.d[0] + 1);
		1621	break;
		1622
		1623	case ir_triop_bitfield_extract: {
		1624	int offset = op[1]->value.i[0];
		1625	int bits = op[2]->value.i[0];
		1626
		1627	for (unsigned c = 0; c < components; c++) {
		1628	if (bits == 0)
		1629	data.u[c] = 0;
		1630	else if (offset < 0 \|\| bits < 0)
		1631	data.u[c] = 0; /* Undefined, per spec. */
		1632	else if (offset + bits > 32)
		1633	data.u[c] = 0; /* Undefined, per spec. */
		1634	else {
		1635	if (op[0]->type->base_type == GLSL_TYPE_INT) {
		1636	/* int so that the right shift will sign-extend. */
		1637	int value = op[0]->value.i[c];
		1638	value <<= 32 - bits - offset;
		1639	value >>= 32 - bits;
		1640	data.i[c] = value;
		1641	} else {
		1642	unsigned value = op[0]->value.u[c];
		1643	value <<= 32 - bits - offset;
		1644	value >>= 32 - bits;
		1645	data.u[c] = value;
		1646	}
		1647	}
		1648	}
		1649	break;
		1650	}
		1651
		1652	case ir_binop_bfm: {
		1653	int bits = op[0]->value.i[0];
		1654	int offset = op[1]->value.i[0];
		1655
		1656	for (unsigned c = 0; c < components; c++) {
		1657	if (bits == 0)
		1658	data.u[c] = op[0]->value.u[c];
		1659	else if (offset < 0 \|\| bits < 0)
		1660	data.u[c] = 0; /* Undefined for bitfieldInsert, per spec. */
		1661	else if (offset + bits > 32)
		1662	data.u[c] = 0; /* Undefined for bitfieldInsert, per spec. */
		1663	else
		1664	data.u[c] = ((1 << bits) - 1) << offset;
		1665	}
		1666	break;
		1667	}
		1668
		1669	case ir_binop_ldexp:
		1670	for (unsigned c = 0; c < components; c++) {
		1671	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE) {
		1672	data.d[c] = ldexp(op[0]->value.d[c], op[1]->value.i[c]);
		1673	/* Flush subnormal values to zero. */
		1674	if (!isnormal(data.d[c]))
		1675	data.d[c] = copysign(0.0, op[0]->value.d[c]);
		1676	} else {
		1677	data.f[c] = ldexp(op[0]->value.f[c], op[1]->value.i[c]);
		1678	/* Flush subnormal values to zero. */
		1679	if (!isnormal(data.f[c]))
		1680	data.f[c] = copysign(0.0f, op[0]->value.f[c]);
		1681	}
		1682	}
		1683	break;
		1684
		1685	case ir_triop_fma:
		1686	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT \|\|
		1687	op[0]->type->base_type == GLSL_TYPE_DOUBLE);
		1688	assert(op[1]->type->base_type == GLSL_TYPE_FLOAT \|\|
		1689	op[1]->type->base_type == GLSL_TYPE_DOUBLE);
		1690	assert(op[2]->type->base_type == GLSL_TYPE_FLOAT \|\|
		1691	op[2]->type->base_type == GLSL_TYPE_DOUBLE);
		1692
		1693	for (unsigned c = 0; c < components; c++) {
		1694	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		1695	data.d[c] = op[0]->value.d[c] * op[1]->value.d[c]
		1696	+ op[2]->value.d[c];
		1697	else
		1698	data.f[c] = op[0]->value.f[c] * op[1]->value.f[c]
		1699	+ op[2]->value.f[c];
		1700	}
		1701	break;
		1702
		1703	case ir_triop_lrp: {
		1704	assert(op[0]->type->base_type == GLSL_TYPE_FLOAT \|\|
		1705	op[0]->type->base_type == GLSL_TYPE_DOUBLE);
		1706	assert(op[1]->type->base_type == GLSL_TYPE_FLOAT \|\|
		1707	op[1]->type->base_type == GLSL_TYPE_DOUBLE);
		1708	assert(op[2]->type->base_type == GLSL_TYPE_FLOAT \|\|
		1709	op[2]->type->base_type == GLSL_TYPE_DOUBLE);
		1710
		1711	unsigned c2_inc = op[2]->type->is_scalar() ? 0 : 1;
		1712	for (unsigned c = 0, c2 = 0; c < components; c2 += c2_inc, c++) {
		1713	if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
		1714	data.d[c] = op[0]->value.d[c] * (1.0 - op[2]->value.d[c2]) +
		1715	(op[1]->value.d[c] * op[2]->value.d[c2]);
		1716	else
		1717	data.f[c] = op[0]->value.f[c] * (1.0f - op[2]->value.f[c2]) +
		1718	(op[1]->value.f[c] * op[2]->value.f[c2]);
		1719	}
		1720	break;
		1721	}
		1722
		1723	case ir_triop_csel:
		1724	for (unsigned c = 0; c < components; c++) {
		1725	if (op[1]->type->base_type == GLSL_TYPE_DOUBLE)
		1726	data.d[c] = op[0]->value.b[c] ? op[1]->value.d[c]
		1727	: op[2]->value.d[c];
		1728	else
		1729	data.u[c] = op[0]->value.b[c] ? op[1]->value.u[c]
		1730	: op[2]->value.u[c];
		1731	}
		1732	break;
		1733
		1734	case ir_triop_vector_insert: {
		1735	const unsigned idx = op[2]->value.u[0];
		1736
		1737	memcpy(&data, &op[0]->value, sizeof(data));
		1738
		1739	switch (this->type->base_type) {
		1740	case GLSL_TYPE_INT:
		1741	data.i[idx] = op[1]->value.i[0];
		1742	break;
		1743	case GLSL_TYPE_UINT:
		1744	data.u[idx] = op[1]->value.u[0];
		1745	break;
		1746	case GLSL_TYPE_FLOAT:
		1747	data.f[idx] = op[1]->value.f[0];
		1748	break;
		1749	case GLSL_TYPE_BOOL:
		1750	data.b[idx] = op[1]->value.b[0];
		1751	break;
		1752	case GLSL_TYPE_DOUBLE:
		1753	data.d[idx] = op[1]->value.d[0];
		1754	break;
		1755	default:
		1756	assert(!"Should not get here.");
		1757	break;
		1758	}
		1759	break;
		1760	}
		1761
		1762	case ir_quadop_bitfield_insert: {
		1763	int offset = op[2]->value.i[0];
		1764	int bits = op[3]->value.i[0];
		1765
		1766	for (unsigned c = 0; c < components; c++) {
		1767	if (bits == 0)
		1768	data.u[c] = op[0]->value.u[c];
		1769	else if (offset < 0 \|\| bits < 0)
		1770	data.u[c] = 0; /* Undefined, per spec. */
		1771	else if (offset + bits > 32)
		1772	data.u[c] = 0; /* Undefined, per spec. */
		1773	else {
		1774	unsigned insert_mask = ((1 << bits) - 1) << offset;
		1775
		1776	unsigned insert = op[1]->value.u[c];
		1777	insert <<= offset;
		1778	insert &= insert_mask;
		1779
		1780	unsigned base = op[0]->value.u[c];
		1781	base &= ~insert_mask;
		1782
		1783	data.u[c] = base \| insert;
		1784	}
		1785	}
		1786	break;
		1787	}
		1788
		1789	case ir_quadop_vector:
		1790	for (unsigned c = 0; c < this->type->vector_elements; c++) {
		1791	switch (this->type->base_type) {
		1792	case GLSL_TYPE_INT:
		1793	data.i[c] = op[c]->value.i[0];
		1794	break;
		1795	case GLSL_TYPE_UINT:
		1796	data.u[c] = op[c]->value.u[0];
		1797	break;
		1798	case GLSL_TYPE_FLOAT:
		1799	data.f[c] = op[c]->value.f[0];
		1800	break;
		1801	case GLSL_TYPE_DOUBLE:
		1802	data.d[c] = op[c]->value.d[0];
		1803	break;
		1804	default:
		1805	assert(0);
		1806	}
		1807	}
		1808	break;
		1809
		1810	default:
		1811	/* FINISHME: Should handle all expression types. */
		1812	return NULL;
		1813	}
		1814
		1815	return new(ctx) ir_constant(this->type, &data);
		1816	}
		1817
		1818
		1819	ir_constant *
		1820	ir_texture::constant_expression_value(struct hash_table *)
		1821	{
		1822	/* texture lookups aren't constant expressions */
		1823	return NULL;
		1824	}
		1825
		1826
		1827	ir_constant *
		1828	ir_swizzle::constant_expression_value(struct hash_table *variable_context)
		1829	{
		1830	ir_constant *v = this->val->constant_expression_value(variable_context);
		1831
		1832	if (v != NULL) {
		1833	ir_constant_data data = { { 0 } };
		1834
		1835	const unsigned swiz_idx[4] = {
		1836	this->mask.x, this->mask.y, this->mask.z, this->mask.w
		1837	};
		1838
		1839	for (unsigned i = 0; i < this->mask.num_components; i++) {
		1840	switch (v->type->base_type) {
		1841	case GLSL_TYPE_UINT:
		1842	case GLSL_TYPE_INT: data.u[i] = v->value.u[swiz_idx[i]]; break;
		1843	case GLSL_TYPE_FLOAT: data.f[i] = v->value.f[swiz_idx[i]]; break;
		1844	case GLSL_TYPE_BOOL: data.b[i] = v->value.b[swiz_idx[i]]; break;
		1845	case GLSL_TYPE_DOUBLE:data.d[i] = v->value.d[swiz_idx[i]]; break;
		1846	default: assert(!"Should not get here."); break;
		1847	}
		1848	}
		1849
		1850	void *ctx = ralloc_parent(this);
		1851	return new(ctx) ir_constant(this->type, &data);
		1852	}
		1853	return NULL;
		1854	}
		1855
		1856
		1857	ir_constant *
		1858	ir_dereference_variable::constant_expression_value(struct hash_table *variable_context)
		1859	{
		1860	/* This may occur during compile and var->type is glsl_type::error_type */
		1861	if (!var)
		1862	return NULL;
		1863
		1864	/* Give priority to the context hashtable, if it exists */
		1865	if (variable_context) {
		1866	ir_constant value = (ir_constant )hash_table_find(variable_context, var);
		1867	if(value)
		1868	return value;
		1869	}
		1870
		1871	/* The constant_value of a uniform variable is its initializer,
		1872	* not the lifetime constant value of the uniform.
		1873	*/
		1874	if (var->data.mode == ir_var_uniform)
		1875	return NULL;
		1876
		1877	if (!var->constant_value)
		1878	return NULL;
		1879
		1880	return var->constant_value->clone(ralloc_parent(var), NULL);
		1881	}
		1882
		1883
		1884	ir_constant *
		1885	ir_dereference_array::constant_expression_value(struct hash_table *variable_context)
		1886	{
		1887	ir_constant *array = this->array->constant_expression_value(variable_context);
		1888	ir_constant *idx = this->array_index->constant_expression_value(variable_context);
		1889
		1890	if ((array != NULL) && (idx != NULL)) {
		1891	void *ctx = ralloc_parent(this);
		1892	if (array->type->is_matrix()) {
		1893	/* Array access of a matrix results in a vector.
		1894	*/
		1895	const unsigned column = idx->value.u[0];
		1896
		1897	const glsl_type *const column_type = array->type->column_type();
		1898
		1899	/* Offset in the constant matrix to the first element of the column
		1900	* to be extracted.
		1901	*/
		1902	const unsigned mat_idx = column * column_type->vector_elements;
		1903
		1904	ir_constant_data data = { { 0 } };
		1905
		1906	switch (column_type->base_type) {
		1907	case GLSL_TYPE_UINT:
		1908	case GLSL_TYPE_INT:
		1909	for (unsigned i = 0; i < column_type->vector_elements; i++)
		1910	data.u[i] = array->value.u[mat_idx + i];
		1911
		1912	break;
		1913
		1914	case GLSL_TYPE_FLOAT:
		1915	for (unsigned i = 0; i < column_type->vector_elements; i++)
		1916	data.f[i] = array->value.f[mat_idx + i];
		1917
		1918	break;
		1919
		1920	case GLSL_TYPE_DOUBLE:
		1921	for (unsigned i = 0; i < column_type->vector_elements; i++)
		1922	data.d[i] = array->value.d[mat_idx + i];
		1923
		1924	break;
		1925
		1926	default:
		1927	assert(!"Should not get here.");
		1928	break;
		1929	}
		1930
		1931	return new(ctx) ir_constant(column_type, &data);
		1932	} else if (array->type->is_vector()) {
		1933	const unsigned component = idx->value.u[0];
		1934
		1935	return new(ctx) ir_constant(array, component);
		1936	} else {
		1937	const unsigned index = idx->value.u[0];
		1938	return array->get_array_element(index)->clone(ctx, NULL);
		1939	}
		1940	}
		1941	return NULL;
		1942	}
		1943
		1944
		1945	ir_constant *
		1946	ir_dereference_record::constant_expression_value(struct hash_table *)
		1947	{
		1948	ir_constant *v = this->record->constant_expression_value();
		1949
		1950	return (v != NULL) ? v->get_record_field(this->field) : NULL;
		1951	}
		1952
		1953
		1954	ir_constant *
		1955	ir_assignment::constant_expression_value(struct hash_table *)
		1956	{
		1957	/* FINISHME: Handle CEs involving assignment (return RHS) */
		1958	return NULL;
		1959	}
		1960
		1961
		1962	ir_constant *
		1963	ir_constant::constant_expression_value(struct hash_table *)
		1964	{
		1965	return this;
		1966	}
		1967
		1968
		1969	ir_constant *
		1970	ir_call::constant_expression_value(struct hash_table *variable_context)
		1971	{
		1972	return this->callee->constant_expression_value(&this->actual_parameters, variable_context);
		1973	}
		1974
		1975
		1976	bool ir_function_signature::constant_expression_evaluate_expression_list(const struct exec_list &body,
		1977	struct hash_table *variable_context,
		1978	ir_constant **result)
		1979	{
		1980	foreach_in_list(ir_instruction, inst, &body) {
		1981	switch(inst->ir_type) {
		1982
		1983	/* (declare () type symbol) */
		1984	case ir_type_variable: {
		1985	ir_variable *var = inst->as_variable();
		1986	hash_table_insert(variable_context, ir_constant::zero(this, var->type), var);
		1987	break;
		1988	}
		1989
		1990	/* (assign [condition] (write-mask) (ref) (value)) */
		1991	case ir_type_assignment: {
		1992	ir_assignment *asg = inst->as_assignment();
		1993	if (asg->condition) {
		1994	ir_constant *cond = asg->condition->constant_expression_value(variable_context);
		1995	if (!cond)
		1996	return false;
		1997	if (!cond->get_bool_component(0))
		1998	break;
		1999	}
		2000
		2001	ir_constant *store = NULL;
		2002	int offset = 0;
		2003
		2004	if (!constant_referenced(asg->lhs, variable_context, store, offset))
		2005	return false;
		2006
		2007	ir_constant *value = asg->rhs->constant_expression_value(variable_context);
		2008
		2009	if (!value)
		2010	return false;
		2011
		2012	store->copy_masked_offset(value, offset, asg->write_mask);
		2013	break;
		2014	}
		2015
		2016	/* (return (expression)) */
		2017	case ir_type_return:
		2018	assert (result);
		2019	*result = inst->as_return()->value->constant_expression_value(variable_context);
		2020	return *result != NULL;
		2021
		2022	/* (call name (ref) (params))*/
		2023	case ir_type_call: {
		2024	ir_call *call = inst->as_call();
		2025
		2026	/* Just say no to void functions in constant expressions. We
		2027	* don't need them at that point.
		2028	*/
		2029
		2030	if (!call->return_deref)
		2031	return false;
		2032
		2033	ir_constant *store = NULL;
		2034	int offset = 0;
		2035
		2036	if (!constant_referenced(call->return_deref, variable_context,
		2037	store, offset))
		2038	return false;
		2039
		2040	ir_constant *value = call->constant_expression_value(variable_context);
		2041
		2042	if(!value)
		2043	return false;
		2044
		2045	store->copy_offset(value, offset);
		2046	break;
		2047	}
		2048
		2049	/* (if condition (then-instructions) (else-instructions)) */
		2050	case ir_type_if: {
		2051	ir_if *iif = inst->as_if();
		2052
		2053	ir_constant *cond = iif->condition->constant_expression_value(variable_context);
		2054	if (!cond \|\| !cond->type->is_boolean())
		2055	return false;
		2056
		2057	exec_list &branch = cond->get_bool_component(0) ? iif->then_instructions : iif->else_instructions;
		2058
		2059	*result = NULL;
		2060	if (!constant_expression_evaluate_expression_list(branch, variable_context, result))
		2061	return false;
		2062
		2063	/* If there was a return in the branch chosen, drop out now. */
		2064	if (*result)
		2065	return true;
		2066
		2067	break;
		2068	}
		2069
		2070	/* Every other expression type, we drop out. */
		2071	default:
		2072	return false;
		2073	}
		2074	}
		2075
		2076	/* Reaching the end of the block is not an error condition */
		2077	if (result)
		2078	*result = NULL;
		2079
		2080	return true;
		2081	}
		2082
		2083	ir_constant *
		2084	ir_function_signature::constant_expression_value(exec_list actual_parameters, struct hash_table variable_context)
		2085	{
		2086	const glsl_type *type = this->return_type;
		2087	if (type == glsl_type::void_type)
		2088	return NULL;
		2089
		2090	/* From the GLSL 1.20 spec, page 23:
		2091	* "Function calls to user-defined functions (non-built-in functions)
		2092	* cannot be used to form constant expressions."
		2093	*/
		2094	if (!this->is_builtin())
		2095	return NULL;
		2096
		2097	/*
		2098	* Of the builtin functions, only the texture lookups and the noise
		2099	* ones must not be used in constant expressions. They all include
		2100	* specific opcodes so they don't need to be special-cased at this
		2101	* point.
		2102	*/
		2103
		2104	/* Initialize the table of dereferencable names with the function
		2105	* parameters. Verify their const-ness on the way.
		2106	*
		2107	* We expect the correctness of the number of parameters to have
		2108	* been checked earlier.
		2109	*/
		2110	hash_table *deref_hash = hash_table_ctor(8, hash_table_pointer_hash,
		2111	hash_table_pointer_compare);
		2112
		2113	/* If "origin" is non-NULL, then the function body is there. So we
		2114	* have to use the variable objects from the object with the body,
		2115	* but the parameter instanciation on the current object.
		2116	*/
		2117	const exec_node *parameter_info = origin ? origin->parameters.head : parameters.head;
		2118
		2119	foreach_in_list(ir_rvalue, n, actual_parameters) {
		2120	ir_constant *constant = n->constant_expression_value(variable_context);
		2121	if (constant == NULL) {
		2122	hash_table_dtor(deref_hash);
		2123	return NULL;
		2124	}
		2125
		2126
		2127	ir_variable var = (ir_variable )parameter_info;
		2128	hash_table_insert(deref_hash, constant, var);
		2129
		2130	parameter_info = parameter_info->next;
		2131	}
		2132
		2133	ir_constant *result = NULL;
		2134
		2135	/* Now run the builtin function until something non-constant
		2136	* happens or we get the result.
		2137	*/
		2138	if (constant_expression_evaluate_expression_list(origin ? origin->body : body, deref_hash, &result) && result)
		2139	result = result->clone(ralloc_parent(this), NULL);
		2140
		2141	hash_table_dtor(deref_hash);
		2142
		2143	return result;
		2144	}

Subversion Repositories Kolibri OS

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