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	/*
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	* $Id: generate_ppc_loadstore.c,v 1.4 2005/11/23 06:59:52 debug Exp $
29	*/
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	void do_it(int mode)
40	{
41	int n, load, size, zero, ignoreofs, update;
42
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	if (load && !zero && size == 3) {
220	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	if (load && !zero && size == 3) {
257	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	/* 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	}
343
344	return 0;
345	}
346