src/cpus/generate_ppc_loadstore.c

/*
 *  Copyright (C) 2005  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: generate_ppc_loadstore.c,v 1.4 2005/11/23 06:59:52 debug Exp $
 */

#include <stdio.h>
#include <string.h>


char *sizechar[4] = { "b", "h", "w", "d" };
char *modes[2] = { "", "32" };


void do_it(int mode)
{
        int n, load, size, zero, ignoreofs, update;

        n = 0;
        for (update=0; update<=1; update++)
          for (ignoreofs=0; ignoreofs<=1; ignoreofs++)
            for (load=0; load<=1; load++)
                for (zero=0; zero<=1; zero++)
                    for (size=0; size<4; size++) {
                        if (!zero && !load)
                                continue;
                        if (load && !zero && size == 3)
                                continue;

                        switch (size) {
                        case 0: printf("#define LS_B\n"); break;
                        case 1: printf("#define LS_H\n"); break;
                        case 2: printf("#define LS_W\n"); break;
                        case 3: printf("#define LS_D\n"); break;
                        }
                        printf("#define LS_SIZE %i\n", 1 << size);
                        if (zero)
                                printf("#define LS_ZERO\n");
                        if (load)
                                printf("#define LS_LOAD\n");
                        if (ignoreofs)
                                printf("#define LS_IGNOREOFS\n");
                        if (update)
                                printf("#define LS_UPDATE\n");

                        printf("#define LS_GENERIC_N ppc%s_generic_",
                            modes[mode]);
                        if (load)
                                printf("l");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        if (load) {
                                if (zero)
                                        printf("z");
                                else
                                        printf("a");
                        }
                        if (update)
                                printf("u");
                        printf("\n");

                        printf("#define LS_N ppc%s_instr_", modes[mode]);
                        if (load)
                                printf("l");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        if (load && size < 3) {
                                if (zero)
                                        printf("z");
                                else
                                        printf("a");
                        }
                        if (update)
                                printf("u");
                        if (ignoreofs)
                                printf("_0");
                        printf("\n");

                        printf("#include \"cpu_ppc_instr_loadstore.c\"\n");

                        printf("#undef LS_N\n");
                        printf("#undef LS_GENERIC_N\n");
                        switch (size) {
                        case 0: printf("#undef LS_B\n"); break;
                        case 1: printf("#undef LS_H\n"); break;
                        case 2: printf("#undef LS_W\n"); break;
                        case 3: printf("#undef LS_D\n"); break;
                        }
                        printf("#undef LS_SIZE\n");
                        if (load)
                                printf("#undef LS_LOAD\n");
                        if (update)
                                printf("#undef LS_UPDATE\n");
                        if (zero)
                                printf("#undef LS_ZERO\n");
                        if (ignoreofs)
                                printf("#undef LS_IGNOREOFS\n");
                    }

        /*  Indexed loads/stores:  */
        printf("#define LS_INDEXED\n");
        for (update=0; update<=1; update++)
            for (load=0; load<=1; load++)
                for (zero=0; zero<=1; zero++)
                    for (size=0; size<4; size++) {
                        if (!zero && !load)
                                continue;
                        if (load && !zero && size == 3)
                                continue;

                        switch (size) {
                        case 0: printf("#define LS_B\n"); break;
                        case 1: printf("#define LS_H\n"); break;
                        case 2: printf("#define LS_W\n"); break;
                        case 3: printf("#define LS_D\n"); break;
                        }
                        printf("#define LS_SIZE %i\n", 1 << size);
                        if (zero)
                                printf("#define LS_ZERO\n");
                        if (load)
                                printf("#define LS_LOAD\n");
                        if (update)
                                printf("#define LS_UPDATE\n");

                        printf("#define LS_GENERIC_N ppc%s_generic_",
                            modes[mode]);
                        if (load)
                                printf("l");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        if (load) {
                                if (zero)
                                        printf("z");
                                else
                                        printf("a");
                        }
                        if (update)
                                printf("u");
                        printf("x");
                        printf("\n");

                        printf("#define LS_N ppc%s_instr_", modes[mode]);
                        if (load)
                                printf("l");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        if (load && size < 3) {
                                if (zero)
                                        printf("z");
                                else
                                        printf("a");
                        }
                        if (update)
                                printf("u");
                        printf("x");
                        printf("\n");

                        printf("#include \"cpu_ppc_instr_loadstore.c\"\n");

                        printf("#undef LS_N\n");
                        printf("#undef LS_GENERIC_N\n");
                        switch (size) {
                        case 0: printf("#undef LS_B\n"); break;
                        case 1: printf("#undef LS_H\n"); break;
                        case 2: printf("#undef LS_W\n"); break;
                        case 3: printf("#undef LS_D\n"); break;
                        }
                        printf("#undef LS_SIZE\n");
                        if (load)
                                printf("#undef LS_LOAD\n");
                        if (update)
                                printf("#undef LS_UPDATE\n");
                        if (zero)
                                printf("#undef LS_ZERO\n");
                    }

        printf("#undef LS_INDEXED\n");


        /*  Lookup tables for loads/stores:  */
        printf("\n\nvoid (*ppc%s_loadstore[64])(struct cpu *, struct "
            "ppc_instr_call *) = {\n", modes[mode]);
        n = 0;
        for (update=0; update<=1; update++)
          for (ignoreofs=0; ignoreofs<=1; ignoreofs++)
            for (load=0; load<=1; load++)
                for (zero=0; zero<=1; zero++)
                    for (size=0; size<4; size++) {
                        printf("\tppc%s_instr_", modes[mode]);

                        if (load && !zero && size == 3) {
                                printf("invalid");
                                goto cont;
                        }

                        if (load)
                                printf("l");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        if (load && size < 3) {
                                if (zero)
                                        printf("z");
                                else
                                        printf("a");
                        }
                        if (update)
                                printf("u");
                        if (ignoreofs)
                                printf("_0");
cont:
                        if (++n < 64)
                                printf(",");
                        printf("\n");
                    }

        printf("};\n\n");

        printf("\n\nvoid (*ppc%s_loadstore_indexed[32])(struct cpu *, struct "
            "ppc_instr_call *) = {\n", modes[mode]);
        n = 0;
        for (update=0; update<=1; update++)
            for (load=0; load<=1; load++)
                for (zero=0; zero<=1; zero++)
                    for (size=0; size<4; size++) {
                        printf("\tppc%s_instr_", modes[mode]);

                        if (load && !zero && size == 3) {
                                printf("invalid");
                                goto cont_x;
                        }

                        if (load)
                                printf("l");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        if (load && size < 3) {
                                if (zero)
                                        printf("z");
                                else
                                        printf("a");
                        }
                        if (update)
                                printf("u");
                        printf("x");
cont_x:
                        if (++n < 32)
                                printf(",");
                        printf("\n");
                    }

        printf("};\n\n");

        /*  Non-standard loads/stores:  */
        printf("#define LS_BYTEREVERSE\n"
            "#define LS_INDEXED\n"

            "#define LS_SIZE 2\n"
            "#define LS_H\n"
            "#define LS_GENERIC_N ppc%s_generic_lhbrx\n"
            "#define LS_N ppc%s_instr_lhbrx\n"
            "#define LS_LOAD\n"
            "#include \"cpu_ppc_instr_loadstore.c\"\n"
            "#undef LS_LOAD\n"
            "#undef LS_N\n"
            "#undef LS_GENERIC_N\n"
            "#define LS_GENERIC_N ppc%s_generic_sthbrx\n"
            "#define LS_N ppc%s_instr_sthbrx\n"
            "#include \"cpu_ppc_instr_loadstore.c\"\n"
            "#undef LS_N\n"
            "#undef LS_GENERIC_N\n"
            "#undef LS_H\n"
            "#undef LS_SIZE\n"

            "#define LS_SIZE 4\n"
            "#define LS_W\n"
            "#define LS_GENERIC_N ppc%s_generic_lwbrx\n"
            "#define LS_N ppc%s_instr_lwbrx\n"
            "#define LS_LOAD\n"
            "#include \"cpu_ppc_instr_loadstore.c\"\n"
            "#undef LS_LOAD\n"
            "#undef LS_N\n"
            "#undef LS_GENERIC_N\n"
            "#define LS_GENERIC_N ppc%s_generic_stwbrx\n"
            "#define LS_N ppc%s_instr_stwbrx\n"
            "#include \"cpu_ppc_instr_loadstore.c\"\n"
            "#undef LS_N\n"
            "#undef LS_GENERIC_N\n"
            "#undef LS_W\n"
            "#undef LS_SIZE\n"

            "#undef LS_INDEXED\n"
            "#undef LS_BYTEREVERSE\n",
            modes[mode], modes[mode], modes[mode], modes[mode],
            modes[mode], modes[mode], modes[mode], modes[mode]);
}

