WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/tgsi/tgsi_build.c

Rev	Author	Line No.	Line
5564	serge	1	/**************************************************************************
		2	*
		3	* Copyright 2007 VMware, Inc.
		4	* All Rights Reserved.
		5	*
		6	* Permission is hereby granted, free of charge, to any person obtaining a
		7	* copy of this software and associated documentation files (the
		8	* "Software"), to deal in the Software without restriction, including
		9	* without limitation the rights to use, copy, modify, merge, publish,
		10	* distribute, sub license, and/or sell copies of the Software, and to
		11	* permit persons to whom the Software is furnished to do so, subject to
		12	* the following conditions:
		13	*
		14	* The above copyright notice and this permission notice (including the
		15	* next paragraph) shall be included in all copies or substantial portions
		16	* of the Software.
		17	*
		18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		19	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
		20	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
		21	* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
		22	* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
		23	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
		24	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		25	*
		26	**************************************************************************/
		27
		28	#include "util/u_debug.h"
		29	#include "pipe/p_format.h"
		30	#include "pipe/p_shader_tokens.h"
		31	#include "tgsi_build.h"
		32	#include "tgsi_parse.h"
		33
		34
		35	/*
		36	* header
		37	*/
		38
		39	struct tgsi_header
		40	tgsi_build_header( void )
		41	{
		42	struct tgsi_header header;
		43
		44	header.HeaderSize = 1;
		45	header.BodySize = 0;
		46
		47	return header;
		48	}
		49
		50	static void
		51	header_headersize_grow( struct tgsi_header *header )
		52	{
		53	assert( header->HeaderSize < 0xFF );
		54	assert( header->BodySize == 0 );
		55
		56	header->HeaderSize++;
		57	}
		58
		59	static void
		60	header_bodysize_grow( struct tgsi_header *header )
		61	{
		62	assert( header->BodySize < 0xFFFFFF );
		63
		64	header->BodySize++;
		65	}
		66
		67	struct tgsi_processor
		68	tgsi_build_processor(
		69	unsigned type,
		70	struct tgsi_header *header )
		71	{
		72	struct tgsi_processor processor;
		73
		74	processor.Processor = type;
		75	processor.Padding = 0;
		76
		77	header_headersize_grow( header );
		78
		79	return processor;
		80	}
		81
		82	/*
		83	* declaration
		84	*/
		85
		86	static void
		87	declaration_grow(
		88	struct tgsi_declaration *declaration,
		89	struct tgsi_header *header )
		90	{
		91	assert( declaration->NrTokens < 0xFF );
		92
		93	declaration->NrTokens++;
		94
		95	header_bodysize_grow( header );
		96	}
		97
		98	static struct tgsi_declaration
		99	tgsi_default_declaration( void )
		100	{
		101	struct tgsi_declaration declaration;
		102
		103	declaration.Type = TGSI_TOKEN_TYPE_DECLARATION;
		104	declaration.NrTokens = 1;
		105	declaration.File = TGSI_FILE_NULL;
		106	declaration.UsageMask = TGSI_WRITEMASK_XYZW;
		107	declaration.Interpolate = 0;
		108	declaration.Dimension = 0;
		109	declaration.Semantic = 0;
		110	declaration.Invariant = 0;
		111	declaration.Local = 0;
		112	declaration.Array = 0;
		113	declaration.Padding = 0;
		114
		115	return declaration;
		116	}
		117
		118	static struct tgsi_declaration
		119	tgsi_build_declaration(
		120	unsigned file,
		121	unsigned usage_mask,
		122	unsigned interpolate,
		123	unsigned dimension,
		124	unsigned semantic,
		125	unsigned invariant,
		126	unsigned local,
		127	unsigned array,
		128	struct tgsi_header *header )
		129	{
		130	struct tgsi_declaration declaration;
		131
		132	assert( file < TGSI_FILE_COUNT );
		133	assert( interpolate < TGSI_INTERPOLATE_COUNT );
		134
		135	declaration = tgsi_default_declaration();
		136	declaration.File = file;
		137	declaration.UsageMask = usage_mask;
		138	declaration.Interpolate = interpolate;
		139	declaration.Dimension = dimension;
		140	declaration.Semantic = semantic;
		141	declaration.Invariant = invariant;
		142	declaration.Local = local;
		143	declaration.Array = array;
		144	header_bodysize_grow( header );
		145
		146	return declaration;
		147	}
		148
		149	static struct tgsi_declaration_range
		150	tgsi_default_declaration_range( void )
		151	{
		152	struct tgsi_declaration_range dr;
		153
		154	dr.First = 0;
		155	dr.Last = 0;
		156
		157	return dr;
		158	}
		159
		160	static struct tgsi_declaration_range
		161	tgsi_build_declaration_range(
		162	unsigned first,
		163	unsigned last,
		164	struct tgsi_declaration *declaration,
		165	struct tgsi_header *header )
		166	{
		167	struct tgsi_declaration_range declaration_range;
		168
		169	assert( last >= first );
		170	assert( last <= 0xFFFF );
		171
		172	declaration_range.First = first;
		173	declaration_range.Last = last;
		174
		175	declaration_grow( declaration, header );
		176
		177	return declaration_range;
		178	}
		179
		180	static struct tgsi_declaration_dimension
		181	tgsi_build_declaration_dimension(unsigned index_2d,
		182	struct tgsi_declaration *declaration,
		183	struct tgsi_header *header)
		184	{
		185	struct tgsi_declaration_dimension dd;
		186
		187	assert(index_2d <= 0xFFFF);
		188
		189	dd.Index2D = index_2d;
		190	dd.Padding = 0;
		191
		192	declaration_grow(declaration, header);
		193
		194	return dd;
		195	}
		196
		197	static struct tgsi_declaration_interp
		198	tgsi_default_declaration_interp( void )
		199	{
		200	struct tgsi_declaration_interp di;
		201
		202	di.Interpolate = TGSI_INTERPOLATE_CONSTANT;
		203	di.Location = TGSI_INTERPOLATE_LOC_CENTER;
		204	di.CylindricalWrap = 0;
		205	di.Padding = 0;
		206
		207	return di;
		208	}
		209
		210	static struct tgsi_declaration_interp
		211	tgsi_build_declaration_interp(unsigned interpolate,
		212	unsigned interpolate_location,
		213	unsigned cylindrical_wrap,
		214	struct tgsi_declaration *declaration,
		215	struct tgsi_header *header)
		216	{
		217	struct tgsi_declaration_interp di;
		218
		219	di.Interpolate = interpolate;
		220	di.Location = interpolate_location;
		221	di.CylindricalWrap = cylindrical_wrap;
		222	di.Padding = 0;
		223
		224	declaration_grow(declaration, header);
		225
		226	return di;
		227	}
		228
		229	static struct tgsi_declaration_semantic
		230	tgsi_default_declaration_semantic( void )
		231	{
		232	struct tgsi_declaration_semantic ds;
		233
		234	ds.Name = TGSI_SEMANTIC_POSITION;
		235	ds.Index = 0;
		236	ds.Padding = 0;
		237
		238	return ds;
		239	}
		240
		241	static struct tgsi_declaration_semantic
		242	tgsi_build_declaration_semantic(
		243	unsigned semantic_name,
		244	unsigned semantic_index,
		245	struct tgsi_declaration *declaration,
		246	struct tgsi_header *header )
		247	{
		248	struct tgsi_declaration_semantic ds;
		249
		250	assert( semantic_name <= TGSI_SEMANTIC_COUNT );
		251	assert( semantic_index <= 0xFFFF );
		252
		253	ds.Name = semantic_name;
		254	ds.Index = semantic_index;
		255	ds.Padding = 0;
		256
		257	declaration_grow( declaration, header );
		258
		259	return ds;
		260	}
		261
		262	static struct tgsi_declaration_resource
		263	tgsi_default_declaration_resource(void)
		264	{
		265	struct tgsi_declaration_resource dr;
		266
		267	dr.Resource = TGSI_TEXTURE_BUFFER;
		268	dr.Raw = 0;
		269	dr.Writable = 0;
		270	dr.Padding = 0;
		271
		272	return dr;
		273	}
		274
		275	static struct tgsi_declaration_resource
		276	tgsi_build_declaration_resource(unsigned texture,
		277	unsigned raw,
		278	unsigned writable,
		279	struct tgsi_declaration *declaration,
		280	struct tgsi_header *header)
		281	{
		282	struct tgsi_declaration_resource dr;
		283
		284	dr = tgsi_default_declaration_resource();
		285	dr.Resource = texture;
		286	dr.Raw = raw;
		287	dr.Writable = writable;
		288
		289	declaration_grow(declaration, header);
		290
		291	return dr;
		292	}
		293
		294	static struct tgsi_declaration_sampler_view
		295	tgsi_default_declaration_sampler_view(void)
		296	{
		297	struct tgsi_declaration_sampler_view dsv;
		298
		299	dsv.Resource = TGSI_TEXTURE_BUFFER;
		300	dsv.ReturnTypeX = TGSI_RETURN_TYPE_UNORM;
		301	dsv.ReturnTypeY = TGSI_RETURN_TYPE_UNORM;
		302	dsv.ReturnTypeZ = TGSI_RETURN_TYPE_UNORM;
		303	dsv.ReturnTypeW = TGSI_RETURN_TYPE_UNORM;
		304
		305	return dsv;
		306	}
		307
		308	static struct tgsi_declaration_sampler_view
		309	tgsi_build_declaration_sampler_view(unsigned texture,
		310	unsigned return_type_x,
		311	unsigned return_type_y,
		312	unsigned return_type_z,
		313	unsigned return_type_w,
		314	struct tgsi_declaration *declaration,
		315	struct tgsi_header *header)
		316	{
		317	struct tgsi_declaration_sampler_view dsv;
		318
		319	dsv = tgsi_default_declaration_sampler_view();
		320	dsv.Resource = texture;
		321	dsv.ReturnTypeX = return_type_x;
		322	dsv.ReturnTypeY = return_type_y;
		323	dsv.ReturnTypeZ = return_type_z;
		324	dsv.ReturnTypeW = return_type_w;
		325
		326	declaration_grow(declaration, header);
		327
		328	return dsv;
		329	}
		330
		331
		332	static struct tgsi_declaration_array
		333	tgsi_default_declaration_array( void )
		334	{
		335	struct tgsi_declaration_array a;
		336
		337	a.ArrayID = 0;
		338	a.Padding = 0;
		339
		340	return a;
		341	}
		342
		343	static struct tgsi_declaration_array
		344	tgsi_build_declaration_array(unsigned arrayid,
		345	struct tgsi_declaration *declaration,
		346	struct tgsi_header *header)
		347	{
		348	struct tgsi_declaration_array da;
		349
		350	da = tgsi_default_declaration_array();
		351	da.ArrayID = arrayid;
		352
		353	declaration_grow(declaration, header);
		354
		355	return da;
		356	}
		357
		358	struct tgsi_full_declaration
		359	tgsi_default_full_declaration( void )
		360	{
		361	struct tgsi_full_declaration full_declaration;
		362
		363	full_declaration.Declaration = tgsi_default_declaration();
		364	full_declaration.Range = tgsi_default_declaration_range();
		365	full_declaration.Semantic = tgsi_default_declaration_semantic();
		366	full_declaration.Interp = tgsi_default_declaration_interp();
		367	full_declaration.Resource = tgsi_default_declaration_resource();
		368	full_declaration.SamplerView = tgsi_default_declaration_sampler_view();
		369	full_declaration.Array = tgsi_default_declaration_array();
		370
		371	return full_declaration;
		372	}
		373
		374	unsigned
		375	tgsi_build_full_declaration(
		376	const struct tgsi_full_declaration *full_decl,
		377	struct tgsi_token *tokens,
		378	struct tgsi_header *header,
		379	unsigned maxsize )
		380	{
		381	unsigned size = 0;
		382	struct tgsi_declaration *declaration;
		383	struct tgsi_declaration_range *dr;
		384
		385	if( maxsize <= size )
		386	return 0;
		387	declaration = (struct tgsi_declaration *) &tokens[size];
		388	size++;
		389
		390	*declaration = tgsi_build_declaration(
		391	full_decl->Declaration.File,
		392	full_decl->Declaration.UsageMask,
		393	full_decl->Declaration.Interpolate,
		394	full_decl->Declaration.Dimension,
		395	full_decl->Declaration.Semantic,
		396	full_decl->Declaration.Invariant,
		397	full_decl->Declaration.Local,
		398	full_decl->Declaration.Array,
		399	header );
		400
		401	if (maxsize <= size)
		402	return 0;
		403	dr = (struct tgsi_declaration_range *) &tokens[size];
		404	size++;
		405
		406	*dr = tgsi_build_declaration_range(
		407	full_decl->Range.First,
		408	full_decl->Range.Last,
		409	declaration,
		410	header );
		411
		412	if (full_decl->Declaration.Dimension) {
		413	struct tgsi_declaration_dimension *dd;
		414
		415	if (maxsize <= size) {
		416	return 0;
		417	}
		418	dd = (struct tgsi_declaration_dimension *)&tokens[size];
		419	size++;
		420
		421	*dd = tgsi_build_declaration_dimension(full_decl->Dim.Index2D,
		422	declaration,
		423	header);
		424	}
		425
		426	if (full_decl->Declaration.Interpolate) {
		427	struct tgsi_declaration_interp *di;
		428
		429	if (maxsize <= size) {
		430	return 0;
		431	}
		432	di = (struct tgsi_declaration_interp *)&tokens[size];
		433	size++;
		434
		435	*di = tgsi_build_declaration_interp(full_decl->Interp.Interpolate,
		436	full_decl->Interp.Location,
		437	full_decl->Interp.CylindricalWrap,
		438	declaration,
		439	header);
		440	}
		441
		442	if( full_decl->Declaration.Semantic ) {
		443	struct tgsi_declaration_semantic *ds;
		444
		445	if( maxsize <= size )
		446	return 0;
		447	ds = (struct tgsi_declaration_semantic *) &tokens[size];
		448	size++;
		449
		450	*ds = tgsi_build_declaration_semantic(
		451	full_decl->Semantic.Name,
		452	full_decl->Semantic.Index,
		453	declaration,
		454	header );
		455	}
		456
		457	if (full_decl->Declaration.File == TGSI_FILE_RESOURCE) {
		458	struct tgsi_declaration_resource *dr;
		459
		460	if (maxsize <= size) {
		461	return 0;
		462	}
		463	dr = (struct tgsi_declaration_resource *)&tokens[size];
		464	size++;
		465
		466	*dr = tgsi_build_declaration_resource(full_decl->Resource.Resource,
		467	full_decl->Resource.Raw,
		468	full_decl->Resource.Writable,
		469	declaration,
		470	header);
		471	}
		472
		473	if (full_decl->Declaration.File == TGSI_FILE_SAMPLER_VIEW) {
		474	struct tgsi_declaration_sampler_view *dsv;
		475
		476	if (maxsize <= size) {
		477	return 0;
		478	}
		479	dsv = (struct tgsi_declaration_sampler_view *)&tokens[size];
		480	size++;
		481
		482	*dsv = tgsi_build_declaration_sampler_view(
		483	full_decl->SamplerView.Resource,
		484	full_decl->SamplerView.ReturnTypeX,
		485	full_decl->SamplerView.ReturnTypeY,
		486	full_decl->SamplerView.ReturnTypeZ,
		487	full_decl->SamplerView.ReturnTypeW,
		488	declaration,
		489	header);
		490	}
		491
		492	if (full_decl->Declaration.Array) {
		493	struct tgsi_declaration_array *da;
		494
		495	if (maxsize <= size) {
		496	return 0;
		497	}
		498	da = (struct tgsi_declaration_array *)&tokens[size];
		499	size++;
		500	*da = tgsi_build_declaration_array(
		501	full_decl->Array.ArrayID,
		502	declaration,
		503	header);
		504	}
		505	return size;
		506	}
		507
		508	/*
		509	* immediate
		510	*/
		511
		512	static struct tgsi_immediate
		513	tgsi_default_immediate( void )
		514	{
		515	struct tgsi_immediate immediate;
		516
		517	immediate.Type = TGSI_TOKEN_TYPE_IMMEDIATE;
		518	immediate.NrTokens = 1;
		519	immediate.DataType = TGSI_IMM_FLOAT32;
		520	immediate.Padding = 0;
		521
		522	return immediate;
		523	}
		524
		525	static struct tgsi_immediate
		526	tgsi_build_immediate(
		527	struct tgsi_header *header,
		528	unsigned type )
		529	{
		530	struct tgsi_immediate immediate;
		531
		532	immediate = tgsi_default_immediate();
		533	immediate.DataType = type;
		534
		535	header_bodysize_grow( header );
		536
		537	return immediate;
		538	}
		539
		540	struct tgsi_full_immediate
		541	tgsi_default_full_immediate( void )
		542	{
		543	struct tgsi_full_immediate fullimm;
		544
		545	fullimm.Immediate = tgsi_default_immediate();
		546	fullimm.u[0].Float = 0.0f;
		547	fullimm.u[1].Float = 0.0f;
		548	fullimm.u[2].Float = 0.0f;
		549	fullimm.u[3].Float = 0.0f;
		550
		551	return fullimm;
		552	}
		553
		554	static void
		555	immediate_grow(
		556	struct tgsi_immediate *immediate,
		557	struct tgsi_header *header )
		558	{
		559	assert( immediate->NrTokens < 0xFF );
		560
		561	immediate->NrTokens++;
		562
		563	header_bodysize_grow( header );
		564	}
		565
		566	unsigned
		567	tgsi_build_full_immediate(
		568	const struct tgsi_full_immediate *full_imm,
		569	struct tgsi_token *tokens,
		570	struct tgsi_header *header,
		571	unsigned maxsize )
		572	{
		573	unsigned size = 0, i;
		574	struct tgsi_immediate *immediate;
		575
		576	if( maxsize <= size )
		577	return 0;
		578	immediate = (struct tgsi_immediate *) &tokens[size];
		579	size++;
		580
		581	*immediate = tgsi_build_immediate( header, full_imm->Immediate.DataType );
		582
		583	assert( full_imm->Immediate.NrTokens <= 4 + 1 );
		584
		585	for( i = 0; i < full_imm->Immediate.NrTokens - 1; i++ ) {
		586	union tgsi_immediate_data *data;
		587
		588	if( maxsize <= size )
		589	return 0;
		590
		591	data = (union tgsi_immediate_data *) &tokens[size];
		592	*data = full_imm->u[i];
		593
		594	immediate_grow( immediate, header );
		595	size++;
		596	}
		597
		598	return size;
		599	}
		600
		601	/*
		602	* instruction
		603	*/
		604
		605	struct tgsi_instruction
		606	tgsi_default_instruction( void )
		607	{
		608	struct tgsi_instruction instruction;
		609
		610	instruction.Type = TGSI_TOKEN_TYPE_INSTRUCTION;
		611	instruction.NrTokens = 0;
		612	instruction.Opcode = TGSI_OPCODE_MOV;
		613	instruction.Saturate = TGSI_SAT_NONE;
		614	instruction.Predicate = 0;
		615	instruction.NumDstRegs = 1;
		616	instruction.NumSrcRegs = 1;
		617	instruction.Label = 0;
		618	instruction.Texture = 0;
		619	instruction.Padding = 0;
		620
		621	return instruction;
		622	}
		623
		624	static struct tgsi_instruction
		625	tgsi_build_instruction(unsigned opcode,
		626	unsigned saturate,
		627	unsigned predicate,
		628	unsigned num_dst_regs,
		629	unsigned num_src_regs,
		630	struct tgsi_header *header)
		631	{
		632	struct tgsi_instruction instruction;
		633
		634	assert (opcode <= TGSI_OPCODE_LAST);
		635	assert (saturate <= TGSI_SAT_MINUS_PLUS_ONE);
		636	assert (num_dst_regs <= 3);
		637	assert (num_src_regs <= 15);
		638
		639	instruction = tgsi_default_instruction();
		640	instruction.Opcode = opcode;
		641	instruction.Saturate = saturate;
		642	instruction.Predicate = predicate;
		643	instruction.NumDstRegs = num_dst_regs;
		644	instruction.NumSrcRegs = num_src_regs;
		645
		646	header_bodysize_grow( header );
		647
		648	return instruction;
		649	}
		650
		651	static void
		652	instruction_grow(
		653	struct tgsi_instruction *instruction,
		654	struct tgsi_header *header )
		655	{
		656	assert (instruction->NrTokens < 0xFF);
		657
		658	instruction->NrTokens++;
		659
		660	header_bodysize_grow( header );
		661	}
		662
		663	struct tgsi_instruction_predicate
		664	tgsi_default_instruction_predicate(void)
		665	{
		666	struct tgsi_instruction_predicate instruction_predicate;
		667
		668	instruction_predicate.SwizzleX = TGSI_SWIZZLE_X;
		669	instruction_predicate.SwizzleY = TGSI_SWIZZLE_Y;
		670	instruction_predicate.SwizzleZ = TGSI_SWIZZLE_Z;
		671	instruction_predicate.SwizzleW = TGSI_SWIZZLE_W;
		672	instruction_predicate.Negate = 0;
		673	instruction_predicate.Index = 0;
		674	instruction_predicate.Padding = 0;
		675
		676	return instruction_predicate;
		677	}
		678
		679	static struct tgsi_instruction_predicate
		680	tgsi_build_instruction_predicate(int index,
		681	unsigned negate,
		682	unsigned swizzleX,
		683	unsigned swizzleY,
		684	unsigned swizzleZ,
		685	unsigned swizzleW,
		686	struct tgsi_instruction *instruction,
		687	struct tgsi_header *header)
		688	{
		689	struct tgsi_instruction_predicate instruction_predicate;
		690
		691	instruction_predicate = tgsi_default_instruction_predicate();
		692	instruction_predicate.SwizzleX = swizzleX;
		693	instruction_predicate.SwizzleY = swizzleY;
		694	instruction_predicate.SwizzleZ = swizzleZ;
		695	instruction_predicate.SwizzleW = swizzleW;
		696	instruction_predicate.Negate = negate;
		697	instruction_predicate.Index = index;
		698
		699	instruction_grow(instruction, header);
		700
		701	return instruction_predicate;
		702	}
		703
		704	static struct tgsi_instruction_label
		705	tgsi_default_instruction_label( void )
		706	{
		707	struct tgsi_instruction_label instruction_label;
		708
		709	instruction_label.Label = 0;
		710	instruction_label.Padding = 0;
		711
		712	return instruction_label;
		713	}
		714
		715	static struct tgsi_instruction_label
		716	tgsi_build_instruction_label(
		717	unsigned label,
		718	struct tgsi_token *prev_token,
		719	struct tgsi_instruction *instruction,
		720	struct tgsi_header *header )
		721	{
		722	struct tgsi_instruction_label instruction_label;
		723
		724	instruction_label.Label = label;
		725	instruction_label.Padding = 0;
		726	instruction->Label = 1;
		727
		728	instruction_grow( instruction, header );
		729
		730	return instruction_label;
		731	}
		732
		733	static struct tgsi_instruction_texture
		734	tgsi_default_instruction_texture( void )
		735	{
		736	struct tgsi_instruction_texture instruction_texture;
		737
		738	instruction_texture.Texture = TGSI_TEXTURE_UNKNOWN;
		739	instruction_texture.NumOffsets = 0;
		740	instruction_texture.Padding = 0;
		741
		742	return instruction_texture;
		743	}
		744
		745	static struct tgsi_instruction_texture
		746	tgsi_build_instruction_texture(
		747	unsigned texture,
		748	unsigned num_offsets,
		749	struct tgsi_token *prev_token,
		750	struct tgsi_instruction *instruction,
		751	struct tgsi_header *header )
		752	{
		753	struct tgsi_instruction_texture instruction_texture;
		754
		755	instruction_texture.Texture = texture;
		756	instruction_texture.NumOffsets = num_offsets;
		757	instruction_texture.Padding = 0;
		758	instruction->Texture = 1;
		759
		760	instruction_grow( instruction, header );
		761
		762	return instruction_texture;
		763	}
		764
		765
		766	static struct tgsi_texture_offset
		767	tgsi_default_texture_offset( void )
		768	{
		769	struct tgsi_texture_offset texture_offset;
		770
		771	texture_offset.Index = 0;
		772	texture_offset.File = 0;
		773	texture_offset.SwizzleX = 0;
		774	texture_offset.SwizzleY = 0;
		775	texture_offset.SwizzleZ = 0;
		776	texture_offset.Padding = 0;
		777
		778	return texture_offset;
		779	}
		780
		781	static struct tgsi_texture_offset
		782	tgsi_build_texture_offset(
		783	int index, int file, int swizzle_x, int swizzle_y, int swizzle_z,
		784	struct tgsi_token *prev_token,
		785	struct tgsi_instruction *instruction,
		786	struct tgsi_header *header )
		787	{
		788	struct tgsi_texture_offset texture_offset;
		789
		790	texture_offset.Index = index;
		791	texture_offset.File = file;
		792	texture_offset.SwizzleX = swizzle_x;
		793	texture_offset.SwizzleY = swizzle_y;
		794	texture_offset.SwizzleZ = swizzle_z;
		795	texture_offset.Padding = 0;
		796
		797	instruction_grow( instruction, header );
		798
		799	return texture_offset;
		800	}
		801
		802	static struct tgsi_src_register
		803	tgsi_default_src_register( void )
		804	{
		805	struct tgsi_src_register src_register;
		806
		807	src_register.File = TGSI_FILE_NULL;
		808	src_register.SwizzleX = TGSI_SWIZZLE_X;
		809	src_register.SwizzleY = TGSI_SWIZZLE_Y;
		810	src_register.SwizzleZ = TGSI_SWIZZLE_Z;
		811	src_register.SwizzleW = TGSI_SWIZZLE_W;
		812	src_register.Negate = 0;
		813	src_register.Absolute = 0;
		814	src_register.Indirect = 0;
		815	src_register.Dimension = 0;
		816	src_register.Index = 0;
		817
		818	return src_register;
		819	}
		820
		821	static struct tgsi_src_register
		822	tgsi_build_src_register(
		823	unsigned file,
		824	unsigned swizzle_x,
		825	unsigned swizzle_y,
		826	unsigned swizzle_z,
		827	unsigned swizzle_w,
		828	unsigned negate,
		829	unsigned absolute,
		830	unsigned indirect,
		831	unsigned dimension,
		832	int index,
		833	struct tgsi_instruction *instruction,
		834	struct tgsi_header *header )
		835	{
		836	struct tgsi_src_register src_register;
		837
		838	assert( file < TGSI_FILE_COUNT );
		839	assert( swizzle_x <= TGSI_SWIZZLE_W );
		840	assert( swizzle_y <= TGSI_SWIZZLE_W );
		841	assert( swizzle_z <= TGSI_SWIZZLE_W );
		842	assert( swizzle_w <= TGSI_SWIZZLE_W );
		843	assert( negate <= 1 );
		844	assert( index >= -0x8000 && index <= 0x7FFF );
		845
		846	src_register.File = file;
		847	src_register.SwizzleX = swizzle_x;
		848	src_register.SwizzleY = swizzle_y;
		849	src_register.SwizzleZ = swizzle_z;
		850	src_register.SwizzleW = swizzle_w;
		851	src_register.Negate = negate;
		852	src_register.Absolute = absolute;
		853	src_register.Indirect = indirect;
		854	src_register.Dimension = dimension;
		855	src_register.Index = index;
		856
		857	instruction_grow( instruction, header );
		858
		859	return src_register;
		860	}
		861
		862	static struct tgsi_ind_register
		863	tgsi_default_ind_register( void )
		864	{
		865	struct tgsi_ind_register ind_register;
		866
		867	ind_register.File = TGSI_FILE_NULL;
		868	ind_register.Index = 0;
		869	ind_register.Swizzle = TGSI_SWIZZLE_X;
		870	ind_register.ArrayID = 0;
		871
		872	return ind_register;
		873	}
		874
		875	static struct tgsi_ind_register
		876	tgsi_build_ind_register(
		877	unsigned file,
		878	unsigned swizzle,
		879	int index,
		880	unsigned arrayid,
		881	struct tgsi_instruction *instruction,
		882	struct tgsi_header *header )
		883	{
		884	struct tgsi_ind_register ind_register;
		885
		886	assert( file < TGSI_FILE_COUNT );
		887	assert( swizzle <= TGSI_SWIZZLE_W );
		888	assert( index >= -0x8000 && index <= 0x7FFF );
		889
		890	ind_register.File = file;
		891	ind_register.Swizzle = swizzle;
		892	ind_register.Index = index;
		893	ind_register.ArrayID = arrayid;
		894
		895	instruction_grow( instruction, header );
		896
		897	return ind_register;
		898	}
		899
		900	static struct tgsi_dimension
		901	tgsi_default_dimension( void )
		902	{
		903	struct tgsi_dimension dimension;
		904
		905	dimension.Indirect = 0;
		906	dimension.Dimension = 0;
		907	dimension.Padding = 0;
		908	dimension.Index = 0;
		909
		910	return dimension;
		911	}
		912
		913	static struct tgsi_full_src_register
		914	tgsi_default_full_src_register( void )
		915	{
		916	struct tgsi_full_src_register full_src_register;
		917
		918	full_src_register.Register = tgsi_default_src_register();
		919	full_src_register.Indirect = tgsi_default_ind_register();
		920	full_src_register.Dimension = tgsi_default_dimension();
		921	full_src_register.DimIndirect = tgsi_default_ind_register();
		922
		923	return full_src_register;
		924	}
		925
		926	static struct tgsi_dimension
		927	tgsi_build_dimension(
		928	unsigned indirect,
		929	unsigned index,
		930	struct tgsi_instruction *instruction,
		931	struct tgsi_header *header )
		932	{
		933	struct tgsi_dimension dimension;
		934
		935	dimension.Indirect = indirect;
		936	dimension.Dimension = 0;
		937	dimension.Padding = 0;
		938	dimension.Index = index;
		939
		940	instruction_grow( instruction, header );
		941
		942	return dimension;
		943	}
		944
		945	static struct tgsi_dst_register
		946	tgsi_default_dst_register( void )
		947	{
		948	struct tgsi_dst_register dst_register;
		949
		950	dst_register.File = TGSI_FILE_NULL;
		951	dst_register.WriteMask = TGSI_WRITEMASK_XYZW;
		952	dst_register.Indirect = 0;
		953	dst_register.Dimension = 0;
		954	dst_register.Index = 0;
		955	dst_register.Padding = 0;
		956
		957	return dst_register;
		958	}
		959
		960	static struct tgsi_dst_register
		961	tgsi_build_dst_register(
		962	unsigned file,
		963	unsigned mask,
		964	unsigned indirect,
		965	unsigned dimension,
		966	int index,
		967	struct tgsi_instruction *instruction,
		968	struct tgsi_header *header )
		969	{
		970	struct tgsi_dst_register dst_register;
		971
		972	assert( file < TGSI_FILE_COUNT );
		973	assert( mask <= TGSI_WRITEMASK_XYZW );
		974	assert( index >= -32768 && index <= 32767 );
		975
		976	dst_register.File = file;
		977	dst_register.WriteMask = mask;
		978	dst_register.Indirect = indirect;
		979	dst_register.Dimension = dimension;
		980	dst_register.Index = index;
		981	dst_register.Padding = 0;
		982
		983	instruction_grow( instruction, header );
		984
		985	return dst_register;
		986	}
		987
		988	static struct tgsi_full_dst_register
		989	tgsi_default_full_dst_register( void )
		990	{
		991	struct tgsi_full_dst_register full_dst_register;
		992
		993	full_dst_register.Register = tgsi_default_dst_register();
		994	full_dst_register.Indirect = tgsi_default_ind_register();
		995	full_dst_register.Dimension = tgsi_default_dimension();
		996	full_dst_register.DimIndirect = tgsi_default_ind_register();
		997
		998	return full_dst_register;
		999	}
		1000
		1001	struct tgsi_full_instruction
		1002	tgsi_default_full_instruction( void )
		1003	{
		1004	struct tgsi_full_instruction full_instruction;
		1005	unsigned i;
		1006
		1007	full_instruction.Instruction = tgsi_default_instruction();
		1008	full_instruction.Predicate = tgsi_default_instruction_predicate();
		1009	full_instruction.Label = tgsi_default_instruction_label();
		1010	full_instruction.Texture = tgsi_default_instruction_texture();
		1011	for( i = 0; i < TGSI_FULL_MAX_TEX_OFFSETS; i++ ) {
		1012	full_instruction.TexOffsets[i] = tgsi_default_texture_offset();
		1013	}
		1014	for( i = 0; i < TGSI_FULL_MAX_DST_REGISTERS; i++ ) {
		1015	full_instruction.Dst[i] = tgsi_default_full_dst_register();
		1016	}
		1017	for( i = 0; i < TGSI_FULL_MAX_SRC_REGISTERS; i++ ) {
		1018	full_instruction.Src[i] = tgsi_default_full_src_register();
		1019	}
		1020
		1021	return full_instruction;
		1022	}
		1023
		1024	unsigned
		1025	tgsi_build_full_instruction(
		1026	const struct tgsi_full_instruction *full_inst,
		1027	struct tgsi_token *tokens,
		1028	struct tgsi_header *header,
		1029	unsigned maxsize )
		1030	{
		1031	unsigned size = 0;
		1032	unsigned i;
		1033	struct tgsi_instruction *instruction;
		1034	struct tgsi_token *prev_token;
		1035
		1036	if( maxsize <= size )
		1037	return 0;
		1038	instruction = (struct tgsi_instruction *) &tokens[size];
		1039	size++;
		1040
		1041	*instruction = tgsi_build_instruction(full_inst->Instruction.Opcode,
		1042	full_inst->Instruction.Saturate,
		1043	full_inst->Instruction.Predicate,
		1044	full_inst->Instruction.NumDstRegs,
		1045	full_inst->Instruction.NumSrcRegs,
		1046	header);
		1047	prev_token = (struct tgsi_token *) instruction;
		1048
		1049	if (full_inst->Instruction.Predicate) {
		1050	struct tgsi_instruction_predicate *instruction_predicate;
		1051
		1052	if (maxsize <= size) {
		1053	return 0;
		1054	}
		1055	instruction_predicate = (struct tgsi_instruction_predicate *)&tokens[size];
		1056	size++;
		1057
		1058	*instruction_predicate =
		1059	tgsi_build_instruction_predicate(full_inst->Predicate.Index,
		1060	full_inst->Predicate.Negate,
		1061	full_inst->Predicate.SwizzleX,
		1062	full_inst->Predicate.SwizzleY,
		1063	full_inst->Predicate.SwizzleZ,
		1064	full_inst->Predicate.SwizzleW,
		1065	instruction,
		1066	header);
		1067	}
		1068
		1069	if (full_inst->Instruction.Label) {
		1070	struct tgsi_instruction_label *instruction_label;
		1071
		1072	if( maxsize <= size )
		1073	return 0;
		1074	instruction_label =
		1075	(struct tgsi_instruction_label *) &tokens[size];
		1076	size++;
		1077
		1078	*instruction_label = tgsi_build_instruction_label(
		1079	full_inst->Label.Label,
		1080	prev_token,
		1081	instruction,
		1082	header );
		1083	prev_token = (struct tgsi_token *) instruction_label;
		1084	}
		1085
		1086	if (full_inst->Instruction.Texture) {
		1087	struct tgsi_instruction_texture *instruction_texture;
		1088
		1089	if( maxsize <= size )
		1090	return 0;
		1091	instruction_texture =
		1092	(struct tgsi_instruction_texture *) &tokens[size];
		1093	size++;
		1094
		1095	*instruction_texture = tgsi_build_instruction_texture(
		1096	full_inst->Texture.Texture,
		1097	full_inst->Texture.NumOffsets,
		1098	prev_token,
		1099	instruction,
		1100	header );
		1101	prev_token = (struct tgsi_token *) instruction_texture;
		1102
		1103	for (i = 0; i < full_inst->Texture.NumOffsets; i++) {
		1104	struct tgsi_texture_offset *texture_offset;
		1105
		1106	if ( maxsize <= size )
		1107	return 0;
		1108	texture_offset = (struct tgsi_texture_offset *)&tokens[size];
		1109	size++;
		1110	*texture_offset = tgsi_build_texture_offset(
		1111	full_inst->TexOffsets[i].Index,
		1112	full_inst->TexOffsets[i].File,
		1113	full_inst->TexOffsets[i].SwizzleX,
		1114	full_inst->TexOffsets[i].SwizzleY,
		1115	full_inst->TexOffsets[i].SwizzleZ,
		1116	prev_token,
		1117	instruction,
		1118	header);
		1119	prev_token = (struct tgsi_token *) texture_offset;
		1120	}
		1121	}
		1122	for( i = 0; i < full_inst->Instruction.NumDstRegs; i++ ) {
		1123	const struct tgsi_full_dst_register *reg = &full_inst->Dst[i];
		1124	struct tgsi_dst_register *dst_register;
		1125
		1126	if( maxsize <= size )
		1127	return 0;
		1128	dst_register = (struct tgsi_dst_register *) &tokens[size];
		1129	size++;
		1130
		1131	*dst_register = tgsi_build_dst_register(
		1132	reg->Register.File,
		1133	reg->Register.WriteMask,
		1134	reg->Register.Indirect,
		1135	reg->Register.Dimension,
		1136	reg->Register.Index,
		1137	instruction,
		1138	header );
		1139
		1140	if( reg->Register.Indirect ) {
		1141	struct tgsi_ind_register *ind;
		1142
		1143	if( maxsize <= size )
		1144	return 0;
		1145	ind = (struct tgsi_ind_register *) &tokens[size];
		1146	size++;
		1147
		1148	*ind = tgsi_build_ind_register(
		1149	reg->Indirect.File,
		1150	reg->Indirect.Swizzle,
		1151	reg->Indirect.Index,
		1152	reg->Indirect.ArrayID,
		1153	instruction,
		1154	header );
		1155	}
		1156
		1157	if( reg->Register.Dimension ) {
		1158	struct tgsi_dimension *dim;
		1159
		1160	assert( !reg->Dimension.Dimension );
		1161
		1162	if( maxsize <= size )
		1163	return 0;
		1164	dim = (struct tgsi_dimension *) &tokens[size];
		1165	size++;
		1166
		1167	*dim = tgsi_build_dimension(
		1168	reg->Dimension.Indirect,
		1169	reg->Dimension.Index,
		1170	instruction,
		1171	header );
		1172
		1173	if( reg->Dimension.Indirect ) {
		1174	struct tgsi_ind_register *ind;
		1175
		1176	if( maxsize <= size )
		1177	return 0;
		1178	ind = (struct tgsi_ind_register *) &tokens[size];
		1179	size++;
		1180
		1181	*ind = tgsi_build_ind_register(
		1182	reg->DimIndirect.File,
		1183	reg->DimIndirect.Swizzle,
		1184	reg->DimIndirect.Index,
		1185	reg->DimIndirect.ArrayID,
		1186	instruction,
		1187	header );
		1188	}
		1189	}
		1190	}
		1191
		1192	for( i = 0; i < full_inst->Instruction.NumSrcRegs; i++ ) {
		1193	const struct tgsi_full_src_register *reg = &full_inst->Src[i];
		1194	struct tgsi_src_register *src_register;
		1195
		1196	if( maxsize <= size )
		1197	return 0;
		1198	src_register = (struct tgsi_src_register *) &tokens[size];
		1199	size++;
		1200
		1201	*src_register = tgsi_build_src_register(
		1202	reg->Register.File,
		1203	reg->Register.SwizzleX,
		1204	reg->Register.SwizzleY,
		1205	reg->Register.SwizzleZ,
		1206	reg->Register.SwizzleW,
		1207	reg->Register.Negate,
		1208	reg->Register.Absolute,
		1209	reg->Register.Indirect,
		1210	reg->Register.Dimension,
		1211	reg->Register.Index,
		1212	instruction,
		1213	header );
		1214
		1215	if( reg->Register.Indirect ) {
		1216	struct tgsi_ind_register *ind;
		1217
		1218	if( maxsize <= size )
		1219	return 0;
		1220	ind = (struct tgsi_ind_register *) &tokens[size];
		1221	size++;
		1222
		1223	*ind = tgsi_build_ind_register(
		1224	reg->Indirect.File,
		1225	reg->Indirect.Swizzle,
		1226	reg->Indirect.Index,
		1227	reg->Indirect.ArrayID,
		1228	instruction,
		1229	header );
		1230	}
		1231
		1232	if( reg->Register.Dimension ) {
		1233	struct tgsi_dimension *dim;
		1234
		1235	assert( !reg->Dimension.Dimension );
		1236
		1237	if( maxsize <= size )
		1238	return 0;
		1239	dim = (struct tgsi_dimension *) &tokens[size];
		1240	size++;
		1241
		1242	*dim = tgsi_build_dimension(
		1243	reg->Dimension.Indirect,
		1244	reg->Dimension.Index,
		1245	instruction,
		1246	header );
		1247
		1248	if( reg->Dimension.Indirect ) {
		1249	struct tgsi_ind_register *ind;
		1250
		1251	if( maxsize <= size )
		1252	return 0;
		1253	ind = (struct tgsi_ind_register *) &tokens[size];
		1254	size++;
		1255
		1256	*ind = tgsi_build_ind_register(
		1257	reg->DimIndirect.File,
		1258	reg->DimIndirect.Swizzle,
		1259	reg->DimIndirect.Index,
		1260	reg->DimIndirect.ArrayID,
		1261	instruction,
		1262	header );
		1263	}
		1264	}
		1265	}
		1266
		1267	return size;
		1268	}
		1269
		1270	static struct tgsi_property
		1271	tgsi_default_property( void )
		1272	{
		1273	struct tgsi_property property;
		1274
		1275	property.Type = TGSI_TOKEN_TYPE_PROPERTY;
		1276	property.NrTokens = 1;
		1277	property.PropertyName = TGSI_PROPERTY_GS_INPUT_PRIM;
		1278	property.Padding = 0;
		1279
		1280	return property;
		1281	}
		1282
		1283	static struct tgsi_property
		1284	tgsi_build_property(unsigned property_name,
		1285	struct tgsi_header *header)
		1286	{
		1287	struct tgsi_property property;
		1288
		1289	property = tgsi_default_property();
		1290	property.PropertyName = property_name;
		1291
		1292	header_bodysize_grow( header );
		1293
		1294	return property;
		1295	}
		1296
		1297
		1298	struct tgsi_full_property
		1299	tgsi_default_full_property( void )
		1300	{
		1301	struct tgsi_full_property full_property;
		1302
		1303	full_property.Property = tgsi_default_property();
		1304	memset(full_property.u, 0,
		1305	sizeof(struct tgsi_property_data) * 8);
		1306
		1307	return full_property;
		1308	}
		1309
		1310	static void
		1311	property_grow(
		1312	struct tgsi_property *property,
		1313	struct tgsi_header *header )
		1314	{
		1315	assert( property->NrTokens < 0xFF );
		1316
		1317	property->NrTokens++;
		1318
		1319	header_bodysize_grow( header );
		1320	}
		1321
		1322	static struct tgsi_property_data
		1323	tgsi_build_property_data(
		1324	unsigned value,
		1325	struct tgsi_property *property,
		1326	struct tgsi_header *header )
		1327	{
		1328	struct tgsi_property_data property_data;
		1329
		1330	property_data.Data = value;
		1331
		1332	property_grow( property, header );
		1333
		1334	return property_data;
		1335	}
		1336
		1337	unsigned
		1338	tgsi_build_full_property(
		1339	const struct tgsi_full_property *full_prop,
		1340	struct tgsi_token *tokens,
		1341	struct tgsi_header *header,
		1342	unsigned maxsize )
		1343	{
		1344	unsigned size = 0, i;
		1345	struct tgsi_property *property;
		1346
		1347	if( maxsize <= size )
		1348	return 0;
		1349	property = (struct tgsi_property *) &tokens[size];
		1350	size++;
		1351
		1352	*property = tgsi_build_property(
		1353	full_prop->Property.PropertyName,
		1354	header );
		1355
		1356	assert( full_prop->Property.NrTokens <= 8 + 1 );
		1357
		1358	for( i = 0; i < full_prop->Property.NrTokens - 1; i++ ) {
		1359	struct tgsi_property_data *data;
		1360
		1361	if( maxsize <= size )
		1362	return 0;
		1363	data = (struct tgsi_property_data *) &tokens[size];
		1364	size++;
		1365
		1366	*data = tgsi_build_property_data(
		1367	full_prop->u[i].Data,
		1368	property,
		1369	header );
		1370	}
		1371
		1372	return size;
		1373	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/tgsi/tgsi_build.c – Rev 5564