Add support for forward function declarations.

7 files changed, 382 insertions, 300 deletions

diff --git a/src/mesa/shader/slang/slang_assemble.c b/src/mesa/shader/slang/slang_assemble.c
index 45b6b1961cc..698b3bf747b 100644
--- a/src/mesa/shader/slang/slang_assemble.c
+++ b/src/mesa/shader/slang/slang_assemble.c
@@ -268,22 +268,36 @@ slang_function *_slang_locate_function (slang_function_scope *funcs, slang_atom
 

 /* _slang_assemble_function() */

 

-int _slang_assemble_function (slang_assembly_file *file, slang_function *fun,

-	slang_assembly_name_space *space, slang_machine *mach, slang_atom_pool *atoms)

+int _slang_assemble_function (slang_assemble_ctx *A, slang_function *fun)

 {

 	unsigned int param_size, local_size;

 	unsigned int skip, cleanup;

-	slang_assembly_flow_control flow;

-	slang_assembly_local_info info;

-	slang_assembly_stack_info stk;

 

-	fun->address = file->count;

+	fun->address = A->file->count;

 

 	if (fun->body == NULL)

 	{

-		/* TODO: jump to the actual function body */

+		/* jump to the actual function body - we do not know it, so add the instruction

+		 * to fixup table */

+		fun->fixups.table = (GLuint *) slang_alloc_realloc (fun->fixups.table,

+			fun->fixups.count * sizeof (GLuint), (fun->fixups.count + 1) * sizeof (GLuint));

+		if (fun->fixups.table == NULL)

+			return 0;

+		fun->fixups.table[fun->fixups.count] = fun->address;

+		fun->fixups.count++;

+		if (!PUSH (A->file, slang_asm_jump))

+			return 0;

 		return 1;

 	}

+	else

+	{

+		GLuint i;

+

+		/* resolve all fixup table entries and delete it */

+		for (i = 0; i < fun->fixups.count; i++)

+			A->file->code[fun->fixups.table[i]].param[0] = fun->address;

+		slang_fixup_table_free (&fun->fixups);

+	}

 

 	/* At this point traverse function formal parameters and code to calculate

 	 * total memory size to be allocated on the stack.

@@ -294,71 +308,82 @@ int _slang_assemble_function (slang_assembly_file *file, slang_function *fun,
 	/* calculate return value size */

 	param_size = 0;

 	if (fun->header.type.specifier.type != slang_spec_void)

-		if (!sizeof_variable (&fun->header.type.specifier, slang_qual_none, NULL, space,

-				&param_size, mach, file, atoms))

+		if (!sizeof_variable (&fun->header.type.specifier, slang_qual_none, NULL, &A->space,

+				&param_size, A->mach, A->file, A->atoms))

 			return 0;

-	info.ret_size = param_size;

+	A->local.ret_size = param_size;

 

 	/* calculate formal parameter list size */

-	if (!sizeof_variables (fun->parameters, 0, fun->param_count, space, &param_size, mach, file,

-			atoms))

+	if (!sizeof_variables (fun->parameters, 0, fun->param_count, &A->space, &param_size, A->mach, A->file,

+			A->atoms))

 		return 0;

 

 	/* calculate local variables size - take into account the four-byte return address and

 	 * temporaries for various tasks (4 for addr and 16 for swizzle temporaries).

 	 * these include variables from the formal parameter scope and from the code */

-	info.addr_tmp = param_size + 4;

-	info.swizzle_tmp = param_size + 4 + 4;

+	A->local.addr_tmp = param_size + 4;

+	A->local.swizzle_tmp = param_size + 4 + 4;

 	local_size = param_size + 4 + 4 + 16;

-	if (!sizeof_variables (fun->parameters, fun->param_count, fun->parameters->num_variables, space,

-			&local_size, mach, file, atoms))

+	if (!sizeof_variables (fun->parameters, fun->param_count, fun->parameters->num_variables, &A->space,

+			&local_size, A->mach, A->file, A->atoms))

 		return 0;

-	if (!collect_locals (fun->body, space, &local_size, mach, file, atoms))

+	if (!collect_locals (fun->body, &A->space, &local_size, A->mach, A->file, A->atoms))

 		return 0;

 

 	/* allocate local variable storage */

-	if (!PLAB (file, slang_asm_local_alloc, local_size - param_size - 4))

+	if (!PLAB (A->file, slang_asm_local_alloc, local_size - param_size - 4))

 		return 0;

 

 	/* mark a new frame for function variable storage */

-	if (!PLAB (file, slang_asm_enter, local_size))

+	if (!PLAB (A->file, slang_asm_enter, local_size))

 		return 0;

 

 	/* jump directly to the actual code */

-	skip = file->count;

-	if (!push_new (file))

+	skip = A->file->count;

+	if (!push_new (A->file))

 		return 0;

-	file->code[skip].type = slang_asm_jump;

+	A->file->code[skip].type = slang_asm_jump;

 

 	/* all "return" statements will be directed here */

-	flow.function_end = file->count;

-	cleanup = file->count;

-	if (!push_new (file))

+	A->flow.function_end = A->file->count;

+	cleanup = A->file->count;

+	if (!push_new (A->file))

 		return 0;

-	file->code[cleanup].type = slang_asm_jump;

+	A->file->code[cleanup].type = slang_asm_jump;

 

 	/* execute the function body */

-	file->code[skip].param[0] = file->count;

-	if (!_slang_assemble_operation (file, fun->body, 0, &flow, space, &info, &stk, mach, atoms))

+	A->file->code[skip].param[0] = A->file->count;

+	if (!_slang_assemble_operation_ (A, fun->body, slang_ref_freelance))

 		return 0;

 

 	/* this is the end of the function - restore the old function frame */

-	file->code[cleanup].param[0] = file->count;

-	if (!PUSH (file, slang_asm_leave))

+	A->file->code[cleanup].param[0] = A->file->count;

+	if (!PUSH (A->file, slang_asm_leave))

 		return 0;

 

 	/* free local variable storage */

-	if (!PLAB (file, slang_asm_local_free, local_size - param_size - 4))

+	if (!PLAB (A->file, slang_asm_local_free, local_size - param_size - 4))

 		return 0;

 

 	/* return from the function */

-	if (!PUSH (file, slang_asm_return))

+	if (!PUSH (A->file, slang_asm_return))

 		return 0;

 	return 1;

 }

 

 int _slang_cleanup_stack (slang_assembly_file *file, slang_operation *op, int ref,

-	slang_assembly_name_space *space, slang_machine *mach, slang_atom_pool *atoms)

+	slang_assembly_name_space *space, struct slang_machine_ *mach, slang_atom_pool *atoms)

+{

+	slang_assemble_ctx A;

+

+	A.file = file;

+	A.mach = mach;

+	A.atoms = atoms;

+	A.space = *space;

+	return _slang_cleanup_stack_ (&A, op);

+}

