1/*
2 * Copyright (C) 2008 Nicolai Haehnle.
3 *
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining
7 * a 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, sublicense, 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
16 * portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 */
27
28#include "radeon_program.h"
29
30#include <stdio.h>
31
32#include "radeon_compiler.h"
33#include "radeon_dataflow.h"
34
35
36/**
37 * Transform the given clause in the following way:
38 *  1. Replace it with an empty clause
39 *  2. For every instruction in the original clause, try the given
40 *     transformations in order.
41 *  3. If one of the transformations returns GL_TRUE, assume that it
42 *     has emitted the appropriate instruction(s) into the new clause;
43 *     otherwise, copy the instruction verbatim.
44 *
45 * \note The transformation is currently not recursive; in other words,
46 * instructions emitted by transformations are not transformed.
47 *
48 * \note The transform is called 'local' because it can only look at
49 * one instruction at a time.
50 */
51void rc_local_transform(
52	struct radeon_compiler * c,
53	void *user)
54{
55	struct radeon_program_transformation *transformations =
56		(struct radeon_program_transformation*)user;
57	struct rc_instruction * inst = c->Program.Instructions.Next;
58
59	while(inst != &c->Program.Instructions) {
60		struct rc_instruction * current = inst;
61		int i;
62
63		inst = inst->Next;
64
65		for(i = 0; transformations[i].function; ++i) {
66			struct radeon_program_transformation* t = transformations + i;
67
68			if (t->function(c, current, t->userData))
69				break;
70		}
71	}
72}
73
74struct get_used_temporaries_data {
75	unsigned char * Used;
76	unsigned int UsedLength;
77};
78
79static void get_used_temporaries_cb(
80	void * userdata,
81	struct rc_instruction * inst,
82	rc_register_file file,
83	unsigned int index,
84	unsigned int mask)
85{
86	struct get_used_temporaries_data * d = userdata;
87
88	if (file != RC_FILE_TEMPORARY)
89		return;
90
91	if (index >= d->UsedLength)
92		return;
93
94	d->Used[index] |= mask;
95}
96
97/**
98 * This function fills in the parameter 'used' with a writemask that
99 * represent which components of each temporary register are used by the
100 * program.  This is meant to be combined with rc_find_free_temporary_list as a
101 * more efficient version of rc_find_free_temporary.
102 * @param used The function does not initialize this parameter.
103 */
104void rc_get_used_temporaries(
105	struct radeon_compiler * c,
106	unsigned char * used,
107	unsigned int used_length)
108{
109	struct rc_instruction * inst;
110	struct get_used_temporaries_data d;
111	d.Used = used;
112	d.UsedLength = used_length;
113
114	for(inst = c->Program.Instructions.Next;
115			inst != &c->Program.Instructions; inst = inst->Next) {
116
117		rc_for_all_reads_mask(inst, get_used_temporaries_cb, &d);
118		rc_for_all_writes_mask(inst, get_used_temporaries_cb, &d);
119	}
120}
121
122/* Search a list of used temporaries for a free one
123 * \sa rc_get_used_temporaries
124 * @note If this functions finds a free temporary, it will mark it as used
125 * in the used temporary list (param 'used')
126 * @param used list of used temporaries
127 * @param used_length number of items in param 'used'
128 * @param mask which components must be free in the temporary index that is
129 * returned.
130 * @return -1 If there are no more free temporaries, otherwise the index of
131 * a temporary register where the components specified in param 'mask' are
132 * not being used.
133 */
134int rc_find_free_temporary_list(
135	struct radeon_compiler * c,
136	unsigned char * used,
137	unsigned int used_length,
138	unsigned int mask)
139{
140	int i;
141	for(i = 0; i < used_length; i++) {
142		if ((~used[i] & mask) == mask) {
143			used[i] |= mask;
144			return i;
145		}
146	}
147	return -1;
148}
149
150unsigned int rc_find_free_temporary(struct radeon_compiler * c)
151{
152	unsigned char used[RC_REGISTER_MAX_INDEX];
153	int free;
154
155	memset(used, 0, sizeof(used));
156
157	rc_get_used_temporaries(c, used, RC_REGISTER_MAX_INDEX);
158
159	free = rc_find_free_temporary_list(c, used, RC_REGISTER_MAX_INDEX,
160								RC_MASK_XYZW);
161	if (free < 0) {
162		rc_error(c, "Ran out of temporary registers\n");
163		return 0;
164	}
165	return free;
166}
167
168
169struct rc_instruction *rc_alloc_instruction(struct radeon_compiler * c)
170{
171	struct rc_instruction * inst = memory_pool_malloc(&c->Pool, sizeof(struct rc_instruction));
172
173	memset(inst, 0, sizeof(struct rc_instruction));
174
175	inst->U.I.Opcode = RC_OPCODE_ILLEGAL_OPCODE;
176	inst->U.I.DstReg.WriteMask = RC_MASK_XYZW;
177	inst->U.I.SrcReg[0].Swizzle = RC_SWIZZLE_XYZW;
178	inst->U.I.SrcReg[1].Swizzle = RC_SWIZZLE_XYZW;
179	inst->U.I.SrcReg[2].Swizzle = RC_SWIZZLE_XYZW;
180
181	return inst;
182}
183
184void rc_insert_instruction(struct rc_instruction * after, struct rc_instruction * inst)
185{
186	inst->Prev = after;
187	inst->Next = after->Next;
188
189	inst->Prev->Next = inst;
190	inst->Next->Prev = inst;
191}
192
193struct rc_instruction *rc_insert_new_instruction(struct radeon_compiler * c, struct rc_instruction * after)
194{
195	struct rc_instruction * inst = rc_alloc_instruction(c);
196
197	rc_insert_instruction(after, inst);
198
199	return inst;
200}
201
202void rc_remove_instruction(struct rc_instruction * inst)
203{
204	inst->Prev->Next = inst->Next;
205	inst->Next->Prev = inst->Prev;
206}
207
208/**
209 * Return the number of instructions in the program.
210 */
211unsigned int rc_recompute_ips(struct radeon_compiler * c)
212{
213	unsigned int ip = 0;
214	struct rc_instruction * inst;
215
216	for(inst = c->Program.Instructions.Next;
217	    inst != &c->Program.Instructions;
218	    inst = inst->Next) {
219		inst->IP = ip++;
220	}
221
222	c->Program.Instructions.IP = 0xcafedead;
223
224	return ip;
225}
226