src/cpus/generate_arm_r.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_arm_r.c,v 1.1 2005/10/09 21:32:07 debug Exp $
 *
 *  Generate functions for computing "reg" operands.
 */

#include <stdio.h>
#include <stdlib.h>


#if 0
/*
 *  update_c is set if the C flag should be updated with the last shifted/
 *  rotated bit.
 */
uint32_t R(struct cpu *cpu, struct arm_instr_call *ic,
        uint32_t iword, int update_c)
{
        int rm = iword & 15, lastbit, t, c;
        uint32_t tmp = cpu->cd.arm.r[rm];

        case 2: /*  lsr #c  (c = 1..32)  */
                if (c == 0)
                        c = 32;
                if (update_c) {
                        lastbit = ((uint64_t)tmp >> (c-1)) & 1;
                }
                tmp = (uint64_t)tmp >> c;
                break;
        case 3: /*  lsr Rc  */
                c = cpu->cd.arm.r[c >> 1] & 255;
                if (c >= 32)
                        c = 33;
                if (update_c) {
                        if (c == 0)
                                update_c = 0;
                        else
                                lastbit = ((uint64_t)tmp >> (c-1)) & 1;
                }
                tmp = (uint64_t)tmp >> c;
                break;
        case 4: /*  asr #c  (c = 1..32)  */
                if (c == 0)
                        c = 32;
                if (update_c) {
                        lastbit = ((int64_t)(int32_t)tmp >> (c-1)) & 1;
                }
                tmp = (int64_t)(int32_t)tmp >> c;
                break;
        case 5: /*  asr Rc  */
                c = cpu->cd.arm.r[c >> 1] & 255;
                if (c >= 32)
                        c = 33;
                if (update_c) {
                        if (c == 0)
                                update_c = 0;
                        else
                                lastbit = ((int64_t)(int32_t)tmp >> (c-1)) & 1;
                }
                tmp = (int64_t)(int32_t)tmp >> c;
                break;
        case 6: /*  ror 1..31  */
                if (c == 0) {
                        fatal("TODO: rrx\n");
                        exit(1);
                }
                if (update_c)
                        lastbit = ((int64_t)(int32_t)tmp >> (c-1)) & 1;
                tmp = (uint64_t)(((uint64_t)tmp << 32) | tmp) >> c;
                break;
        case 7: /*  ror Rc  */
                c = cpu->cd.arm.r[c >> 1] & 255;
                if (update_c) {
                        if (c == 0)
                                update_c = 0;
                        else {
                                c &= 31;
                                if (c == 0)
                                        lastbit = tmp & 0x80000000;
                                else
                                        lastbit = ((int64_t)(int32_t)tmp
                                            >> (c-1)) & 1;
                                tmp = (uint64_t)(((uint64_t)tmp << 32)
                                    | tmp) >> c;
                        }
                }
                break;
        }
        if (update_c) {
                cpu->cd.arm.cpsr &= ~ARM_FLAG_C;
                if (lastbit)
                        cpu->cd.arm.cpsr |= ARM_FLAG_C;
        }
        return tmp;
}
#endif


void sync_pc(void)
{
        printf("\tuint32_t tmp, low_pc = ((size_t)ic - (size_t)\n"
            "\t    cpu->cd.arm.cur_ic_page)/sizeof(struct arm_instr_call);\n");
        printf("\ttmp = cpu->cd.arm.r[15] & ~((ARM_IC_ENTRIES_PER_PAGE-1) <<\n"
            "\t    ARM_INSTR_ALIGNMENT_SHIFT);\n");
        printf("\ttmp += (low_pc << ARM_INSTR_ALIGNMENT_SHIFT) + 8;\n");
}