+

+int _slang_cleanup_stack_ (slang_assemble_ctx *A, slang_operation *op)

 {

 	slang_assembly_typeinfo ti;

 	unsigned int size = 0;

@@ -366,15 +391,15 @@ int _slang_cleanup_stack (slang_assembly_file *file, slang_operation *op, int re
 	/* get type info of the operation and calculate its size */

 	if (!slang_assembly_typeinfo_construct (&ti))

 		return 0;

-	if (!_slang_typeof_operation (op, space, &ti, atoms))

+	if (!_slang_typeof_operation (op, &A->space, &ti, A->atoms))

 	{

 		slang_assembly_typeinfo_destruct (&ti);

 		return 0;

 	}

-	if (ref)

+	if (A->ref == slang_ref_force)

 		size = 4;

 	else if (ti.spec.type != slang_spec_void)

-		if (!sizeof_variable (&ti.spec, slang_qual_none, NULL, space, &size, mach, file, atoms))

+		if (!sizeof_variable (&ti.spec, slang_qual_none, NULL, &A->space, &size, A->mach, A->file, A->atoms))

 		{

 			slang_assembly_typeinfo_destruct (&ti);

 			return 0;

@@ -384,7 +409,7 @@ int _slang_cleanup_stack (slang_assembly_file *file, slang_operation *op, int re
 	/* if nonzero, free it from the stack */

 	if (size != 0)

 	{

-		if (!PLAB (file, slang_asm_local_free, size))

+		if (!PLAB (A->file, slang_asm_local_free, size))

 			return 0;

 	}

 	return 1;

@@ -499,9 +524,8 @@ int _slang_dereference (slang_assembly_file *file, slang_operation *op,
 	return result;

 }

 

-int _slang_call_function (slang_assembly_file *file, slang_function *fun, slang_operation *params,

-	unsigned int param_count, int assignment, slang_assembly_name_space *space,

-	slang_assembly_local_info *info, slang_machine *mach, slang_atom_pool *atoms)

+int _slang_assemble_function_call (slang_assemble_ctx *A, slang_function *fun,

+	slang_operation *params, GLuint param_count, GLboolean assignment)

 {

 	unsigned int i;

 	slang_assembly_stack_info p_stk[64];

@@ -515,52 +539,50 @@ int _slang_call_function (slang_assembly_file *file, slang_function *fun, slang_
 	{

 		unsigned int ret_size = 0;

 

-		if (!sizeof_variable (&fun->header.type.specifier, slang_qual_none, NULL, space,

-				&ret_size, mach, file, atoms))

+		if (!sizeof_variable (&fun->header.type.specifier, slang_qual_none, NULL, &A->space,

+				&ret_size, A->mach, A->file, A->atoms))

 			return 0;

-		if (!PLAB (file, slang_asm_local_alloc, ret_size))

+		if (!PLAB (A->file, slang_asm_local_alloc, ret_size))

 			return 0;

 	}

 

 	/* push the actual parameters on the stack */

 	for (i = 0; i < param_count; i++)

 	{

-		slang_assembly_flow_control flow;

-

 		if (fun->parameters->variables[i].type.qualifier == slang_qual_inout ||

 			fun->parameters->variables[i].type.qualifier == slang_qual_out)

 		{

-			if (!PLAB2 (file, slang_asm_local_addr, info->addr_tmp, 4))

+			if (!PLAB2 (A->file, slang_asm_local_addr, A->local.addr_tmp, 4))

 				return 0;

 			/* TODO: optimize the "out" parameter case */

-			if (!_slang_assemble_operation (file, &params[i], 1, &flow, space, info, &p_stk[i],

-					mach, atoms))

+			if (!_slang_assemble_operation_ (A, &params[i], slang_ref_force))

 				return 0;

-			if (!PUSH (file, slang_asm_addr_copy))

+			p_stk[i] = A->swz;

+			if (!PUSH (A->file, slang_asm_addr_copy))

 				return 0;

-			if (!PUSH (file, slang_asm_addr_deref))

+			if (!PUSH (A->file, slang_asm_addr_deref))

 				return 0;

 			if (i == 0 && assignment)

 			{

 				/* duplicate the resulting address */

-				if (!PLAB2 (file, slang_asm_local_addr, info->addr_tmp, 4))

+				if (!PLAB2 (A->file, slang_asm_local_addr, A->local.addr_tmp, 4))

 					return 0;

-				if (!PUSH (file, slang_asm_addr_deref))

+				if (!PUSH (A->file, slang_asm_addr_deref))

 					return 0;

 			}

-			if (!_slang_dereference (file, &params[i], space, info, mach, atoms))

+			if (!_slang_dereference (A->file, &params[i], &A->space, &A->local, A->mach, A->atoms))

 				return 0;

 		}

 		else

 		{

-			if (!_slang_assemble_operation (file, &params[i], 0, &flow, space, info, &p_stk[i],

-					mach, atoms))

+			if (!_slang_assemble_operation_ (A, &params[i], slang_ref_forbid))

 				return 0;

+			p_stk[i] = A->swz;

 		}

 	}

 

 	/* call the function */

-	if (!PLAB (file, slang_asm_call, fun->address))

+	if (!PLAB (A->file, slang_asm_call, fun->address))

 		return 0;

 

 	/* pop the parameters from the stack */

@@ -573,16 +595,17 @@ int _slang_call_function (slang_assembly_file *file, slang_function *fun, slang_
 		{

 			/* for output parameter copy the contents of the formal parameter

 			 * back to the original actual parameter */

-			if (!_slang_assemble_assignment (file, &params[j], space, info, &p_stk[j], mach, atoms))

+			A->swz = p_stk[j];

+			if (!_slang_assemble_assignment (A, &params[j]))

 				return 0;

 			/* pop the actual parameter's address */

-			if (!PLAB (file, slang_asm_local_free, 4))

+			if (!PLAB (A->file, slang_asm_local_free, 4))

 				return 0;

 		}

 		else

 		{

 			/* pop the value of the parameter */

-			if (!_slang_cleanup_stack (file, &params[j], 0, space, mach, atoms))

+			if (!_slang_cleanup_stack_ (A, &params[j]))

 				return 0;

 		}

 	}

@@ -590,27 +613,23 @@ int _slang_call_function (slang_assembly_file *file, slang_function *fun, slang_
 	return 1;

 }

 

-/* TODO: migrate to full-atom version */

-int call_function_name (slang_assembly_file *file, const char *name, slang_operation *params,

-	unsigned int param_count, int assignment, slang_assembly_name_space *space,

-	slang_assembly_local_info *info, slang_machine *mach, slang_atom_pool *atoms)

+int _slang_assemble_function_call_name (slang_assemble_ctx *A, const char *name,

+	slang_operation *params, GLuint param_count, GLboolean assignment)

 {

 	slang_atom atom;

 	slang_function *fun;

 

-	atom = slang_atom_pool_atom (atoms, name);

+	atom = slang_atom_pool_atom (A->atoms, name);

 	if (atom == SLANG_ATOM_NULL)

 		return 0;

-	fun = _slang_locate_function (space->funcs, atom, params, param_count, space, atoms);

+	fun = _slang_locate_function (A->space.funcs, atom, params, param_count, &A->space, A->atoms);

 	if (fun == NULL)

 		return 0;

-	return _slang_call_function (file, fun, params, param_count, assignment, space, info, mach,

-		atoms);

+	return _slang_assemble_function_call (A, fun, params, param_count, assignment);

 }

 

-static int call_function_name_dummyint (slang_assembly_file *file, const char *name,

-	slang_operation *params, slang_assembly_name_space *space, slang_assembly_local_info *info,

-	slang_machine *mach, slang_atom_pool *atoms)

+static int assemble_function_call_name_dummyint (slang_assemble_ctx *A, const char *name,

+	slang_operation *params)

 {

 	slang_operation p[2];

 	int result;

@@ -619,7 +638,7 @@ static int call_function_name_dummyint (slang_assembly_file *file, const char *n
 	if (!slang_operation_construct (&p[1]))

 		return 0;

 	p[1].type = slang_oper_literal_int;

-	result = call_function_name (file, name, p, 2, 0, space, info, mach, atoms);

+	result = _slang_assemble_function_call_name (A, name, p, 2, GL_FALSE);

 	slang_operation_destruct (&p[1]);

 	return result;

 }

@@ -1001,19 +1020,40 @@ static int handle_field (slang_assembly_typeinfo *tia, slang_assembly_typeinfo *
 	return 1;

 }

 

-int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, int reference,

-	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

-	slang_assembly_local_info *info, slang_assembly_stack_info *stk, slang_machine *mach,

-	slang_atom_pool *atoms)

+int _slang_assemble_operation (slang_assembly_file *file, struct slang_operation_ *op, int reference,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space, slang_assembly_local_info *info,

+	slang_assembly_stack_info *stk, struct slang_machine_ *mach, slang_atom_pool *atoms)

 {

-	unsigned int assem;

+	slang_assemble_ctx A;

+

+	A.file = file;

+	A.mach = mach;

+	A.atoms = atoms;

+	A.space = *space;

+	A.flow = *flow;

+	A.local = *info;

+	if (!_slang_assemble_operation_ (&A, op, reference ? slang_ref_force : slang_ref_forbid))

+		return 0;

+	*stk = A.swz;

+	return 1;

+}

 

-	stk->swizzle.num_components = 0;

+int _slang_assemble_operation_ (slang_assemble_ctx *A, slang_operation *op, slang_ref_type ref)

+{

+	unsigned int assem;

+	slang_assembly_stack_info swz;

 

-	assem = file->count;

-	if (!push_new (file))

+	assem = A->file->count;

+	if (!push_new (A->file))

 		return 0;

 

+if (ref == slang_ref_freelance)

+ref = slang_ref_forbid;

+

+	/* set default results */

+	A->ref = (ref == slang_ref_freelance) ? slang_ref_force : ref;

+	swz.swizzle.num_components = 0;

+

 	switch (op->type)

 	{

 	case slang_oper_block_no_new_scope:

@@ -1023,13 +1063,9 @@ int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, i
 

 			for (i = 0; i < op->num_children; i++)

 			{

-				slang_assembly_stack_info stk;

-

-				if (!_slang_assemble_operation (file, &op->children[i], 0, flow, space, info, &stk,

-						mach, atoms))

+				if (!_slang_assemble_operation_ (A, &op->children[i], slang_ref_freelance))

 					return 0;

-				/* ignore the stk */

-				if (!_slang_cleanup_stack (file, &op->children[i], 0, space, mach, atoms))

+				if (!_slang_cleanup_stack_ (A, &op->children[i]))

 					return 0;

 			}

 		}

@@ -1049,95 +1085,92 @@ int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, i
 		{

 			unsigned int i;

 

-			for (i = 0; i < op->num_children; i++)

-			{

-				slang_assembly_stack_info stk;

-

-				if (!_slang_assemble_operation (file, &op->children[i], i == 0, flow, space, info,

-						&stk, mach, atoms))

+			if (!_slang_assemble_operation_ (A, &op->children[0], slang_ref_force))

+				return 0;

+			for (i = 1; i < op->num_children; i++)

+				if (!_slang_assemble_operation_ (A, &op->children[i], slang_ref_forbid))

 					return 0;

-				/* __asm statement does not support any swizzles, so lets ignore stk for now */

-			}

-			if (!call_asm_instruction (file, op->a_id, atoms))

+			if (!call_asm_instruction (A->file, op->a_id, A->atoms))

 				return 0;

 		}

 		break;

 	case slang_oper_break:

-		file->code[assem].type = slang_asm_jump;

-		file->code[assem].param[0] = flow->loop_end;

+		A->file->code[assem].type = slang_asm_jump;

+		A->file->code[assem].param[0] = A->flow.loop_end;

 		break;

 	case slang_oper_continue:

-		file->code[assem].type = slang_asm_jump;

-		file->code[assem].param[0] = flow->loop_start;

+		A->file->code[assem].type = slang_asm_jump;

+		A->file->code[assem].param[0] = A->flow.loop_start;

 		break;

 	case slang_oper_discard:

-		file->code[assem].type = slang_asm_discard;

-		if (!PUSH (file, slang_asm_exit))

+		A->file->code[assem].type = slang_asm_discard;

+		if (!PUSH (A->file, slang_asm_exit))

 			return 0;

 		break;

 	case slang_oper_return:

-		if (info->ret_size != 0)

+		if (A->local.ret_size != 0)

 		{

-			slang_assembly_stack_info stk;

-

 			/* push the result's address */

-			if (!PLAB2 (file, slang_asm_local_addr, 0, info->ret_size))

+			if (!PLAB2 (A->file, slang_asm_local_addr, 0, A->local.ret_size))

 				return 0;

-			if (!_slang_assemble_operation (file, &op->children[0], 0, flow, space, info, &stk,

-					mach, atoms))

+			if (!_slang_assemble_operation_ (A, &op->children[0], slang_ref_forbid))

 				return 0;

 

-			/* ignore the stk from latest operation, reset swizzle to 0 for the assignment */

-			stk.swizzle.num_components = 0;

+			A->swz.swizzle.num_components = 0;

 			/* assign the operation to the function result (it was reserved on the stack) */

-			if (!_slang_assemble_assignment (file, op->children, space, info, &stk, mach, atoms))

+			if (!_slang_assemble_assignment (A, op->children))

 				return 0;

 

-			if (!PLAB (file, slang_asm_local_free, 4))

+			if (!PLAB (A->file, slang_asm_local_free, 4))

 				return 0;

 		}

-		if (!PLAB (file, slang_asm_jump, flow->function_end))

+		if (!PLAB (A->file, slang_asm_jump, A->flow.function_end))

 			return 0;

 		break;

 	case slang_oper_expression:

-		{

-			slang_assembly_stack_info stk;

-

-			assert (!reference);

-			if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk, mach, atoms))

-				return 0;

-			/* ignore the stk info */

-		}

+		if (ref == slang_ref_force)

+			return 0;

+		if (!_slang_assemble_operation_ (A, &op->children[0], ref))

+			return 0;

 		break;

 	case slang_oper_if:

-		if (!_slang_assemble_if (file, op, flow, space, info, mach, atoms))

+		if (!_slang_assemble_if (A->file, op, &A->flow, &A->space, &A->local, A->mach, A->atoms))

 			return 0;

 		break;

 	case slang_oper_while:

-		if (!_slang_assemble_while (file, op, flow, space, info, mach, atoms))

+		if (!_slang_assemble_while (A->file, op, &A->flow, &A->space, &A->local, A->mach, A->atoms))

 			return 0;

 		break;

 	case slang_oper_do:

-		if (!_slang_assemble_do (file, op, flow, space, info, mach, atoms))

+		if (!_slang_assemble_do (A->file, op, &A->flow, &A->space, &A->local, A->mach, A->atoms))

 			return 0;

 		break;

 	case slang_oper_for:

-		if (!_slang_assemble_for (file, op, flow, space, info, mach, atoms))

+		if (!_slang_assemble_for (A->file, op, &A->flow, &A->space, &A->local, A->mach, A->atoms))

 			return 0;

 		break;

 	case slang_oper_void:

 		break;

 	case slang_oper_literal_bool:

-		file->code[assem].type = slang_asm_bool_push;

-		file->code[assem].literal = op->literal;

+		if (ref == slang_ref_force)

+			return 0;

+		A->file->code[assem].type = slang_asm_bool_push;

+		A->file->code[assem].literal = op->literal;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_literal_int:

-		file->code[assem].type = slang_asm_int_push;

-		file->code[assem].literal = op->literal;

+		if (ref == slang_ref_force)

+			return 0;

+		A->file->code[assem].type = slang_asm_int_push;

+		A->file->code[assem].literal = op->literal;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_literal_float:

-		file->code[assem].type = slang_asm_float_push;

-		file->code[assem].literal = op->literal;

+		if (ref == slang_ref_force)

+			return 0;

+		A->file->code[assem].type = slang_asm_float_push;

+		A->file->code[assem].literal = op->literal;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_identifier:

 		{

@@ -1149,69 +1182,64 @@ int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, i
 			if (var == NULL)

 				return 0;

 			size = 0;

-			if (!sizeof_variable (&var->type.specifier, slang_qual_none, var->array_size, space,

-					&size, mach, file, atoms))

+			if (!sizeof_variable (&var->type.specifier, slang_qual_none, var->array_size, &A->space,

+					&size, A->mach, A->file, A->atoms))

 				return 0;

 

 			/* prepare stack for dereferencing */

-			if (!reference)

-				if (!PLAB2 (file, slang_asm_local_addr, info->addr_tmp, 4))

+			if (ref == slang_ref_forbid)

+				if (!PLAB2 (A->file, slang_asm_local_addr, A->local.addr_tmp, 4))

 					return 0;

 

 			/* push the variable's address */

 			if (var->global)

 			{

-				if (!PLAB (file, slang_asm_addr_push, var->address))

+				if (!PLAB (A->file, slang_asm_addr_push, var->address))

 					return 0;

 			}

 			else

 			{

-				if (!PLAB2 (file, slang_asm_local_addr, var->address, size))

+				if (!PLAB2 (A->file, slang_asm_local_addr, var->address, size))

 					return 0;

 			}

 

 			/* perform the dereference */

-			if (!reference)

+			if (ref == slang_ref_forbid)

 			{

-				if (!PUSH (file, slang_asm_addr_copy))

+				if (!PUSH (A->file, slang_asm_addr_copy))

 					return 0;

-				if (!PLAB (file, slang_asm_local_free, 4))

+				if (!PLAB (A->file, slang_asm_local_free, 4))

 					return 0;

-				if (!_slang_dereference (file, op, space, info, mach, atoms))

+				if (!_slang_dereference (A->file, op, &A->space, &A->local, A->mach, A->atoms))

 					return 0;

 			}

 		}

 		break;

 	case slang_oper_sequence:

-		{

-			slang_assembly_stack_info stk;

-

-			if (!_slang_assemble_operation (file, &op->children[0], 0, flow, space, info, &stk,

-					mach, atoms))

-				return 0;

-			/* TODO: pass-in stk to cleanup */

-			if (!_slang_cleanup_stack (file, &op->children[0], 0, space, mach, atoms))

-				return 0;

-			if (!_slang_assemble_operation (file, &op->children[1], 0, flow, space, info,

-					&stk, mach, atoms))

-				return 0;

-			/* TODO: inspect stk */

-		}

+		if (ref == slang_ref_force)

+			return 0;

+		if (!_slang_assemble_operation_ (A, &op->children[0], slang_ref_freelance))

+			return 0;

+		if (!_slang_cleanup_stack_ (A, &op->children[0]))

+			return 0;

+		if (!_slang_assemble_operation_ (A, &op->children[1], slang_ref_forbid))

+			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_assign:

-		if (!_slang_assemble_assign (file, op, "=", reference, space, info, mach, atoms))

+		if (!_slang_assemble_assign (A, op, "=", ref))

 			return 0;

 		break;

 	case slang_oper_addassign:

-		if (!_slang_assemble_assign (file, op, "+=", reference, space, info, mach, atoms))

+		if (!_slang_assemble_assign (A, op, "+=", ref))

 			return 0;

 		break;

 	case slang_oper_subassign:

-		if (!_slang_assemble_assign (file, op, "-=", reference, space, info, mach, atoms))

+		if (!_slang_assemble_assign (A, op, "-=", ref))

 			return 0;

 		break;

 	case slang_oper_mulassign:

-		if (!_slang_assemble_assign (file, op, "*=", reference, space, info, mach, atoms))

+		if (!_slang_assemble_assign (A, op, "*=", ref))

 			return 0;

 		break;

 	/*case slang_oper_modassign:*/

@@ -1221,111 +1249,116 @@ int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, i
 	/*case slang_oper_xorassign:*/

 	/*case slang_oper_andassign:*/

 	case slang_oper_divassign:

-		if (!_slang_assemble_assign (file, op, "/=", reference, space, info, mach, atoms))

+		if (!_slang_assemble_assign (A, op, "/=", ref))

 			return 0;

 		break;

 	case slang_oper_select:

-		if (!_slang_assemble_select (file, op, flow, space, info, mach, atoms))

+		if (!_slang_assemble_select (A->file, op, &A->flow, &A->space, &A->local, A->mach, A->atoms))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_logicalor:

-		if (!_slang_assemble_logicalor (file, op, flow, space, info, mach, atoms))

+		if (!_slang_assemble_logicalor (A->file, op, &A->flow, &A->space, &A->local, A->mach, A->atoms))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_logicaland:

-		if (!_slang_assemble_logicaland (file, op, flow, space, info, mach, atoms))

+		if (!_slang_assemble_logicaland (A->file, op, &A->flow, &A->space, &A->local, A->mach, A->atoms))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_logicalxor:

-		if (!call_function_name (file, "^^", op->children, 2, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, "^^", op->children, 2, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	/*case slang_oper_bitor:*/

 	/*case slang_oper_bitxor:*/

 	/*case slang_oper_bitand:*/

 	case slang_oper_less:

-		if (!call_function_name (file, "<", op->children, 2, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, "<", op->children, 2, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_greater:

-		if (!call_function_name (file, ">", op->children, 2, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, ">", op->children, 2, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_lessequal:

-		if (!call_function_name (file, "<=", op->children, 2, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, "<=", op->children, 2, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_greaterequal:

-		if (!call_function_name (file, ">=", op->children, 2, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, ">=", op->children, 2, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	/*case slang_oper_lshift:*/

 	/*case slang_oper_rshift:*/

 	case slang_oper_add:

-		if (!call_function_name (file, "+", op->children, 2, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, "+", op->children, 2, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_subtract:

-		if (!call_function_name (file, "-", op->children, 2, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, "-", op->children, 2, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_multiply:

-		if (!call_function_name (file, "*", op->children, 2, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, "*", op->children, 2, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	/*case slang_oper_modulus:*/

 	case slang_oper_divide:

-		if (!call_function_name (file, "/", op->children, 2, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, "/", op->children, 2, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_equal:

-		{

-			slang_assembly_stack_info stk;

-

-			if (!_slang_assemble_operation (file, &op->children[0], 0, flow, space, info, &stk,

-					mach, atoms))

-				return 0;

-			if (!_slang_assemble_operation (file, &op->children[1], 0, flow, space, info, &stk,

-					mach, atoms))

-				return 0;

-			if (!equality (file, op->children, space, info, 1, mach, atoms))

-				return 0;

-		}

+		if (!_slang_assemble_operation_ (A, &op->children[0], slang_ref_forbid))

+			return 0;

+		if (!_slang_assemble_operation_ (A, &op->children[1], slang_ref_forbid))

+			return 0;

+		if (!equality (A->file, op->children, &A->space, &A->local, 1, A->mach, A->atoms))

+			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_notequal:

-		{

-			slang_assembly_stack_info stk;

-

-			if (!_slang_assemble_operation (file, &op->children[0], 0, flow, space, info, &stk,

-					mach, atoms))

-				return 0;

-			if (!_slang_assemble_operation (file, &op->children[1], 0, flow, space, info, &stk,

-					mach, atoms))

-				return 0;

-			if (!equality (file, op->children, space, info, 0, mach, atoms))

-				return 0;

-		}

+		if (!_slang_assemble_operation_ (A, &op->children[0], slang_ref_forbid))

+			return 0;

+		if (!_slang_assemble_operation_ (A, &op->children[1], slang_ref_forbid))

+			return 0;

+		if (!equality (A->file, op->children, &A->space, &A->local, 0, A->mach, A->atoms))

+			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_preincrement:

-		if (!_slang_assemble_assign (file, op, "++", reference, space, info, mach, atoms))

+		if (!_slang_assemble_assign (A, op, "++", ref))

 			return 0;

 		break;

 	case slang_oper_predecrement:

-		if (!_slang_assemble_assign (file, op, "--", reference, space, info, mach, atoms))

+		if (!_slang_assemble_assign (A, op, "--", ref))

 			return 0;

 		break;

 	case slang_oper_plus:

-		if (!_slang_dereference (file, op, space, info, mach, atoms))

+		if (!_slang_dereference (A->file, op, &A->space, &A->local, A->mach, A->atoms))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_minus:

-		if (!call_function_name (file, "-", op->children, 1, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, "-", op->children, 1, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	/*case slang_oper_complement:*/

 	case slang_oper_not:

-		if (!call_function_name (file, "!", op->children, 1, 0, space, info, mach, atoms))

+		if (!_slang_assemble_function_call_name (A, "!", op->children, 1, GL_FALSE))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_subscript:

 		{

@@ -1338,8 +1371,8 @@ int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, i
 				slang_assembly_typeinfo_destruct (&ti_arr);

 				return 0;

 			}

-			if (!handle_subscript (&ti_elem, &ti_arr, file, op, reference, flow, space, info,

-					mach, atoms))

+			if (!handle_subscript (&ti_elem, &ti_arr, A->file, op, ref != slang_ref_forbid, &A->flow, &A->space, &A->local,

+					A->mach, A->atoms))

 			{

 				slang_assembly_typeinfo_destruct (&ti_arr);

 				slang_assembly_typeinfo_destruct (&ti_elem);

@@ -1353,8 +1386,8 @@ int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, i
 		{

 			slang_function *fun;

 

-			fun = _slang_locate_function (space->funcs, op->a_id, op->children, op->num_children,

-				space, atoms);

+			fun = _slang_locate_function (A->space.funcs, op->a_id, op->children, op->num_children,

+				&A->space, A->atoms);

 			if (fun == NULL)

 			{

 /*				if (!_slang_assemble_constructor (file, op, flow, space, info, mach))

@@ -1362,10 +1395,10 @@ int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, i
 			}

 			else

 			{

-				if (!_slang_call_function (file, fun, op->children, op->num_children, 0, space,

-						info, mach, atoms))

+				if (!_slang_assemble_function_call (A, fun, op->children, op->num_children, GL_FALSE))

 					return 0;

 			}

+			A->ref = slang_ref_forbid;

 		}

 		break;

 	case slang_oper_field:

@@ -1379,8 +1412,8 @@ int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, i
 				slang_assembly_typeinfo_destruct (&ti_after);

 				return 0;

 			}

-			if (!handle_field (&ti_after, &ti_before, file, op, reference, flow, space, info, stk,

-					mach, atoms))

+			if (!handle_field (&ti_after, &ti_before, A->file, op, ref != slang_ref_forbid, &A->flow, &A->space, &A->local, &swz,

+					A->mach, A->atoms))

 			{

 				slang_assembly_typeinfo_destruct (&ti_after);

 				slang_assembly_typeinfo_destruct (&ti_before);

@@ -1391,16 +1424,21 @@ int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, i
 		}

 		break;

 	case slang_oper_postincrement:

-		if (!call_function_name_dummyint (file, "++", op->children, space, info, mach, atoms))

+		if (!assemble_function_call_name_dummyint (A, "++", op->children))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	case slang_oper_postdecrement:

-		if (!call_function_name_dummyint (file, "--", op->children, space, info, mach, atoms))

+		if (!assemble_function_call_name_dummyint (A, "--", op->children))

 			return 0;

+		A->ref = slang_ref_forbid;

 		break;

 	default:

 		return 0;

 	}

+

+	A->swz = swz;

+

 	return 1;

 }

 

diff --git a/src/mesa/shader/slang/slang_assemble.h b/src/mesa/shader/slang/slang_assemble.h
index c3af8d8fed8..3d5eec21047 100644
--- a/src/mesa/shader/slang/slang_assemble.h
+++ b/src/mesa/shader/slang/slang_assemble.h
@@ -125,19 +125,19 @@ typedef struct slang_assembly_flow_control_
 	unsigned int function_end;			/* for "return" statement */

 } slang_assembly_flow_control;

 

-typedef struct slang_assembly_name_space_

+typedef struct slang_assembly_local_info_

 {

-	struct slang_function_scope_ *funcs;

-	struct slang_struct_scope_ *structs;

-	struct slang_variable_scope_ *vars;

-} slang_assembly_name_space;

-

-slang_function *_slang_locate_function (slang_function_scope *funcs, slang_atom a_name,

-	slang_operation *params, unsigned int num_params, slang_assembly_name_space *space,

-	slang_atom_pool *);

+	unsigned int ret_size;

+	unsigned int addr_tmp;

+	unsigned int swizzle_tmp;

+} slang_assembly_local_info;

 

-int _slang_assemble_function (slang_assembly_file *, struct slang_function_ *,

-	slang_assembly_name_space *, struct slang_machine_ *, slang_atom_pool *);

+typedef enum

+{

+	slang_ref_force,

+	slang_ref_forbid,

+	slang_ref_freelance

+} slang_ref_type;

 

 /*

 	holds a complete information about vector swizzle - the <swizzle> array contains

@@ -155,22 +155,48 @@ typedef struct slang_assembly_stack_info_
 	slang_swizzle swizzle;

 } slang_assembly_stack_info;

 

-int _slang_cleanup_stack (slang_assembly_file *, slang_operation *, int ref,

-	slang_assembly_name_space *, struct slang_machine_ *, slang_atom_pool *);

+typedef struct slang_assembly_name_space_

+{

+	struct slang_function_scope_ *funcs;

+	struct slang_struct_scope_ *structs;

+	struct slang_variable_scope_ *vars;

+} slang_assembly_name_space;

 

-typedef struct slang_assembly_local_info_

+typedef struct slang_assemble_ctx_

 {

-	unsigned int ret_size;

-	unsigned int addr_tmp;

-	unsigned int swizzle_tmp;

-} slang_assembly_local_info;

+	slang_assembly_file *file;

+	struct slang_machine_ *mach;

+	slang_atom_pool *atoms;

+	slang_assembly_name_space space;

+	slang_assembly_flow_control flow;

+	slang_assembly_local_info local;

+	slang_ref_type ref;

+	slang_assembly_stack_info swz;

+} slang_assemble_ctx;

+

+slang_function *_slang_locate_function (slang_function_scope *funcs, slang_atom a_name,

+	slang_operation *params, unsigned int num_params, slang_assembly_name_space *space,

+	slang_atom_pool *);

+

+int _slang_assemble_function (slang_assemble_ctx *, struct slang_function_ *);

+

+int _slang_cleanup_stack (slang_assembly_file *, slang_operation *, int ref,

+	slang_assembly_name_space *, struct slang_machine_ *, slang_atom_pool *);

+int _slang_cleanup_stack_ (slang_assemble_ctx *, slang_operation *);

 

 int _slang_dereference (slang_assembly_file *, slang_operation *, slang_assembly_name_space *,

 	slang_assembly_local_info *, struct slang_machine_ *, slang_atom_pool *);

 

+int _slang_assemble_function_call (slang_assemble_ctx *, slang_function *,

+	slang_operation *, GLuint, GLboolean);

+

+int _slang_assemble_function_call_name (slang_assemble_ctx *, const char *,

+	slang_operation *, GLuint, GLboolean);

+

 int _slang_assemble_operation (slang_assembly_file *, struct slang_operation_ *, int reference,

 	slang_assembly_flow_control *, slang_assembly_name_space *, slang_assembly_local_info *,

 	slang_assembly_stack_info *, struct slang_machine_ *, slang_atom_pool *);

+int _slang_assemble_operation_ (slang_assemble_ctx *, struct slang_operation_ *, slang_ref_type);

 

 #ifdef __cplusplus

 }

diff --git a/src/mesa/shader/slang/slang_assemble_assignment.c b/src/mesa/shader/slang/slang_assemble_assignment.c
index 3c35e862566..afecf08a491 100644
--- a/src/mesa/shader/slang/slang_assemble_assignment.c
+++ b/src/mesa/shader/slang/slang_assemble_assignment.c
@@ -117,9 +117,7 @@ static int assign_aggregate (slang_assembly_file *file, const slang_storage_aggr
 	return 1;

 }

 

-int _slang_assemble_assignment (slang_assembly_file *file, slang_operation *op,

-	slang_assembly_name_space *space, slang_assembly_local_info *info, slang_assembly_stack_info *stk,

-	struct slang_machine_ *mach, slang_atom_pool *atoms)

+int _slang_assemble_assignment (slang_assemble_ctx *A, slang_operation *op)

 {

 	slang_assembly_typeinfo ti;

 	int result;

@@ -128,7 +126,7 @@ int _slang_assemble_assignment (slang_assembly_file *file, slang_operation *op,
 

 	if (!slang_assembly_typeinfo_construct (&ti))

 		return 0;

-	if (!_slang_typeof_operation (op, space, &ti, atoms))

+	if (!_slang_typeof_operation (op, &A->space, &ti, A->atoms))

 	{

 		slang_assembly_typeinfo_destruct (&ti);

 		return 0;

@@ -139,8 +137,8 @@ int _slang_assemble_assignment (slang_assembly_file *file, slang_operation *op,
 		slang_assembly_typeinfo_destruct (&ti);

 		return 0;

 	}

-	if (!_slang_aggregate_variable (&agg, &ti.spec, NULL, space->funcs, space->structs,

-			space->vars, mach, file, atoms))

+	if (!_slang_aggregate_variable (&agg, &ti.spec, NULL, A->space.funcs, A->space.structs,

+			A->space.vars, A->mach, A->file, A->atoms))

 	{

 		slang_storage_aggregate_destruct (&agg);

 		slang_assembly_typeinfo_destruct (&ti);

@@ -149,7 +147,7 @@ int _slang_assemble_assignment (slang_assembly_file *file, slang_operation *op,
 

 	index = 0;

 	size = _slang_sizeof_aggregate (&agg);

-	result = assign_aggregate (file, &agg, &index, size, info, stk);

+	result = assign_aggregate (A->file, &agg, &index, size, &A->local, &A->swz);

 

 	slang_storage_aggregate_destruct (&agg);

 	slang_assembly_typeinfo_destruct (&ti);

@@ -163,48 +161,41 @@ int _slang_assemble_assignment (slang_assembly_file *file, slang_operation *op,
 	children

 */

 

-int call_function_name (slang_assembly_file *file, const char *name, slang_operation *params,

-	unsigned int param_count, int assignment, slang_assembly_name_space *space,

-	slang_assembly_local_info *info, slang_machine *mach, slang_atom_pool *atoms);

-

-int _slang_assemble_assign (slang_assembly_file *file, slang_operation *op, const char *oper,

-	int ref, slang_assembly_name_space *space, slang_assembly_local_info *info,

-	struct slang_machine_ *mach, slang_atom_pool *atoms)

+int _slang_assemble_assign (slang_assemble_ctx *A, slang_operation *op, const char *oper,

+	slang_ref_type ref)

 {

-	slang_assembly_stack_info l_stk, r_stk;

-	slang_assembly_flow_control flow;

+	slang_assembly_stack_info stk;

 

-	if (!ref)

+	if (ref == slang_ref_forbid)

 	{

-		if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr, info->addr_tmp, 4))

+		if (!slang_assembly_file_push_label2 (A->file, slang_asm_local_addr, A->local.addr_tmp, 4))

 			return 0;

 	}

 

 	if (slang_string_compare ("=", oper) == 0)

 	{

-		if (!_slang_assemble_operation (file, &op->children[0], 1, &flow, space, info, &l_stk, mach,

-				atoms))

+		if (!_slang_assemble_operation_ (A, &op->children[0], slang_ref_force))

 			return 0;

-		if (!_slang_assemble_operation (file, &op->children[1], 0, &flow, space, info, &r_stk, mach,

-				atoms))

+		stk = A->swz;

+		if (!_slang_assemble_operation_ (A, &op->children[1], slang_ref_forbid))

 			return 0;

-		if (!_slang_assemble_assignment (file, op->children, space, info, &l_stk, mach, atoms))

+		A->swz = stk;

+		if (!_slang_assemble_assignment (A, op->children))

 			return 0;

 	}

 	else

 	{

-		if (!call_function_name (file, oper, op->children, op->num_children, 1, space, info, mach,

-				atoms))

+		if (!_slang_assemble_function_call_name (A, oper, op->children, op->num_children, GL_TRUE))

 			return 0;

 	}

 

-	if (!ref)

+	if (ref == slang_ref_forbid)

 	{

-		if (!slang_assembly_file_push (file, slang_asm_addr_copy))

+		if (!slang_assembly_file_push (A->file, slang_asm_addr_copy))

 			return 0;

-		if (!slang_assembly_file_push_label (file, slang_asm_local_free, 4))

+		if (!slang_assembly_file_push_label (A->file, slang_asm_local_free, 4))

 			return 0;

-		if (!_slang_dereference (file, op->children, space, info, mach, atoms))

+		if (!_slang_dereference (A->file, op->children, &A->space, &A->local, A->mach, A->atoms))

 			return 0;

 	}

 

diff --git a/src/mesa/shader/slang/slang_assemble_assignment.h b/src/mesa/shader/slang/slang_assemble_assignment.h
index 1dc48b16a77..dfec8b0138f 100644
--- a/src/mesa/shader/slang/slang_assemble_assignment.h
+++ b/src/mesa/shader/slang/slang_assemble_assignment.h
@@ -31,13 +31,9 @@
 extern "C" {

 #endif

 

-int _slang_assemble_assignment (slang_assembly_file *, slang_operation *,

-	slang_assembly_name_space *, slang_assembly_local_info *, slang_assembly_stack_info *,

-	struct slang_machine_ *, slang_atom_pool *);

+int _slang_assemble_assignment (slang_assemble_ctx *, slang_operation *);

 

-int _slang_assemble_assign (slang_assembly_file *, slang_operation *, const char *, int ref,

-	slang_assembly_name_space *, slang_assembly_local_info *, struct slang_machine_ *,

-	slang_atom_pool *);

+int _slang_assemble_assign (slang_assemble_ctx *, slang_operation *, const char *, slang_ref_type);

 

 #ifdef __cplusplus

 }

diff --git a/src/mesa/shader/slang/slang_compile.c b/src/mesa/shader/slang/slang_compile.c
index 11243202db6..eb02ccc1991 100644
--- a/src/mesa/shader/slang/slang_compile.c
+++ b/src/mesa/shader/slang/slang_compile.c
@@ -1489,8 +1489,7 @@ static int parse_function_definition (slang_parse_ctx *C, slang_output_ctx *O, s
 	return 1;
 }

 

-static int initialize_global (slang_assembly_file *file, slang_machine *pmach,

-	slang_assembly_name_space *space, slang_variable *var, slang_atom_pool *atoms)

+static int initialize_global (slang_assemble_ctx *A, slang_variable *var)

 {

 	slang_assembly_file_restore_point point;

 	slang_machine mach;

@@ -1501,20 +1500,20 @@ static int initialize_global (slang_assembly_file *file, slang_machine *pmach,
 	slang_assembly_stack_info stk;

 

 	/* save the current assembly */

-	if (!slang_assembly_file_restore_point_save (file, &point))

+	if (!slang_assembly_file_restore_point_save (A->file, &point))

 		return 0;

 

 	/* setup the machine */

-	mach = *pmach;

-	mach.ip = file->count;

+	mach = *A->mach;

+	mach.ip = A->file->count;

 

 	/* allocate local storage for expression */

 	info.ret_size = 0;

 	info.addr_tmp = 0;

 	info.swizzle_tmp = 4;

-	if (!slang_assembly_file_push_label (file, slang_asm_local_alloc, 20))

+	if (!slang_assembly_file_push_label (A->file, slang_asm_local_alloc, 20))

 		return 0;

-	if (!slang_assembly_file_push_label (file, slang_asm_enter, 20))

+	if (!slang_assembly_file_push_label (A->file, slang_asm_enter, 20))

 		return 0;

 

 	/* construct the left side of assignment */

@@ -1554,7 +1553,7 @@ static int initialize_global (slang_assembly_file *file, slang_machine *pmach,
 	op_assign.children[1] = *var->initializer;

 

 	/* insert the actual expression */

-	result = _slang_assemble_operation (file, &op_assign, 0, &flow, space, &info, &stk, pmach, atoms);

+	result = _slang_assemble_operation (A->file, &op_assign, 0, &flow, &A->space, &info, &stk, A->mach, A->atoms);

 

 	/* carefully destroy the operations */

 	op_assign.num_children = 0;

@@ -1566,19 +1565,19 @@ static int initialize_global (slang_assembly_file *file, slang_machine *pmach,
 

 	if (!result)

 		return 0;

-	if (!slang_assembly_file_push (file, slang_asm_exit))

+	if (!slang_assembly_file_push (A->file, slang_asm_exit))

 		return 0;

 

 	/* execute the expression */

-	if (!_slang_execute2 (file, &mach))

+	if (!_slang_execute2 (A->file, &mach))

 		return 0;

 

 	/* restore the old assembly */

-	if (!slang_assembly_file_restore_point_load (file, &point))

+	if (!slang_assembly_file_restore_point_load (A->file, &point))

 		return 0;

 

 	/* now we copy the contents of the initialized variable back to the original machine */

-	_mesa_memcpy ((GLubyte *) pmach->mem + var->address, (GLubyte *) mach.mem + var->address,

+	_mesa_memcpy ((GLubyte *) A->mach->mem + var->address, (GLubyte *) mach.mem + var->address,

 		var->size);

 

 	return 1;

@@ -1728,12 +1727,15 @@ static int parse_init_declarator (slang_parse_ctx *C, slang_output_ctx *O,
 	/* initialize global variable */

 	if (C->global_scope && var->initializer != NULL)

 	{

-		slang_assembly_name_space space;

-

-		space.funcs = O->funs;

-		space.structs = O->structs;

-		space.vars = O->vars;

-		if (!initialize_global (O->assembly, O->machine, &space, var, C->atoms))

+		slang_assemble_ctx A;

+

+		A.file = O->assembly;

+		A.mach = O->machine;

+		A.atoms = C->atoms;

+		A.space.funcs = O->funs;

+		A.space.structs = O->structs;

+		A.space.vars = O->vars;

+		if (!initialize_global (&A, var))

 			return 0;

 	}
 	return 1;
@@ -1783,7 +1785,7 @@ static int parse_function (slang_parse_ctx *C, slang_output_ctx *O, int definiti
 			return 0;
 		}
 	}
-/*	else
+	else
 	{
 		if (!parse_function_prototype (C, O, &parsed_func))
 		{
@@ -1813,45 +1815,48 @@ static int parse_function (slang_parse_ctx *C, slang_output_ctx *O, int definiti
 		/* return the newly parsed function */
 		*parsed_func_ret = &O->funs->functions[O->funs->num_functions - 1];
 	}
-/*	else
+	else
 	{
 		/* TODO: check function return type qualifiers and specifiers */
-/*		if (definition)
-		{
-			/* destroy the existing function declaration and replace it with the new one */
-/*			if (found_func->body != NULL)
+		if (definition)
+		{

+			if (found_func->body != NULL)
 			{
 				slang_info_log_error (C->L, "%s: function already has a body",
-					parsed_func.header.name);
+					slang_atom_pool_id (C->atoms, parsed_func.header.a_name));
 				slang_function_destruct (&parsed_func);
 				return 0;
-			}
+			}

+

+			/* destroy the existing function declaration and replace it with the new one,

+			 * remember to save the fixup table */

+			parsed_func.fixups = found_func->fixups;

+			slang_fixup_table_init (&found_func->fixups);
 			slang_function_destruct (found_func);
 			*found_func = parsed_func;
 		}
 		else
 		{
 			/* another declaration of the same function prototype - ignore it */
-/*			slang_function_destruct (&parsed_func);
+			slang_function_destruct (&parsed_func);
 		}
 
 		/* return the found function */
-/*		*parsed_func_ret = found_func;
+		*parsed_func_ret = found_func;
 	}
 
 	/* assemble the parsed function */
-	if (definition)
 	{
-		slang_assembly_name_space space;
-

-		space.funcs = O->funs;
-		space.structs = O->structs;
-		space.vars = O->vars;

-		if (!_slang_assemble_function (O->assembly, *parsed_func_ret, &space, O->machine, C->atoms))

-		{

-			const char *name = slang_atom_pool_id (C->atoms, (**parsed_func_ret).header.a_name);
+		slang_assemble_ctx A;
+

+		A.file = O->assembly;

+		A.mach = O->machine;

+		A.atoms = C->atoms;

+		A.space.funcs = O->funs;
+		A.space.structs = O->structs;
+		A.space.vars = O->vars;

+		if (!_slang_assemble_function (&A, *parsed_func_ret))

 			return 0;

-		}
 	}
 	return 1;
 }
diff --git a/src/mesa/shader/slang/slang_compile_function.c b/src/mesa/shader/slang/slang_compile_function.c
index d62b009e662..5edba72cf77 100644
--- a/src/mesa/shader/slang/slang_compile_function.c
+++ b/src/mesa/shader/slang/slang_compile_function.c
@@ -34,6 +34,20 @@
 #include "slang_compile_operation.h"

 #include "slang_compile_function.h"

 

+/* slang_fixup_table */

+

+void slang_fixup_table_init (slang_fixup_table *fix)

+{

+	fix->table = NULL;

+	fix->count = 0;

+}

+

+void slang_fixup_table_free (slang_fixup_table *fix)

+{

+	slang_alloc_free (fix->table);

+	slang_fixup_table_init (fix);

+}

+

 /* slang_function */

 

 int slang_function_construct (slang_function *func)

@@ -56,6 +70,7 @@ int slang_function_construct (slang_function *func)
 	func->param_count = 0;

 	func->body = NULL;

 	func->address = ~0;

+	slang_fixup_table_init (&func->fixups);

 	return 1;

 }

 

@@ -69,6 +84,7 @@ void slang_function_destruct (slang_function *func)
 		slang_operation_destruct (func->body);

 		slang_alloc_free (func->body);

 	}

+	slang_fixup_table_free (&func->fixups);

 }

 

 /* slang_function_scope */

diff --git a/src/mesa/shader/slang/slang_compile_function.h b/src/mesa/shader/slang/slang_compile_function.h
index 59743dfc29e..d1208817cfa 100644
--- a/src/mesa/shader/slang/slang_compile_function.h
+++ b/src/mesa/shader/slang/slang_compile_function.h
@@ -36,6 +36,15 @@ typedef enum slang_function_kind_
 	slang_func_operator

 } slang_function_kind;

 

+typedef struct slang_fixup_table_

+{

+	GLuint *table;

+	GLuint count;

+} slang_fixup_table;

+

+void slang_fixup_table_init (slang_fixup_table *);

+void slang_fixup_table_free (slang_fixup_table *);

+

 typedef struct slang_function_

 {

 	slang_function_kind kind;

@@ -44,6 +53,7 @@ typedef struct slang_function_
 	unsigned int param_count;

 	slang_operation *body;

 	unsigned int address;

+	slang_fixup_table fixups;

 } slang_function;

 

 int slang_function_construct (slang_function *);