src/cpus/generate_alpha_misc.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_alpha_misc.c,v 1.1 2005/08/29 14:36:41 debug Exp $
 */

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


char *sizechar[4] = { "b", "w", "l", "q" };

#define N_CMPS  5
char *cmps[N_CMPS] = { "ult", "eq", "ule", "lt", "le" /*bge*/ };
#define N_CMOV  8
char *cmov[N_CMOV] = { "lbs", "lbc", "eq", "ne", "lt", "ge", "le", "gt" };


int main(int argc, char *argv[])
{
        int load, size, zero, aligncheck, n, msk, llsc;
        int ra, rc, lo, scale, imm, not, op, quad;

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

        n = 0;
        /*  add and sub:  */
        for (imm = 0; imm <= 1; imm ++)
          for (quad = 0; quad <= 1; quad ++)
            for (scale = 0; scale <= 8; scale += 4)
                for (op = 0; op <= 1; op ++) {
                        printf("#define ALU_N alpha_instr_");
                        if (scale)
                                printf("s%i", scale);
                        printf("%s%s", op? "sub" : "add", quad? "q" : "l");
                        if (imm)
                                printf("_imm");
                        printf("\n");

                        if (imm)
                                printf("#define ALU_IMM\n");
                        if (!quad)
                                printf("#define ALU_LONG\n");
                        if (op)
                                printf("#define ALU_SUB\n");
                        else
                                printf("#define ALU_ADD\n");
                        if (scale)
                                printf("#define ALU_S%i\n", scale);

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

                        if (imm)
                                printf("#undef ALU_IMM\n");
                        if (!quad)
                                printf("#undef ALU_LONG\n");
                        if (op)
                                printf("#undef ALU_SUB\n");
                        else
                                printf("#undef ALU_ADD\n");
                        if (scale)
                                printf("#undef ALU_S%i\n", scale);

                        printf("#undef ALU_N\n");
                }

        /*  and, or, xor, zap, sll, srl, sra:  */
        for (imm = 0; imm <= 1; imm ++)
            for (not = 0; not <= 1; not ++)
                for (op = 0; op < 7; op ++) {
                        if (op >= 4 && not)
                                continue;
                        printf("#define ALU_N alpha_instr_");
                        switch (op) {
                        case 0: printf("and"); break;
                        case 1: printf("or"); break;
                        case 2: printf("xor"); break;
                        case 3: printf("zap"); break;
                        case 4: printf("sll"); break;
                        case 5: printf("srl"); break;
                        case 6: printf("sra"); break;
                        }
                        if (not)
                                printf("not");
                        if (imm)
                                printf("_imm");
                        printf("\n");
                        if (imm)
                                printf("#define ALU_IMM\n");
                        switch (op) {
                        case 0: printf("#define ALU_AND\n"); break;
                        case 1: printf("#define ALU_OR\n"); break;
                        case 2: printf("#define ALU_XOR\n"); break;
                        case 3: printf("#define ALU_ZAP\n"); break;
                        case 4: printf("#define ALU_SLL\n"); break;
                        case 5: printf("#define ALU_SRL\n"); break;
                        case 6: printf("#define ALU_SRA\n"); break;
                        }
                        if (not)
                                printf("#define ALU_NOT\n");
                        printf("#include \"cpu_alpha_instr_alu.c\"\n");

                        if (imm)
                                printf("#undef ALU_IMM\n");
                        if (not)
                                printf("#undef ALU_NOT\n");
                        switch (op) {
                        case 0: printf("#undef ALU_AND\n"); break;
                        case 1: printf("#undef ALU_OR\n"); break;
                        case 2: printf("#undef ALU_XOR\n"); break;
                        case 3: printf("#undef ALU_ZAP\n"); break;
                        case 4: printf("#undef ALU_SLL\n"); break;
                        case 5: printf("#undef ALU_SRL\n"); break;
                        case 6: printf("#undef ALU_SRA\n"); break;
                        }

                        printf("#undef ALU_N\n");
                }

        printf("#define ALU_CMP\n");
        for (imm = 0; imm <= 1; imm ++)
            for (op = 0; op < N_CMPS; op ++) {
                printf("#define ALU_N alpha_instr_cmp%s", cmps[op]);
                if (imm)
                        printf("_imm");
                printf("\n");

                if (imm)
                        printf("#define ALU_IMM\n");

                if (cmps[op][0] == 'u')
                        printf("#define ALU_UNSIGNED\n");
                if (strcmp(cmps[op]+strlen(cmps[op])-2,"lt") == 0)
                        printf("#define ALU_CMP_LT\n");
                if (strcmp(cmps[op]+strlen(cmps[op])-2,"le") == 0)
                        printf("#define ALU_CMP_LE\n");
                if (strcmp(cmps[op]+strlen(cmps[op])-2,"eq") == 0)
                        printf("#define ALU_CMP_EQ\n");

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

                if (cmps[op][0] == 'u')
                        printf("#undef ALU_UNSIGNED\n");
                if (strcmp(cmps[op]+strlen(cmps[op])-2,"lt") == 0)
                        printf("#undef ALU_CMP_LT\n");
                if (strcmp(cmps[op]+strlen(cmps[op])-2,"le") == 0)
                        printf("#undef ALU_CMP_LE\n");
                if (strcmp(cmps[op]+strlen(cmps[op])-2,"eq") == 0)
                        printf("#undef ALU_CMP_EQ\n");
                if (imm)
                        printf("#undef ALU_IMM\n");
                printf("#undef ALU_N\n");
            }
        printf("#undef ALU_CMP\n");

        printf("#define ALU_CMOV\n");
        for (imm = 0; imm <= 1; imm ++)
            for (op = 0; op < N_CMOV; op ++) {
                printf("#define ALU_N alpha_instr_cmov%s", cmov[op]);
                if (imm)
                        printf("_imm");
                printf("\n");
                if (imm)
                        printf("#define ALU_IMM\n");
                printf("#define ALU_CMOV_%s\n", cmov[op]);
                printf("#include \"cpu_alpha_instr_alu.c\"\n");
                printf("#undef ALU_CMOV_%s\n", cmov[op]);
                if (imm)
                        printf("#undef ALU_IMM\n");
                printf("#undef ALU_N\n");
            }
        printf("#undef ALU_CMOV\n");

        for (imm = 0; imm <= 1; imm ++)
          for (lo = 0; lo <= 1; lo ++)
           for (msk = 0; msk <= 2; msk ++)
            for (size=0; size<4; size++) {
                if (size==0 && lo==0)
                        continue;
                switch (msk) {
                case 0: printf("#define ALU_MSK\n"); break;
                case 1: printf("#define ALU_EXT\n"); break;
                case 2: printf("#define ALU_INS\n"); break;
                }
                switch (msk) {
                case 0: printf("#define ALU_N alpha_instr_msk"); break;
                case 1: printf("#define ALU_N alpha_instr_ext"); break;
                case 2: printf("#define ALU_N alpha_instr_ins"); break;
                }
                printf("%s", sizechar[size]);
                if (lo)
                        printf("l");
                else
                        printf("h");
                if (imm)
                        printf("_imm");
                printf("\n");
                if (imm)
                        printf("#define ALU_IMM\n");
                switch (size) {
                case 0: printf("#define ALU_B\n"); break;
                case 1: printf("#define ALU_W\n"); break;
                case 2: printf("#define ALU_L\n"); break;
                case 3: printf("#define ALU_Q\n"); break;
                }
                if (lo)
                        printf("#define ALU_LO\n");
                printf("#include \"cpu_alpha_instr_alu.c\"\n");
                switch (size) {
                case 0: printf("#undef ALU_B\n"); break;
                case 1: printf("#undef ALU_W\n"); break;
                case 2: printf("#undef ALU_L\n"); break;
                case 3: printf("#undef ALU_Q\n"); break;
                }
                switch (msk) {
                case 0: printf("#undef ALU_MSK\n"); break;
                case 1: printf("#undef ALU_EXT\n"); break;
                case 2: printf("#undef ALU_INS\n"); break;
                }
                if (lo)
                        printf("#undef ALU_LO\n");
                if (imm)
                        printf("#undef ALU_IMM\n");
                printf("#undef ALU_N\n");
            }

        /*
         *  Normal load/store:
         */
        for (llsc=0; llsc<=1; llsc++)
          for (aligncheck=0; aligncheck<=1; aligncheck++)
            for (load=0; load<=1; load++)
                for (zero=0; zero<=1; zero++)
                    for (size=0; size<4; size++) {
                        if (llsc && size < 2)
                                continue;
                        if (aligncheck)
                                printf("#define LS_ALIGN_CHECK\n");
                        if (zero)
                                printf("#define LS_IGNORE_OFFSET\n");
                        if (load)
                                printf("#define LS_LOAD\n");
                        if (llsc)
                                printf("#define LS_LLSC\n");
                        switch (size) {
                        case 0: printf("#define LS_B\n"); break;
                        case 1: printf("#define LS_W\n"); break;
                        case 2: printf("#define LS_L\n"); break;
                        case 3: printf("#define LS_Q\n"); break;
                        }
                        printf("#define LS_GENERIC_N alpha_generic_");
                        if (load)
                                printf("ld");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        if (llsc)
                                printf("_llsc");
                        printf("\n");
                        printf("#define LS_N alpha_instr_");
                        if (load)
                                printf("ld");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        if (zero)
                                printf("_0");
                        if (aligncheck)
                                printf("_aligncheck");
                        if (llsc)
                                printf("_llsc");
                        printf("\n");
                        printf("#include \"cpu_alpha_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_W\n"); break;
                        case 2: printf("#undef LS_L\n"); break;
                        case 3: printf("#undef LS_Q\n"); break;
                        }
                        if (load)
                                printf("#undef LS_LOAD\n");
                        if (llsc)
                                printf("#undef LS_LLSC\n");
                        if (zero)
                                printf("#undef LS_IGNORE_OFFSET\n");
                        if (aligncheck)
                                printf("#undef LS_ALIGN_CHECK\n");
                    }

        /*
         *  Unaligned load/store:
         */
        printf("#define LS_UNALIGNED\n");
        for (load=0; load<=1; load++) {
                        size = 3;
                        if (load)
                                printf("#define LS_LOAD\n");
                        printf("#define LS_Q\n");
                        printf("#define LS_GENERIC_N alpha_generic_");
                        if (load)
                                printf("ld");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        printf("_u");           /*  NOTE: unaligned  */
                        printf("\n");
                        printf("#define LS_N alpha_instr_");
                        if (load)
                                printf("ld");
                        else
                                printf("st");
                        printf("%s", sizechar[size]);
                        printf("_u");           /*  NOTE: unaligned  */
                        printf("\n");
                        printf("#include \"cpu_alpha_instr_loadstore.c\"\n");
                        printf("#undef LS_N\n");
                        printf("#undef LS_GENERIC_N\n");
                        printf("#undef LS_Q\n");
                        if (load)
                                printf("#undef LS_LOAD\n");
                }
        printf("#undef LS_UNALIGNED\n");

        /*  Lookup table for most normal loads/stores:  */
        printf("\n\nvoid (*alpha_loadstore[64])(struct cpu *, struct "
            "alpha_instr_call *) = {\n");

        for (llsc = 0; llsc <= 1; llsc ++)
            for (aligncheck=0; aligncheck<=1; aligncheck++)
                for (load=0; load<=1; load++)
                  for (zero=0; zero<=1; zero++)
                    for (size=0; size<4; size++) {
                        printf("\talpha_instr_");
                        if (llsc && (size != 2 && size != 3)) {
                                printf("nop");
                        } else {
                                if (load)
                                        printf("ld");
                                else
                                        printf("st");
                                printf("%s", sizechar[size]);
                                if (zero)
                                        printf("_0");
                                if (aligncheck)
                                        printf("_aligncheck");
                                if (llsc)
                                        printf("_llsc");
                        }
                        if (++n < 64)
                                printf(",");
                        printf("\n");
                    }

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

        for (ra = 0; ra < 32; ra ++)
            for (rc = 0; rc < 31; rc ++)
                if (ra != rc) {
                        printf("static void alpha_instr_mov_%i_%i(struct cpu"
                            " *cpu, struct alpha_instr_call *ic)\n", ra, rc);
                        printf("{ cpu->cd.alpha.r[%i] = ", rc);
                        if (ra == 31)
                                printf("0");
                        else
                                printf("cpu->cd.alpha.r[%i]", ra);
                        printf("; }\n");
                }

        printf("\n\nvoid (*alpha_mov_r_r[32*31])(struct cpu *, struct "
            "alpha_instr_call *) = {\n");
        n = 0;
        for (rc = 0; rc < 31; rc ++)
            for (ra = 0; ra < 32; ra ++) {
                if (ra == rc)
                        printf("\talpha_instr_nop");
                else
                        printf("\talpha_instr_mov_%i_%i", ra, rc);
                if (++n < 31*32)
                        printf(",");
                printf("\n");
            }

        printf("};\n\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_alpha_misc.c,v 1.1 2005/08/29 14:36:41 debug Exp $
29	*/
30
31	#include <stdio.h>
32	#include <string.h>
33
34
35	char *sizechar[4] = { "b", "w", "l", "q" };
36
37	#define N_CMPS 5
38	char cmps[N_CMPS] = { "ult", "eq", "ule", "lt", "le" /bge*/ };
39	#define N_CMOV 8
40	char *cmov[N_CMOV] = { "lbs", "lbc", "eq", "ne", "lt", "ge", "le", "gt" };
41
42
43	int main(int argc, char *argv[])
44	{
45	int load, size, zero, aligncheck, n, msk, llsc;
46	int ra, rc, lo, scale, imm, not, op, quad;
47
48	printf("\n/* AUTOMATICALLY GENERATED! Do not edit. */\n\n");
49
50	n = 0;
51	/* add and sub: */
52	for (imm = 0; imm <= 1; imm ++)
53	for (quad = 0; quad <= 1; quad ++)
54	for (scale = 0; scale <= 8; scale += 4)
55	for (op = 0; op <= 1; op ++) {
56	printf("#define ALU_N alpha_instr_");
57	if (scale)
58	printf("s%i", scale);
59	printf("%s%s", op? "sub" : "add", quad? "q" : "l");
60	if (imm)
61	printf("_imm");
62	printf("\n");
63
64	if (imm)
65	printf("#define ALU_IMM\n");
66	if (!quad)
67	printf("#define ALU_LONG\n");
68	if (op)
69	printf("#define ALU_SUB\n");
70	else
71	printf("#define ALU_ADD\n");
72	if (scale)
73	printf("#define ALU_S%i\n", scale);
74
75	printf("#include \"cpu_alpha_instr_alu.c\"\n");
76
77	if (imm)
78	printf("#undef ALU_IMM\n");
79	if (!quad)
80	printf("#undef ALU_LONG\n");
81	if (op)
82	printf("#undef ALU_SUB\n");
83	else
84	printf("#undef ALU_ADD\n");
85	if (scale)
86	printf("#undef ALU_S%i\n", scale);
87
88	printf("#undef ALU_N\n");
89	}
90
91	/* and, or, xor, zap, sll, srl, sra: */
92	for (imm = 0; imm <= 1; imm ++)
93	for (not = 0; not <= 1; not ++)
94	for (op = 0; op < 7; op ++) {
95	if (op >= 4 && not)
96	continue;
97	printf("#define ALU_N alpha_instr_");
98	switch (op) {
99	case 0: printf("and"); break;
100	case 1: printf("or"); break;
101	case 2: printf("xor"); break;
102	case 3: printf("zap"); break;
103	case 4: printf("sll"); break;
104	case 5: printf("srl"); break;
105	case 6: printf("sra"); break;
106	}
107	if (not)
108	printf("not");
109	if (imm)
110	printf("_imm");
111	printf("\n");
112	if (imm)
113	printf("#define ALU_IMM\n");
114	switch (op) {
115	case 0: printf("#define ALU_AND\n"); break;
116	case 1: printf("#define ALU_OR\n"); break;
117	case 2: printf("#define ALU_XOR\n"); break;
118	case 3: printf("#define ALU_ZAP\n"); break;
119	case 4: printf("#define ALU_SLL\n"); break;
120	case 5: printf("#define ALU_SRL\n"); break;
121	case 6: printf("#define ALU_SRA\n"); break;
122	}
123	if (not)
124	printf("#define ALU_NOT\n");
125	printf("#include \"cpu_alpha_instr_alu.c\"\n");
126
127	if (imm)
128	printf("#undef ALU_IMM\n");
129	if (not)
130	printf("#undef ALU_NOT\n");
131	switch (op) {
132	case 0: printf("#undef ALU_AND\n"); break;
133	case 1: printf("#undef ALU_OR\n"); break;
134	case 2: printf("#undef ALU_XOR\n"); break;
135	case 3: printf("#undef ALU_ZAP\n"); break;
136	case 4: printf("#undef ALU_SLL\n"); break;
137	case 5: printf("#undef ALU_SRL\n"); break;
138	case 6: printf("#undef ALU_SRA\n"); break;
139	}
140
141	printf("#undef ALU_N\n");
142	}
143
144	printf("#define ALU_CMP\n");
145	for (imm = 0; imm <= 1; imm ++)
146	for (op = 0; op < N_CMPS; op ++) {
147	printf("#define ALU_N alpha_instr_cmp%s", cmps[op]);
148	if (imm)
149	printf("_imm");
150	printf("\n");
151
152	if (imm)
153	printf("#define ALU_IMM\n");
154
155	if (cmps[op][0] == 'u')
156	printf("#define ALU_UNSIGNED\n");
157	if (strcmp(cmps[op]+strlen(cmps[op])-2,"lt") == 0)
158	printf("#define ALU_CMP_LT\n");
159	if (strcmp(cmps[op]+strlen(cmps[op])-2,"le") == 0)
160	printf("#define ALU_CMP_LE\n");
161	if (strcmp(cmps[op]+strlen(cmps[op])-2,"eq") == 0)
162	printf("#define ALU_CMP_EQ\n");
163
164	printf("#include \"cpu_alpha_instr_alu.c\"\n");
165
166	if (cmps[op][0] == 'u')
167	printf("#undef ALU_UNSIGNED\n");
168	if (strcmp(cmps[op]+strlen(cmps[op])-2,"lt") == 0)
169	printf("#undef ALU_CMP_LT\n");
170	if (strcmp(cmps[op]+strlen(cmps[op])-2,"le") == 0)
171	printf("#undef ALU_CMP_LE\n");
172	if (strcmp(cmps[op]+strlen(cmps[op])-2,"eq") == 0)
173	printf("#undef ALU_CMP_EQ\n");
174	if (imm)
175	printf("#undef ALU_IMM\n");
176	printf("#undef ALU_N\n");
177	}
178	printf("#undef ALU_CMP\n");
179
180	printf("#define ALU_CMOV\n");
181	for (imm = 0; imm <= 1; imm ++)
182	for (op = 0; op < N_CMOV; op ++) {
183	printf("#define ALU_N alpha_instr_cmov%s", cmov[op]);
184	if (imm)
185	printf("_imm");
186	printf("\n");
187	if (imm)
188	printf("#define ALU_IMM\n");
189	printf("#define ALU_CMOV_%s\n", cmov[op]);
190	printf("#include \"cpu_alpha_instr_alu.c\"\n");
191	printf("#undef ALU_CMOV_%s\n", cmov[op]);
192	if (imm)
193	printf("#undef ALU_IMM\n");
194	printf("#undef ALU_N\n");
195	}
196	printf("#undef ALU_CMOV\n");
197
198	for (imm = 0; imm <= 1; imm ++)
199	for (lo = 0; lo <= 1; lo ++)
200	for (msk = 0; msk <= 2; msk ++)
201	for (size=0; size<4; size++) {
202	if (size==0 && lo==0)
203	continue;
204	switch (msk) {
205	case 0: printf("#define ALU_MSK\n"); break;
206	case 1: printf("#define ALU_EXT\n"); break;
207	case 2: printf("#define ALU_INS\n"); break;
208	}
209	switch (msk) {
210	case 0: printf("#define ALU_N alpha_instr_msk"); break;
211	case 1: printf("#define ALU_N alpha_instr_ext"); break;
212	case 2: printf("#define ALU_N alpha_instr_ins"); break;
213	}
214	printf("%s", sizechar[size]);
215	if (lo)
216	printf("l");
217	else
218	printf("h");
219	if (imm)
220	printf("_imm");
221	printf("\n");
222	if (imm)
223	printf("#define ALU_IMM\n");
224	switch (size) {
225	case 0: printf("#define ALU_B\n"); break;
226	case 1: printf("#define ALU_W\n"); break;
227	case 2: printf("#define ALU_L\n"); break;
228	case 3: printf("#define ALU_Q\n"); break;
229	}
230	if (lo)
231	printf("#define ALU_LO\n");
232	printf("#include \"cpu_alpha_instr_alu.c\"\n");
233	switch (size) {
234	case 0: printf("#undef ALU_B\n"); break;
235	case 1: printf("#undef ALU_W\n"); break;
236	case 2: printf("#undef ALU_L\n"); break;
237	case 3: printf("#undef ALU_Q\n"); break;
238	}
239	switch (msk) {
240	case 0: printf("#undef ALU_MSK\n"); break;
241	case 1: printf("#undef ALU_EXT\n"); break;
242	case 2: printf("#undef ALU_INS\n"); break;
243	}
244	if (lo)
245	printf("#undef ALU_LO\n");
246	if (imm)
247	printf("#undef ALU_IMM\n");
248	printf("#undef ALU_N\n");
249	}
250
251	/*
252	* Normal load/store:
253	*/
254	for (llsc=0; llsc<=1; llsc++)
255	for (aligncheck=0; aligncheck<=1; aligncheck++)
256	for (load=0; load<=1; load++)
257	for (zero=0; zero<=1; zero++)
258	for (size=0; size<4; size++) {
259	if (llsc && size < 2)
260	continue;
261	if (aligncheck)
262	printf("#define LS_ALIGN_CHECK\n");
263	if (zero)
264	printf("#define LS_IGNORE_OFFSET\n");
265	if (load)
266	printf("#define LS_LOAD\n");
267	if (llsc)
268	printf("#define LS_LLSC\n");
269	switch (size) {
270	case 0: printf("#define LS_B\n"); break;
271	case 1: printf("#define LS_W\n"); break;
272	case 2: printf("#define LS_L\n"); break;
273	case 3: printf("#define LS_Q\n"); break;
274	}
275	printf("#define LS_GENERIC_N alpha_generic_");
276	if (load)
277	printf("ld");
278	else
279	printf("st");
280	printf("%s", sizechar[size]);
281	if (llsc)
282	printf("_llsc");
283	printf("\n");
284	printf("#define LS_N alpha_instr_");
285	if (load)
286	printf("ld");
287	else
288	printf("st");
289	printf("%s", sizechar[size]);
290	if (zero)
291	printf("_0");
292	if (aligncheck)
293	printf("_aligncheck");
294	if (llsc)
295	printf("_llsc");
296	printf("\n");
297	printf("#include \"cpu_alpha_instr_loadstore.c\"\n");
298	printf("#undef LS_N\n");
299	printf("#undef LS_GENERIC_N\n");
300	switch (size) {
301	case 0: printf("#undef LS_B\n"); break;
302	case 1: printf("#undef LS_W\n"); break;
303	case 2: printf("#undef LS_L\n"); break;
304	case 3: printf("#undef LS_Q\n"); break;
305	}
306	if (load)
307	printf("#undef LS_LOAD\n");
308	if (llsc)
309	printf("#undef LS_LLSC\n");
310	if (zero)
311	printf("#undef LS_IGNORE_OFFSET\n");
312	if (aligncheck)
313	printf("#undef LS_ALIGN_CHECK\n");
314	}
315
316	/*
317	* Unaligned load/store:
318	*/
319	printf("#define LS_UNALIGNED\n");
320	for (load=0; load<=1; load++) {
321	size = 3;
322	if (load)
323	printf("#define LS_LOAD\n");
324	printf("#define LS_Q\n");
325	printf("#define LS_GENERIC_N alpha_generic_");
326	if (load)
327	printf("ld");
328	else
329	printf("st");
330	printf("%s", sizechar[size]);
331	printf("_u"); /* NOTE: unaligned */
332	printf("\n");
333	printf("#define LS_N alpha_instr_");
334	if (load)
335	printf("ld");
336	else
337	printf("st");
338	printf("%s", sizechar[size]);
339	printf("_u"); /* NOTE: unaligned */
340	printf("\n");
341	printf("#include \"cpu_alpha_instr_loadstore.c\"\n");
342	printf("#undef LS_N\n");
343	printf("#undef LS_GENERIC_N\n");
344	printf("#undef LS_Q\n");
345	if (load)
346	printf("#undef LS_LOAD\n");
347	}
348	printf("#undef LS_UNALIGNED\n");
349
350	/* Lookup table for most normal loads/stores: */
351	printf("\n\nvoid (alpha_loadstore[64])(struct cpu , struct "
352	"alpha_instr_call *) = {\n");
353
354	for (llsc = 0; llsc <= 1; llsc ++)
355	for (aligncheck=0; aligncheck<=1; aligncheck++)
356	for (load=0; load<=1; load++)
357	for (zero=0; zero<=1; zero++)
358	for (size=0; size<4; size++) {
359	printf("\talpha_instr_");
360	if (llsc && (size != 2 && size != 3)) {
361	printf("nop");
362	} else {
363	if (load)
364	printf("ld");
365	else
366	printf("st");
367	printf("%s", sizechar[size]);
368	if (zero)
369	printf("_0");
370	if (aligncheck)
371	printf("_aligncheck");
372	if (llsc)
373	printf("_llsc");
374	}
375	if (++n < 64)
376	printf(",");
377	printf("\n");
378	}
379
380	printf("};\n\n");
381
382	for (ra = 0; ra < 32; ra ++)
383	for (rc = 0; rc < 31; rc ++)
384	if (ra != rc) {
385	printf("static void alpha_instr_mov_%i_%i(struct cpu"
386	" cpu, struct alpha_instr_call ic)\n", ra, rc);
387	printf("{ cpu->cd.alpha.r[%i] = ", rc);
388	if (ra == 31)
389	printf("0");
390	else
391	printf("cpu->cd.alpha.r[%i]", ra);
392	printf("; }\n");
393	}
394
395	printf("\n\nvoid (alpha_mov_r_r[3231])(struct cpu *, struct "
396	"alpha_instr_call *) = {\n");
397	n = 0;
398	for (rc = 0; rc < 31; rc ++)
399	for (ra = 0; ra < 32; ra ++) {
400	if (ra == rc)
401	printf("\talpha_instr_nop");
402	else
403	printf("\talpha_instr_mov_%i_%i", ra, rc);
404	if (++n < 31*32)
405	printf(",");
406	printf("\n");
407	}
408
409	printf("};\n\n");
410
411	return 0;
412	}
413