void f(int s, int func, int only_name)
{
        int rm = func & 15;
        int c = (func >> 7) & 31;
        int t = (func >> 4) & 7;
        char name[200];
        int pc = rm == 15, rc = c >> 1;

        snprintf(name, sizeof(name), "arm_r%s_r%i_t%i_c%i", s? "s" : "",
            rm, t, c);
        if (only_name) {
                printf("%s", name);
                return;
        }

        printf("uint32_t %s(struct cpu *cpu, struct arm_instr_call *ic)"
            " {\n", name);
        if (pc)
                sync_pc();

        switch (t) {

        case 0: /*  lsl c  (Logical Shift Left by constant)  */
                if (s) {
                        printf("{ uint32_t x = ");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]", rm);
                        printf(";\n");
                        if (c != 0) {
                                printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
                                printf("if (x & 0x%x)\n"
                                    "\tcpu->cd.arm.cpsr |= ARM_FLAG_C;\n",
                                    (int)(0x80000000 >> (c-1)));
                                printf("x <<= %i;\n", c);
                        }
                        printf(" return x; }\n");
                } else {
                        if (pc)
                                printf("\treturn tmp");
                        else
                                printf("\treturn cpu->cd.arm.r[%i]", rm);
                        if (c != 0)
                                printf(" << %i", c);
                        printf(";\n");
                }
                break;

        case 1: /*  lsl Rc  (Logical Shift Left by register)  */
                if (s) {
                        printf("{ uint32_t x = ");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]", rm);
                        printf(";\n");
                        printf("  uint32_t y = cpu->cd.arm.r[%i] & 255;\n", rc);
                        printf("  if (y != 0) {\n");
                        printf("    cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
                        printf("    if (y >= 32) return 0;\n");
                        printf("    x <<= (y - 1);\n");
                        printf("    if (x & 0x80000000)\n"
                            "\tcpu->cd.arm.cpsr |= ARM_FLAG_C;\n");
                        printf("    x <<= 1;\n");
                        printf(" }\n");
                        printf(" return x; }\n");
                } else {
                        printf("{ uint32_t y = cpu->cd.arm.r[%i] & 255;\n", rc);
                        printf("  uint32_t x =");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]", rm);
                        printf(";\n");
                        printf("if (y > 31) return 0; else x <<= y;\n");
                        printf("return x; }\n");
                }
                break;

        case 2: /*  lsr c  (Logical Shift Right by constant)  */
                /*  1..32  */
                if (s) {
                        printf("{ uint32_t x = ");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]", rm);
                        printf(";\n");
                        if (c == 0)
                                c = 32;
                        printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
                        printf("if (x & 0x%x)\n"
                            "\tcpu->cd.arm.cpsr |= ARM_FLAG_C;\n",
                            (int)(1 << (c-1)));
                        if (c == 32)
                                printf("x = 0;\n");
                        else
                                printf("x >>= %i;\n", c);
                        printf(" return x; }\n");
                } else {
                        if (c == 0)
                                printf("\treturn 0;\n");
                        else {
                                if (pc)
                                        printf("\treturn tmp");
                                else
                                        printf("\treturn cpu->cd.arm.r[%i]",rm);
                                printf(" >> %i;\n", c);
                        }
                }
                break;

        case 3: /*  lsr Rc  (Logical Shift Right by register)  */
                if (s) {
                        printf("{ uint32_t x = ");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]", rm);
                        printf(",y=cpu->cd.arm.r[%i]&255;\n", rc);
                        printf("if(y==0) return x;\n");
                        printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
                        printf("if(y>31) y=32;\n");
                        printf("y--; x >>= y;\n");
                        printf("if (x & 1) "
                            "cpu->cd.arm.cpsr |= ARM_FLAG_C;\n");
                        printf(" return x >> 1; }\n");
                } else {
                        printf("{ uint32_t y=cpu->cd.arm.r[%i]&255;\n", rc);
                        printf("uint32_t x=");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]",rm);
                        printf("; ");
                        printf("if (y>=32) return 0;\n");
                        printf("return x >> y; } ");
                }
                break;

        case 4: /*  asr c  (Arithmetic Shift Right by constant)  */
                /*  1..32  */
                if (s) {
                        printf("{ int32_t x = ");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]", rm);
                        printf(";\n");
                        if (c == 0)
                                c = 32;
                        printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
                        printf("if (x & 0x%x)\n"
                            "\tcpu->cd.arm.cpsr |= ARM_FLAG_C;\n",
                            (int)(1 << (c-1)));
                        if (c == 32)
                                printf("x = (x<0)? 0xffffffff : 0;\n");
                        else
                                printf("x >>= %i;\n", c);
                        printf(" return x; }\n");
                } else {
                        if (c == 0) {
                                printf("\treturn ");
                                if (pc)
                                        printf("tmp");
                                else
                                        printf("cpu->cd.arm.r[%i]",rm);
                                printf(" & 0x80000000? 0xffffffff : 0;\n");
                        } else {
                                printf("return (int32_t)");
                                if (pc)
                                        printf("tmp");
                                else
                                        printf("cpu->cd.arm.r[%i]",rm);
                                printf(" >> %i;\n", c);
                        }
                }
                break;

        case 5: /*  asr Rc  (Arithmetic Shift Right by register)  */
                if (s) {
                        printf("{ int32_t x = ");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]", rm);
                        printf(",y=cpu->cd.arm.r[%i]&255;\n", rc);
                        printf("if(y==0) return x;\n");
                        printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
                        printf("if(y>31) y=31;\n");
                        printf("y--; x >>= y;\n");
                        printf("if (x & 1) "
                            "cpu->cd.arm.cpsr |= ARM_FLAG_C;\n");
                        printf(" return (int32_t)x >> 1; }\n");
                } else {
                        printf("{ int32_t y=cpu->cd.arm.r[%i]&255;\n", rc);
                        printf("int32_t x=");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]",rm);
                        printf("; ");
                        printf("if (y>=31) return (x<0)?0xffffffff:0;\n");
                        printf("return (int32_t)x >> y; } ");
                }
                break;

        case 6: /*  ror c  OR rrx (Arithmetic Shift Right by constant)  */
                /*  0=rrx, 1..31=ror  */
                if (c == 0) {
                        printf("\tprintf(\"%s\\n\");\n", name);
                        printf("\texit(1);  /*  TODO  */\n\treturn 0;\n");
                } else if (s) {
                        printf("{ uint64_t x = ");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]", rm);
                        printf("; x |= (x << 32);\n");
                        printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
                        printf("if (x & 0x%x)\n"
                            "\tcpu->cd.arm.cpsr |= ARM_FLAG_C;\n",
                            (int)(1 << (c-1)));
                        printf(" return x >> %i; }\n", c);
                } else {
                        printf("uint64_t x=");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]",rm);
                        printf("; x |= (x << 32); ");
                        printf("return x >> %i;\n", c);
                }
                break;

        case 7: /*  ror Rc  (Rotate Right by register)  */
                if (s) {
                        printf("{ uint64_t x = ");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]", rm);
                        printf("; int y=cpu->cd.arm.r[%i]&255;\n", rc);
                        printf("if(y==0) return x;\n");
                        printf("y --; y &= 31; x >>= y;\n");
                        printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
                        printf("if (x & 1) "
                            "cpu->cd.arm.cpsr |= ARM_FLAG_C;\n");
                        printf(" return x >> 1; }\n");
                } else {
                        printf("{ int y=cpu->cd.arm.r[%i]&31;\n", rc);
                        printf("uint64_t x=");
                        if (pc)
                                printf("tmp");
                        else
                                printf("cpu->cd.arm.r[%i]",rm);
                        printf("; x |= (x << 32); ");
                        printf("return (x >> y); } ");
                }
                break;

        default:
                printf("\tprintf(\"%s\\n\");\n", name);
                printf("\texit(1);  /*  TODO  */\n\treturn 0;\n");
        }

        printf("}\n");
}