int main(int argc, char *argv[])
{
        int mode;

        printf("\n/*  AUTOMATICALLY GENERATED! Do not edit.  */\n\n");

        for (mode = 0; mode <= 1; mode ++) {
                if (mode == 0)
                        printf("#ifndef MODE32\n");
                else
                        printf("#ifdef MODE32\n");

                do_it(mode);

                printf("#endif\n");
        }

        return 0;
}

1	dpavlin	14	/*
2			* Copyright (C) 2005 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	20	* $Id: generate_ppc_loadstore.c,v 1.4 2005/11/23 06:59:52 debug Exp $
29	dpavlin	14	*/
30
31			#include <stdio.h>
32			#include <string.h>
33
34
35			char *sizechar[4] = { "b", "h", "w", "d" };
36			char *modes[2] = { "", "32" };
37
38
39	dpavlin	20	void do_it(int mode)
40	dpavlin	14	{
41	dpavlin	20	int n, load, size, zero, ignoreofs, update;
42	dpavlin	14
43			n = 0;
44			for (update=0; update<=1; update++)
45			for (ignoreofs=0; ignoreofs<=1; ignoreofs++)
46			for (load=0; load<=1; load++)
47			for (zero=0; zero<=1; zero++)
48			for (size=0; size<4; size++) {
49			if (!zero && !load)
50			continue;
51			if (load && !zero && size == 3)
52			continue;
53
54			switch (size) {
55			case 0: printf("#define LS_B\n"); break;
56			case 1: printf("#define LS_H\n"); break;
57			case 2: printf("#define LS_W\n"); break;
58			case 3: printf("#define LS_D\n"); break;
59			}
60			printf("#define LS_SIZE %i\n", 1 << size);
61			if (zero)
62			printf("#define LS_ZERO\n");
63			if (load)
64			printf("#define LS_LOAD\n");
65			if (ignoreofs)
66			printf("#define LS_IGNOREOFS\n");
67			if (update)
68			printf("#define LS_UPDATE\n");
69
70			printf("#define LS_GENERIC_N ppc%s_generic_",
71			modes[mode]);
72			if (load)
73			printf("l");
74			else
75			printf("st");
76			printf("%s", sizechar[size]);
77			if (load) {
78			if (zero)
79			printf("z");
80			else
81			printf("a");
82			}
83			if (update)
84			printf("u");
85			printf("\n");
86
87			printf("#define LS_N ppc%s_instr_", modes[mode]);
88			if (load)
89			printf("l");
90			else
91			printf("st");
92			printf("%s", sizechar[size]);
93			if (load && size < 3) {
94			if (zero)
95			printf("z");
96			else
97			printf("a");
98			}
99			if (update)
100			printf("u");
101			if (ignoreofs)
102			printf("_0");
103			printf("\n");
104
105			printf("#include \"cpu_ppc_instr_loadstore.c\"\n");
106
107			printf("#undef LS_N\n");
108			printf("#undef LS_GENERIC_N\n");
109			switch (size) {
110			case 0: printf("#undef LS_B\n"); break;
111			case 1: printf("#undef LS_H\n"); break;
112			case 2: printf("#undef LS_W\n"); break;
113			case 3: printf("#undef LS_D\n"); break;
114			}
115			printf("#undef LS_SIZE\n");
116			if (load)
117			printf("#undef LS_LOAD\n");
118			if (update)
119			printf("#undef LS_UPDATE\n");
120			if (zero)
121			printf("#undef LS_ZERO\n");
122			if (ignoreofs)
123			printf("#undef LS_IGNOREOFS\n");
124			}
125
126			/* Indexed loads/stores: */
127			printf("#define LS_INDEXED\n");
128			for (update=0; update<=1; update++)
129			for (load=0; load<=1; load++)
130			for (zero=0; zero<=1; zero++)
131			for (size=0; size<4; size++) {
132			if (!zero && !load)
133			continue;
134			if (load && !zero && size == 3)
135			continue;
136
137			switch (size) {
138			case 0: printf("#define LS_B\n"); break;
139			case 1: printf("#define LS_H\n"); break;
140			case 2: printf("#define LS_W\n"); break;
141			case 3: printf("#define LS_D\n"); break;
142			}
143			printf("#define LS_SIZE %i\n", 1 << size);
144			if (zero)
145			printf("#define LS_ZERO\n");
146			if (load)
147			printf("#define LS_LOAD\n");
148			if (update)
149			printf("#define LS_UPDATE\n");
150
151			printf("#define LS_GENERIC_N ppc%s_generic_",
152			modes[mode]);
153			if (load)
154			printf("l");
155			else
156			printf("st");
157			printf("%s", sizechar[size]);
158			if (load) {
159			if (zero)
160			printf("z");
161			else
162			printf("a");
163			}
164			if (update)
165			printf("u");
166			printf("x");
167			printf("\n");
168
169			printf("#define LS_N ppc%s_instr_", modes[mode]);
170			if (load)
171			printf("l");
172			else
173			printf("st");
174			printf("%s", sizechar[size]);
175			if (load && size < 3) {
176			if (zero)
177			printf("z");
178			else
179			printf("a");
180			}
181			if (update)
182			printf("u");
183			printf("x");
184			printf("\n");
185
186			printf("#include \"cpu_ppc_instr_loadstore.c\"\n");
187
188			printf("#undef LS_N\n");
189			printf("#undef LS_GENERIC_N\n");
190			switch (size) {
191			case 0: printf("#undef LS_B\n"); break;
192			case 1: printf("#undef LS_H\n"); break;
193			case 2: printf("#undef LS_W\n"); break;
194			case 3: printf("#undef LS_D\n"); break;
195			}
196			printf("#undef LS_SIZE\n");
197			if (load)
198			printf("#undef LS_LOAD\n");
199			if (update)
200			printf("#undef LS_UPDATE\n");
201			if (zero)
202			printf("#undef LS_ZERO\n");
203			}
204
205			printf("#undef LS_INDEXED\n");
206
207
208			/* Lookup tables for loads/stores: */
209			printf("\n\nvoid (ppc%s_loadstore[64])(struct cpu , struct "
210			"ppc_instr_call *) = {\n", modes[mode]);
211			n = 0;
212			for (update=0; update<=1; update++)
213			for (ignoreofs=0; ignoreofs<=1; ignoreofs++)
214			for (load=0; load<=1; load++)
215			for (zero=0; zero<=1; zero++)
216			for (size=0; size<4; size++) {
217			printf("\tppc%s_instr_", modes[mode]);
218
219	dpavlin	20	if (load && !zero && size == 3) {
220	dpavlin	14	printf("invalid");
221			goto cont;
222			}
223
224			if (load)
225			printf("l");
226			else
227			printf("st");
228			printf("%s", sizechar[size]);
229			if (load && size < 3) {
230			if (zero)
231			printf("z");
232			else
233			printf("a");
234			}
235			if (update)
236			printf("u");
237			if (ignoreofs)
238			printf("_0");
239			cont:
240			if (++n < 64)
241			printf(",");
242			printf("\n");
243			}
244
245			printf("};\n\n");
246
247			printf("\n\nvoid (ppc%s_loadstore_indexed[32])(struct cpu , struct "
248			"ppc_instr_call *) = {\n", modes[mode]);
249			n = 0;
250			for (update=0; update<=1; update++)
251			for (load=0; load<=1; load++)
252			for (zero=0; zero<=1; zero++)
253			for (size=0; size<4; size++) {
254			printf("\tppc%s_instr_", modes[mode]);
255
256	dpavlin	20	if (load && !zero && size == 3) {
257	dpavlin	14	printf("invalid");
258			goto cont_x;
259			}
260
261			if (load)
262			printf("l");
263			else
264			printf("st");
265			printf("%s", sizechar[size]);
266			if (load && size < 3) {
267			if (zero)
268			printf("z");
269			else
270			printf("a");
271			}
272			if (update)
273			printf("u");
274			printf("x");
275			cont_x:
276			if (++n < 32)
277			printf(",");
278			printf("\n");
279			}
280
281			printf("};\n\n");
282
283	dpavlin	20	/* Non-standard loads/stores: */
284			printf("#define LS_BYTEREVERSE\n"
285			"#define LS_INDEXED\n"
286
287			"#define LS_SIZE 2\n"
288			"#define LS_H\n"
289			"#define LS_GENERIC_N ppc%s_generic_lhbrx\n"
290			"#define LS_N ppc%s_instr_lhbrx\n"
291			"#define LS_LOAD\n"
292			"#include \"cpu_ppc_instr_loadstore.c\"\n"
293			"#undef LS_LOAD\n"
294			"#undef LS_N\n"
295			"#undef LS_GENERIC_N\n"
296			"#define LS_GENERIC_N ppc%s_generic_sthbrx\n"
297			"#define LS_N ppc%s_instr_sthbrx\n"
298			"#include \"cpu_ppc_instr_loadstore.c\"\n"
299			"#undef LS_N\n"
300			"#undef LS_GENERIC_N\n"
301			"#undef LS_H\n"
302			"#undef LS_SIZE\n"
303
304			"#define LS_SIZE 4\n"
305			"#define LS_W\n"
306			"#define LS_GENERIC_N ppc%s_generic_lwbrx\n"
307			"#define LS_N ppc%s_instr_lwbrx\n"
308			"#define LS_LOAD\n"
309			"#include \"cpu_ppc_instr_loadstore.c\"\n"
310			"#undef LS_LOAD\n"
311			"#undef LS_N\n"
312			"#undef LS_GENERIC_N\n"
313			"#define LS_GENERIC_N ppc%s_generic_stwbrx\n"
314			"#define LS_N ppc%s_instr_stwbrx\n"
315			"#include \"cpu_ppc_instr_loadstore.c\"\n"
316			"#undef LS_N\n"
317			"#undef LS_GENERIC_N\n"
318			"#undef LS_W\n"
319			"#undef LS_SIZE\n"
320
321			"#undef LS_INDEXED\n"
322			"#undef LS_BYTEREVERSE\n",
323			modes[mode], modes[mode], modes[mode], modes[mode],
324			modes[mode], modes[mode], modes[mode], modes[mode]);
325			}
326
327			int main(int argc, char *argv[])
328			{
329			int mode;
330
331			printf("\n/* AUTOMATICALLY GENERATED! Do not edit. */\n\n");
332
333			for (mode = 0; mode <= 1; mode ++) {
334			if (mode == 0)
335			printf("#ifndef MODE32\n");
336			else
337			printf("#ifdef MODE32\n");
338
339			do_it(mode);
340
341			printf("#endif\n");
342	dpavlin	14	}
343
344			return 0;
345			}
346