int main(int argc, char *argv[])
{
        int s, func, f_start, f_end;

        if (argc < 3) {
                fprintf(stderr, "usage: %s start end\n", argv[0]);
                exit(1);
        }

        f_start = strtol(argv[1], NULL, 0);
        f_end   = strtol(argv[2], NULL, 0);

        printf("/*\n *  DO NOT EDIT! AUTOMATICALLY GENERATED!\n */\n\n");
        printf("#include <stdio.h>\n");
        printf("#include <stdlib.h>\n");
        printf("#include \"cpu.h\"\n");
        printf("#include \"misc.h\"\n");
        printf("\n\n");

        if (f_start != 0 || f_end != 0) {
                for (s=0; s<=1; s++)
                        for (func=f_start; func<=f_end; func++)
                                f(s, func, 0);
        } else {
                for (s=0; s<=1; s++)
                        for (func=0; func<=0xfff; func++) {
                                printf("extern uint32_t ");
                                f(s, func, 1);
                                printf("(struct cpu *, struct arm_"
                                    "instr_call *);\n");
                        }

                printf("\nuint32_t (*arm_r[8192])(struct cpu *,"
                    " struct arm_instr_call *) = {\n");
                for (s=0; s<=1; s++)
                        for (func=0; func<=0xfff; func++) {
                                printf("\t");
                                f(s, func, 1);
                                if (s!=1 || func!=0xfff)
                                        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_arm_r.c,v 1.1 2005/10/09 21:32:07 debug Exp $
29	*
30	* Generate functions for computing "reg" operands.
31	*/
32
33	#include <stdio.h>
34	#include <stdlib.h>
35
36
37	#if 0
38	/*
39	* update_c is set if the C flag should be updated with the last shifted/
40	* rotated bit.
41	*/
42	uint32_t R(struct cpu cpu, struct arm_instr_call ic,
43	uint32_t iword, int update_c)
44	{
45	int rm = iword & 15, lastbit, t, c;
46	uint32_t tmp = cpu->cd.arm.r[rm];
47
48	case 2: /* lsr #c (c = 1..32) */
49	if (c == 0)
50	c = 32;
51	if (update_c) {
52	lastbit = ((uint64_t)tmp >> (c-1)) & 1;
53	}
54	tmp = (uint64_t)tmp >> c;
55	break;
56	case 3: /* lsr Rc */
57	c = cpu->cd.arm.r[c >> 1] & 255;
58	if (c >= 32)
59	c = 33;
60	if (update_c) {
61	if (c == 0)
62	update_c = 0;
63	else
64	lastbit = ((uint64_t)tmp >> (c-1)) & 1;
65	}
66	tmp = (uint64_t)tmp >> c;
67	break;
68	case 4: /* asr #c (c = 1..32) */
69	if (c == 0)
70	c = 32;
71	if (update_c) {
72	lastbit = ((int64_t)(int32_t)tmp >> (c-1)) & 1;
73	}
74	tmp = (int64_t)(int32_t)tmp >> c;
75	break;
76	case 5: /* asr Rc */
77	c = cpu->cd.arm.r[c >> 1] & 255;
78	if (c >= 32)
79	c = 33;
80	if (update_c) {
81	if (c == 0)
82	update_c = 0;
83	else
84	lastbit = ((int64_t)(int32_t)tmp >> (c-1)) & 1;
85	}
86	tmp = (int64_t)(int32_t)tmp >> c;
87	break;
88	case 6: /* ror 1..31 */
89	if (c == 0) {
90	fatal("TODO: rrx\n");
91	exit(1);
92	}
93	if (update_c)
94	lastbit = ((int64_t)(int32_t)tmp >> (c-1)) & 1;
95	tmp = (uint64_t)(((uint64_t)tmp << 32) \| tmp) >> c;
96	break;
97	case 7: /* ror Rc */
98	c = cpu->cd.arm.r[c >> 1] & 255;
99	if (update_c) {
100	if (c == 0)
101	update_c = 0;
102	else {
103	c &= 31;
104	if (c == 0)
105	lastbit = tmp & 0x80000000;
106	else
107	lastbit = ((int64_t)(int32_t)tmp
108	>> (c-1)) & 1;
109	tmp = (uint64_t)(((uint64_t)tmp << 32)
110	\| tmp) >> c;
111	}
112	}
113	break;
114	}
115	if (update_c) {
116	cpu->cd.arm.cpsr &= ~ARM_FLAG_C;
117	if (lastbit)
118	cpu->cd.arm.cpsr \|= ARM_FLAG_C;
119	}
120	return tmp;
121	}
122	#endif
123
124
125	void sync_pc(void)
126	{
127	printf("\tuint32_t tmp, low_pc = ((size_t)ic - (size_t)\n"
128	"\t cpu->cd.arm.cur_ic_page)/sizeof(struct arm_instr_call);\n");
129	printf("\ttmp = cpu->cd.arm.r[15] & ~((ARM_IC_ENTRIES_PER_PAGE-1) <<\n"
130	"\t ARM_INSTR_ALIGNMENT_SHIFT);\n");
131	printf("\ttmp += (low_pc << ARM_INSTR_ALIGNMENT_SHIFT) + 8;\n");
132	}
133
134
135	void f(int s, int func, int only_name)
136	{
137	int rm = func & 15;
138	int c = (func >> 7) & 31;
139	int t = (func >> 4) & 7;
140	char name[200];
141	int pc = rm == 15, rc = c >> 1;
142
143	snprintf(name, sizeof(name), "arm_r%s_r%i_t%i_c%i", s? "s" : "",
144	rm, t, c);
145	if (only_name) {
146	printf("%s", name);
147	return;
148	}
149
150	printf("uint32_t %s(struct cpu cpu, struct arm_instr_call ic)"
151	" {\n", name);
152	if (pc)
153	sync_pc();
154
155	switch (t) {
156
157	case 0: /* lsl c (Logical Shift Left by constant) */
158	if (s) {
159	printf("{ uint32_t x = ");
160	if (pc)
161	printf("tmp");
162	else
163	printf("cpu->cd.arm.r[%i]", rm);
164	printf(";\n");
165	if (c != 0) {
166	printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
167	printf("if (x & 0x%x)\n"
168	"\tcpu->cd.arm.cpsr \|= ARM_FLAG_C;\n",
169	(int)(0x80000000 >> (c-1)));
170	printf("x <<= %i;\n", c);
171	}
172	printf(" return x; }\n");
173	} else {
174	if (pc)
175	printf("\treturn tmp");
176	else
177	printf("\treturn cpu->cd.arm.r[%i]", rm);
178	if (c != 0)
179	printf(" << %i", c);
180	printf(";\n");
181	}
182	break;
183
184	case 1: /* lsl Rc (Logical Shift Left by register) */
185	if (s) {
186	printf("{ uint32_t x = ");
187	if (pc)
188	printf("tmp");
189	else
190	printf("cpu->cd.arm.r[%i]", rm);
191	printf(";\n");
192	printf(" uint32_t y = cpu->cd.arm.r[%i] & 255;\n", rc);
193	printf(" if (y != 0) {\n");
194	printf(" cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
195	printf(" if (y >= 32) return 0;\n");
196	printf(" x <<= (y - 1);\n");
197	printf(" if (x & 0x80000000)\n"
198	"\tcpu->cd.arm.cpsr \|= ARM_FLAG_C;\n");
199	printf(" x <<= 1;\n");
200	printf(" }\n");
201	printf(" return x; }\n");
202	} else {
203	printf("{ uint32_t y = cpu->cd.arm.r[%i] & 255;\n", rc);
204	printf(" uint32_t x =");
205	if (pc)
206	printf("tmp");
207	else
208	printf("cpu->cd.arm.r[%i]", rm);
209	printf(";\n");
210	printf("if (y > 31) return 0; else x <<= y;\n");
211	printf("return x; }\n");
212	}
213	break;
214
215	case 2: /* lsr c (Logical Shift Right by constant) */
216	/* 1..32 */
217	if (s) {
218	printf("{ uint32_t x = ");
219	if (pc)
220	printf("tmp");
221	else
222	printf("cpu->cd.arm.r[%i]", rm);
223	printf(";\n");
224	if (c == 0)
225	c = 32;
226	printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
227	printf("if (x & 0x%x)\n"
228	"\tcpu->cd.arm.cpsr \|= ARM_FLAG_C;\n",
229	(int)(1 << (c-1)));
230	if (c == 32)
231	printf("x = 0;\n");
232	else
233	printf("x >>= %i;\n", c);
234	printf(" return x; }\n");
235	} else {
236	if (c == 0)
237	printf("\treturn 0;\n");
238	else {
239	if (pc)
240	printf("\treturn tmp");
241	else
242	printf("\treturn cpu->cd.arm.r[%i]",rm);
243	printf(" >> %i;\n", c);
244	}
245	}
246	break;
247
248	case 3: /* lsr Rc (Logical Shift Right by register) */
249	if (s) {
250	printf("{ uint32_t x = ");
251	if (pc)
252	printf("tmp");
253	else
254	printf("cpu->cd.arm.r[%i]", rm);
255	printf(",y=cpu->cd.arm.r[%i]&255;\n", rc);
256	printf("if(y==0) return x;\n");
257	printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
258	printf("if(y>31) y=32;\n");
259	printf("y--; x >>= y;\n");
260	printf("if (x & 1) "
261	"cpu->cd.arm.cpsr \|= ARM_FLAG_C;\n");
262	printf(" return x >> 1; }\n");
263	} else {
264	printf("{ uint32_t y=cpu->cd.arm.r[%i]&255;\n", rc);
265	printf("uint32_t x=");
266	if (pc)
267	printf("tmp");
268	else
269	printf("cpu->cd.arm.r[%i]",rm);
270	printf("; ");
271	printf("if (y>=32) return 0;\n");
272	printf("return x >> y; } ");
273	}
274	break;
275
276	case 4: /* asr c (Arithmetic Shift Right by constant) */
277	/* 1..32 */
278	if (s) {
279	printf("{ int32_t x = ");
280	if (pc)
281	printf("tmp");
282	else
283	printf("cpu->cd.arm.r[%i]", rm);
284	printf(";\n");
285	if (c == 0)
286	c = 32;
287	printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
288	printf("if (x & 0x%x)\n"
289	"\tcpu->cd.arm.cpsr \|= ARM_FLAG_C;\n",
290	(int)(1 << (c-1)));
291	if (c == 32)
292	printf("x = (x<0)? 0xffffffff : 0;\n");
293	else
294	printf("x >>= %i;\n", c);
295	printf(" return x; }\n");
296	} else {
297	if (c == 0) {
298	printf("\treturn ");
299	if (pc)
300	printf("tmp");
301	else
302	printf("cpu->cd.arm.r[%i]",rm);
303	printf(" & 0x80000000? 0xffffffff : 0;\n");
304	} else {
305	printf("return (int32_t)");
306	if (pc)
307	printf("tmp");
308	else
309	printf("cpu->cd.arm.r[%i]",rm);
310	printf(" >> %i;\n", c);
311	}
312	}
313	break;
314
315	case 5: /* asr Rc (Arithmetic Shift Right by register) */
316	if (s) {
317	printf("{ int32_t x = ");
318	if (pc)
319	printf("tmp");
320	else
321	printf("cpu->cd.arm.r[%i]", rm);
322	printf(",y=cpu->cd.arm.r[%i]&255;\n", rc);
323	printf("if(y==0) return x;\n");
324	printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
325	printf("if(y>31) y=31;\n");
326	printf("y--; x >>= y;\n");
327	printf("if (x & 1) "
328	"cpu->cd.arm.cpsr \|= ARM_FLAG_C;\n");
329	printf(" return (int32_t)x >> 1; }\n");
330	} else {
331	printf("{ int32_t y=cpu->cd.arm.r[%i]&255;\n", rc);
332	printf("int32_t x=");
333	if (pc)
334	printf("tmp");
335	else
336	printf("cpu->cd.arm.r[%i]",rm);
337	printf("; ");
338	printf("if (y>=31) return (x<0)?0xffffffff:0;\n");
339	printf("return (int32_t)x >> y; } ");
340	}
341	break;
342
343	case 6: /* ror c OR rrx (Arithmetic Shift Right by constant) */
344	/* 0=rrx, 1..31=ror */
345	if (c == 0) {
346	printf("\tprintf(\"%s\\n\");\n", name);
347	printf("\texit(1); /* TODO */\n\treturn 0;\n");
348	} else if (s) {
349	printf("{ uint64_t x = ");
350	if (pc)
351	printf("tmp");
352	else
353	printf("cpu->cd.arm.r[%i]", rm);
354	printf("; x \|= (x << 32);\n");
355	printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
356	printf("if (x & 0x%x)\n"
357	"\tcpu->cd.arm.cpsr \|= ARM_FLAG_C;\n",
358	(int)(1 << (c-1)));
359	printf(" return x >> %i; }\n", c);
360	} else {
361	printf("uint64_t x=");
362	if (pc)
363	printf("tmp");
364	else
365	printf("cpu->cd.arm.r[%i]",rm);
366	printf("; x \|= (x << 32); ");
367	printf("return x >> %i;\n", c);
368	}
369	break;
370
371	case 7: /* ror Rc (Rotate Right by register) */
372	if (s) {
373	printf("{ uint64_t x = ");
374	if (pc)
375	printf("tmp");
376	else
377	printf("cpu->cd.arm.r[%i]", rm);
378	printf("; int y=cpu->cd.arm.r[%i]&255;\n", rc);
379	printf("if(y==0) return x;\n");
380	printf("y --; y &= 31; x >>= y;\n");
381	printf("cpu->cd.arm.cpsr &= ~ARM_FLAG_C;\n");
382	printf("if (x & 1) "
383	"cpu->cd.arm.cpsr \|= ARM_FLAG_C;\n");
384	printf(" return x >> 1; }\n");
385	} else {
386	printf("{ int y=cpu->cd.arm.r[%i]&31;\n", rc);
387	printf("uint64_t x=");
388	if (pc)
389	printf("tmp");
390	else
391	printf("cpu->cd.arm.r[%i]",rm);
392	printf("; x \|= (x << 32); ");
393	printf("return (x >> y); } ");
394	}
395	break;
396
397	default:
398	printf("\tprintf(\"%s\\n\");\n", name);
399	printf("\texit(1); /* TODO */\n\treturn 0;\n");
400	}
401
402	printf("}\n");
403	}
404
405
406	int main(int argc, char *argv[])
407	{
408	int s, func, f_start, f_end;
409
410	if (argc < 3) {
411	fprintf(stderr, "usage: %s start end\n", argv[0]);
412	exit(1);
413	}
414
415	f_start = strtol(argv[1], NULL, 0);
416	f_end = strtol(argv[2], NULL, 0);
417
418	printf("/\n DO NOT EDIT! AUTOMATICALLY GENERATED!\n */\n\n");
419	printf("#include <stdio.h>\n");
420	printf("#include <stdlib.h>\n");
421	printf("#include \"cpu.h\"\n");
422	printf("#include \"misc.h\"\n");
423	printf("\n\n");
424
425	if (f_start != 0 \|\| f_end != 0) {
426	for (s=0; s<=1; s++)
427	for (func=f_start; func<=f_end; func++)
428	f(s, func, 0);
429	} else {
430	for (s=0; s<=1; s++)
431	for (func=0; func<=0xfff; func++) {
432	printf("extern uint32_t ");
433	f(s, func, 1);
434	printf("(struct cpu *, struct arm_"
435	"instr_call *);\n");
436	}
437
438	printf("\nuint32_t (arm_r[8192])(struct cpu ,"
439	" struct arm_instr_call *) = {\n");
440	for (s=0; s<=1; s++)
441	for (func=0; func<=0xfff; func++) {
442	printf("\t");
443	f(s, func, 1);
444	if (s!=1 \|\| func!=0xfff)
445	printf(",");
446	printf("\n");
447	}
448	printf("};\n\n");
449	}
450
451	return 0;
452	}
453