]>
Commit | Line | Data |
---|---|---|
d45a4bef JB |
1 | /* srcdest.c --- decoding M32C addressing modes. |
2 | ||
1d506c26 | 3 | Copyright (C) 2005-2024 Free Software Foundation, Inc. |
d45a4bef JB |
4 | Contributed by Red Hat, Inc. |
5 | ||
6 | This file is part of the GNU simulators. | |
7 | ||
4744ac1b JB |
8 | This program is free software; you can redistribute it and/or modify |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 3 of the License, or | |
11 | (at your option) any later version. | |
d45a4bef | 12 | |
4744ac1b JB |
13 | This program is distributed in the hope that it will be useful, |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
d45a4bef JB |
17 | |
18 | You should have received a copy of the GNU General Public License | |
4744ac1b | 19 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
d45a4bef | 20 | |
6df01ab8 MF |
21 | /* This must come before any other includes. */ |
22 | #include "defs.h" | |
d45a4bef JB |
23 | |
24 | #include <stdio.h> | |
25 | #include <stdlib.h> | |
26 | ||
13a590ca | 27 | #include "libiberty.h" |
d45a4bef JB |
28 | #include "cpu.h" |
29 | #include "mem.h" | |
30 | ||
31 | static int src_indirect = 0; | |
32 | static int dest_indirect = 0; | |
33 | static int src_addend = 0; | |
34 | static int dest_addend = 0; | |
35 | ||
36 | static int | |
269e9c18 | 37 | disp8 (void) |
d45a4bef JB |
38 | { |
39 | int rv; | |
40 | int tsave = trace; | |
41 | ||
42 | if (trace == 1) | |
43 | trace = 0; | |
44 | rv = mem_get_qi (get_reg (pc)); | |
45 | regs.r_pc++; | |
46 | trace = tsave; | |
47 | return rv; | |
48 | } | |
49 | ||
50 | static int | |
269e9c18 | 51 | disp16 (void) |
d45a4bef JB |
52 | { |
53 | int rv; | |
54 | int tsave = trace; | |
55 | ||
56 | if (trace == 1) | |
57 | trace = 0; | |
58 | rv = mem_get_hi (get_reg (pc)); | |
59 | regs.r_pc += 2; | |
60 | trace = tsave; | |
61 | return rv; | |
62 | } | |
63 | ||
64 | static int | |
269e9c18 | 65 | disp24 (void) |
d45a4bef JB |
66 | { |
67 | int rv; | |
68 | int tsave = trace; | |
69 | ||
70 | if (trace == 1) | |
71 | trace = 0; | |
72 | rv = mem_get_psi (get_reg (pc)); | |
73 | regs.r_pc += 3; | |
74 | trace = tsave; | |
75 | return rv; | |
76 | } | |
77 | ||
78 | static int | |
269e9c18 | 79 | disp20 (void) |
d45a4bef JB |
80 | { |
81 | return disp24 () & 0x000fffff; | |
82 | } | |
83 | ||
84 | const char * | |
85 | bits (int v, int b) | |
86 | { | |
87 | static char buf[17]; | |
88 | char *bp = buf + 16; | |
89 | *bp = 0; | |
90 | while (b) | |
91 | { | |
92 | *--bp = (v & 1) ? '1' : '0'; | |
93 | v >>= 1; | |
94 | b--; | |
95 | } | |
96 | return bp; | |
97 | } | |
98 | ||
99 | static const char *the_bits = 0; | |
100 | ||
101 | void | |
102 | decode_indirect (int si, int di) | |
103 | { | |
104 | src_indirect = si; | |
105 | dest_indirect = di; | |
106 | if (trace && (si || di)) | |
107 | printf ("indirect: s:%d d:%d\n", si, di); | |
108 | } | |
109 | ||
110 | void | |
111 | decode_index (int sa, int da) | |
112 | { | |
113 | src_addend = sa; | |
114 | dest_addend = da; | |
115 | if (trace && (sa || da)) | |
116 | printf ("index: s:%d d:%d\n", sa, da); | |
117 | } | |
118 | ||
119 | srcdest | |
120 | decode_srcdest4 (int destcode, int bw) | |
121 | { | |
122 | srcdest sd; | |
d45a4bef JB |
123 | static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3", |
124 | "a0", "a1", "[a0]", "[a1]", | |
125 | "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", | |
126 | "disp16[a0]", "disp16[a1]", "disp16[sb]", "disp16" | |
127 | }; | |
128 | static const char *dc_bnames[4] = { "r0l", "r0h", "r1l", "r1h" };; | |
129 | ||
269e9c18 MF |
130 | sd.bytes = bw ? 2 : 1; |
131 | sd.mem = (destcode >= 6) ? 1 : 0; | |
132 | ||
d45a4bef JB |
133 | if (trace) |
134 | { | |
135 | const char *n = dc_wnames[destcode]; | |
136 | if (bw == 0 && destcode <= 3) | |
137 | n = dc_bnames[destcode]; | |
138 | if (!the_bits) | |
139 | the_bits = bits (destcode, 4); | |
140 | printf ("decode: %s (%d) : %s\n", the_bits, destcode, n); | |
141 | the_bits = 0; | |
142 | } | |
143 | ||
144 | switch (destcode) | |
145 | { | |
146 | case 0x0: | |
147 | sd.u.reg = bw ? r0 : r0l; | |
148 | break; | |
149 | case 0x1: | |
150 | sd.u.reg = bw ? r1 : r0h; | |
151 | break; | |
152 | case 0x2: | |
153 | sd.u.reg = bw ? r2 : r1l; | |
154 | break; | |
155 | case 0x3: | |
156 | sd.u.reg = bw ? r3 : r1h; | |
157 | break; | |
158 | case 0x4: | |
159 | sd.u.reg = a0; | |
160 | break; | |
161 | case 0x5: | |
162 | sd.u.reg = a1; | |
163 | break; | |
164 | case 0x6: | |
165 | sd.u.addr = get_reg (a0); | |
166 | break; | |
167 | case 0x7: | |
168 | sd.u.addr = get_reg (a1); | |
169 | break; | |
170 | case 0x8: | |
171 | sd.u.addr = get_reg (a0) + disp8 (); | |
172 | break; | |
173 | case 0x9: | |
174 | sd.u.addr = get_reg (a1) + disp8 (); | |
175 | break; | |
176 | case 0xa: | |
177 | sd.u.addr = get_reg (sb) + disp8 (); | |
178 | break; | |
179 | case 0xb: | |
180 | sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8); | |
181 | break; | |
182 | case 0xc: | |
183 | sd.u.addr = get_reg (a0) + disp16 (); | |
184 | break; | |
185 | case 0xd: | |
186 | sd.u.addr = get_reg (a1) + disp16 (); | |
187 | break; | |
188 | case 0xe: | |
189 | sd.u.addr = get_reg (sb) + disp16 (); | |
190 | break; | |
191 | case 0xf: | |
192 | sd.u.addr = disp16 (); | |
193 | break; | |
194 | default: | |
195 | abort (); | |
196 | } | |
197 | if (sd.mem) | |
198 | sd.u.addr &= addr_mask; | |
199 | return sd; | |
200 | } | |
201 | ||
202 | srcdest | |
203 | decode_jumpdest (int destcode, int w) | |
204 | { | |
205 | srcdest sd; | |
d45a4bef JB |
206 | static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3", |
207 | "a0", "a1", "[a0]", "[a1]", | |
208 | "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", | |
209 | "disp20[a0]", "disp20[a1]", "disp16[sb]", "abs16" | |
210 | }; | |
211 | static const char *dc_anames[4] = { "r0l", "r0h", "r1l", "r1h" }; | |
212 | ||
269e9c18 MF |
213 | sd.bytes = w ? 2 : 3; |
214 | sd.mem = (destcode >= 6) ? 1 : 0; | |
215 | ||
d45a4bef JB |
216 | if (trace) |
217 | { | |
218 | const char *n = dc_wnames[destcode]; | |
219 | if (w == 0 && destcode <= 3) | |
220 | n = dc_anames[destcode]; | |
221 | if (!the_bits) | |
222 | the_bits = bits (destcode, 4); | |
223 | printf ("decode: %s : %s\n", the_bits, n); | |
224 | the_bits = 0; | |
225 | } | |
226 | ||
227 | switch (destcode) | |
228 | { | |
229 | case 0x0: | |
230 | sd.u.reg = w ? r0 : r2r0; | |
231 | break; | |
232 | case 0x1: | |
233 | sd.u.reg = w ? r1 : r2r0; | |
234 | break; | |
235 | case 0x2: | |
236 | sd.u.reg = w ? r2 : r3r1; | |
237 | break; | |
238 | case 0x3: | |
239 | sd.u.reg = w ? r3 : r3r1; | |
240 | break; | |
241 | case 0x4: | |
242 | sd.u.reg = w ? a0 : a1a0; | |
243 | break; | |
244 | case 0x5: | |
245 | sd.u.reg = w ? a1 : a1a0; | |
246 | break; | |
247 | case 0x6: | |
248 | sd.u.addr = get_reg (a0); | |
249 | break; | |
250 | case 0x7: | |
251 | sd.u.addr = get_reg (a1); | |
252 | break; | |
253 | case 0x8: | |
254 | sd.u.addr = get_reg (a0) + disp8 (); | |
255 | break; | |
256 | case 0x9: | |
257 | sd.u.addr = get_reg (a1) + disp8 (); | |
258 | break; | |
259 | case 0xa: | |
260 | sd.u.addr = get_reg (sb) + disp8 (); | |
261 | break; | |
262 | case 0xb: | |
263 | sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8); | |
264 | break; | |
265 | case 0xc: | |
266 | sd.u.addr = get_reg (a0) + disp20 (); | |
267 | break; | |
268 | case 0xd: | |
269 | sd.u.addr = get_reg (a1) + disp20 (); | |
270 | break; | |
271 | case 0xe: | |
272 | sd.u.addr = get_reg (sb) + disp16 (); | |
273 | break; | |
274 | case 0xf: | |
275 | sd.u.addr = disp16 (); | |
276 | break; | |
277 | default: | |
278 | abort (); | |
279 | } | |
280 | if (sd.mem) | |
281 | sd.u.addr &= addr_mask; | |
282 | return sd; | |
283 | } | |
284 | ||
285 | srcdest | |
286 | decode_dest3 (int destcode, int bw) | |
287 | { | |
288 | static char map[8] = { -1, -1, -1, 1, 0, 10, 11, 15 }; | |
289 | ||
290 | the_bits = bits (destcode, 3); | |
291 | return decode_srcdest4 (map[destcode], bw); | |
292 | } | |
293 | ||
294 | srcdest | |
295 | decode_src2 (int srccode, int bw, int d) | |
296 | { | |
297 | static char map[4] = { 0, 10, 11, 15 }; | |
298 | ||
299 | the_bits = bits (srccode, 2); | |
300 | return decode_srcdest4 (srccode ? map[srccode] : 1 - d, bw); | |
301 | } | |
302 | ||
303 | static struct | |
304 | { | |
305 | reg_id b_regno; | |
306 | reg_id w_regno; | |
307 | int is_memory; | |
308 | int disp_bytes; | |
309 | char *name; | |
310 | } modes23[] = | |
311 | { | |
312 | { | |
313 | a0, a0, 1, 0, "[A0]"}, /* 0 0 0 0 0 */ | |
314 | { | |
315 | a1, a1, 1, 0, "[A1]"}, /* 0 0 0 0 1 */ | |
316 | { | |
317 | a0, a0, 0, 0, "A0"}, /* 0 0 0 1 0 */ | |
318 | { | |
319 | a1, a1, 0, 0, "A1"}, /* 0 0 0 1 1 */ | |
320 | { | |
321 | a0, a0, 1, 1, "dsp:8[A0]"}, /* 0 0 1 0 0 */ | |
322 | { | |
323 | a1, a1, 1, 1, "dsp:8[A1]"}, /* 0 0 1 0 1 */ | |
324 | { | |
325 | sb, sb, 1, 1, "dsp:8[SB]"}, /* 0 0 1 1 0 */ | |
326 | { | |
327 | fb, fb, 1, -1, "dsp:8[FB]"}, /* 0 0 1 1 1 */ | |
328 | { | |
329 | a0, a0, 1, 2, "dsp:16[A0]"}, /* 0 1 0 0 0 */ | |
330 | { | |
331 | a1, a1, 1, 2, "dsp:16[A1]"}, /* 0 1 0 0 1 */ | |
332 | { | |
333 | sb, sb, 1, 2, "dsp:16[SB]"}, /* 0 1 0 1 0 */ | |
334 | { | |
335 | fb, fb, 1, -2, "dsp:16[FB]"}, /* 0 1 0 1 1 */ | |
336 | { | |
337 | a0, a0, 1, 3, "dsp:24[A0]"}, /* 0 1 1 0 0 */ | |
338 | { | |
339 | a1, a1, 1, 3, "dsp:24[A1]"}, /* 0 1 1 0 1 */ | |
340 | { | |
341 | mem, mem, 1, 3, "abs24"}, /* 0 1 1 1 0 */ | |
342 | { | |
343 | mem, mem, 1, 2, "abs16"}, /* 0 1 1 1 1 */ | |
344 | { | |
345 | r0h, r2, 0, 0, "R0H/R2"}, /* 1 0 0 0 0 */ | |
346 | { | |
347 | r1h, r3, 0, 0, "R1H/R3"}, /* 1 0 0 0 1 */ | |
348 | { | |
349 | r0l, r0, 0, 0, "R0L/R0"}, /* 1 0 0 1 0 */ | |
350 | { | |
351 | r1l, r1, 0, 0, "R1L/R1"}, /* 1 0 0 1 1 */ | |
352 | }; | |
353 | ||
354 | static srcdest | |
355 | decode_sd23 (int bbb, int bb, int bytes, int ind, int add) | |
356 | { | |
357 | srcdest sd; | |
358 | int code = (bbb << 2) | bb; | |
359 | ||
13a590ca | 360 | if (code >= ARRAY_SIZE (modes23)) |
d45a4bef JB |
361 | abort (); |
362 | ||
363 | if (trace) | |
364 | { | |
365 | char *b1 = ""; | |
366 | char *b2 = ""; | |
367 | char ad[30]; | |
368 | if (ind) | |
369 | { | |
370 | b1 = "["; | |
371 | b2 = "]"; | |
372 | } | |
373 | if (add) | |
374 | sprintf (ad, "%+d", add); | |
375 | else | |
376 | ad[0] = 0; | |
377 | if (!the_bits) | |
378 | the_bits = bits (code, 4); | |
379 | printf ("decode: %s (%d) : %s%s%s%s\n", the_bits, code, b1, | |
380 | modes23[code].name, ad, b2); | |
381 | the_bits = 0; | |
382 | } | |
383 | ||
384 | sd.bytes = bytes; | |
385 | sd.mem = modes23[code].is_memory; | |
386 | if (sd.mem) | |
387 | { | |
388 | if (modes23[code].w_regno == mem) | |
389 | sd.u.addr = 0; | |
390 | else | |
391 | sd.u.addr = get_reg (modes23[code].w_regno); | |
392 | switch (modes23[code].disp_bytes) | |
393 | { | |
394 | case 1: | |
395 | sd.u.addr += disp8 (); | |
396 | break; | |
397 | case 2: | |
398 | sd.u.addr += disp16 (); | |
399 | break; | |
400 | case -1: | |
401 | sd.u.addr += sign_ext (disp8 (), 8); | |
402 | break; | |
403 | case -2: | |
404 | sd.u.addr += sign_ext (disp16 (), 16); | |
405 | break; | |
406 | case 3: | |
407 | sd.u.addr += disp24 (); | |
408 | break; | |
409 | default: | |
410 | break; | |
411 | } | |
412 | if (add) | |
413 | sd.u.addr += add; | |
414 | if (ind) | |
415 | sd.u.addr = mem_get_si (sd.u.addr & membus_mask); | |
416 | sd.u.addr &= membus_mask; | |
417 | } | |
418 | else | |
419 | { | |
420 | sd.u.reg = (bytes > 1) ? modes23[code].w_regno : modes23[code].b_regno; | |
421 | if (bytes == 3 || bytes == 4) | |
422 | { | |
423 | switch (sd.u.reg) | |
424 | { | |
425 | case r0: | |
426 | sd.u.reg = r2r0; | |
427 | break; | |
428 | case r1: | |
429 | sd.u.reg = r3r1; | |
430 | break; | |
431 | case r2: | |
432 | abort (); | |
433 | case r3: | |
434 | abort (); | |
435 | default:; | |
436 | } | |
437 | } | |
438 | ||
439 | } | |
440 | return sd; | |
441 | } | |
442 | ||
443 | srcdest | |
444 | decode_dest23 (int ddd, int dd, int bytes) | |
445 | { | |
446 | return decode_sd23 (ddd, dd, bytes, dest_indirect, dest_addend); | |
447 | } | |
448 | ||
449 | srcdest | |
450 | decode_src23 (int sss, int ss, int bytes) | |
451 | { | |
452 | return decode_sd23 (sss, ss, bytes, src_indirect, src_addend); | |
453 | } | |
454 | ||
455 | srcdest | |
456 | decode_dest2 (int dd, int bytes) | |
457 | { | |
458 | /* r0l/r0, abs16, dsp:8[SB], dsp:8[FB] */ | |
459 | static char map[4] = { 0x12, 0x0f, 0x06, 0x07 }; | |
460 | ||
461 | the_bits = bits (dd, 2); | |
462 | return decode_sd23 (map[dd] >> 2, map[dd] & 3, bytes, dest_indirect, | |
463 | dest_addend); | |
464 | } | |
465 | ||
466 | srcdest | |
467 | decode_src3 (int sss, int bytes) | |
468 | { | |
469 | /* r0, r1, a0, a1, r2, r3, N/A, N/A */ | |
470 | static char map[8] = { 0x12, 0x13, 0x02, 0x03, 0x10, 0x11, 0, 0 }; | |
471 | ||
472 | the_bits = bits (sss, 3); | |
473 | return decode_sd23 (map[sss] >> 2, map[sss] & 3, bytes, src_indirect, | |
474 | src_addend); | |
475 | } | |
476 | ||
477 | srcdest | |
478 | decode_dest1 (int destcode, int bw) | |
479 | { | |
480 | the_bits = bits (destcode, 1); | |
481 | return decode_srcdest4 (destcode, bw); | |
482 | } | |
483 | ||
484 | srcdest | |
485 | decode_cr (int crcode) | |
486 | { | |
487 | static int regcode[] = { 0, intbl, intbh, flags, isp, sp, sb, fb }; | |
488 | srcdest sd; | |
489 | sd.mem = 0; | |
490 | sd.bytes = 2; | |
491 | sd.u.reg = regcode[crcode & 7]; | |
492 | return sd; | |
493 | } | |
494 | ||
495 | srcdest | |
496 | decode_cr_b (int crcode, int bank) | |
497 | { | |
498 | /* FIXME: intbl, intbh, isp */ | |
499 | static int regcode[3][8] = { | |
500 | {0, 0, flags, 0, 0, 0, 0, 0}, | |
501 | {intb, sp, sb, fb, 0, 0, 0, isp}, | |
502 | {0, 0, 0, 0, 0, 0, 0, 0} | |
503 | }; | |
504 | srcdest sd; | |
505 | sd.mem = 0; | |
506 | sd.bytes = bank ? 3 : 2; | |
507 | sd.u.reg = regcode[bank][crcode & 7]; | |
508 | return sd; | |
509 | } | |
510 | ||
511 | srcdest | |
512 | widen_sd (srcdest sd) | |
513 | { | |
514 | sd.bytes *= 2; | |
515 | if (!sd.mem) | |
516 | switch (sd.u.reg) | |
517 | { | |
518 | case r0l: | |
519 | sd.u.reg = r0; | |
520 | break; | |
521 | case r0: | |
522 | sd.u.reg = r2r0; | |
523 | break; | |
524 | case r1l: | |
525 | sd.u.reg = r1; | |
526 | break; | |
527 | case r1: | |
528 | sd.u.reg = r3r1; | |
529 | break; | |
530 | case a0: | |
531 | if (A16) | |
532 | sd.u.reg = a1a0; | |
533 | break; | |
534 | default: | |
535 | break; | |
536 | } | |
537 | return sd; | |
538 | } | |
539 | ||
540 | srcdest | |
541 | reg_sd (reg_id reg) | |
542 | { | |
543 | srcdest rv; | |
544 | rv.bytes = reg_bytes[reg]; | |
545 | rv.mem = 0; | |
546 | rv.u.reg = reg; | |
547 | return rv; | |
548 | } | |
549 | ||
550 | int | |
551 | get_src (srcdest sd) | |
552 | { | |
553 | int v; | |
554 | if (sd.mem) | |
555 | { | |
556 | switch (sd.bytes) | |
557 | { | |
558 | case 1: | |
559 | v = mem_get_qi (sd.u.addr); | |
560 | break; | |
561 | case 2: | |
562 | v = mem_get_hi (sd.u.addr); | |
563 | break; | |
564 | case 3: | |
565 | v = mem_get_psi (sd.u.addr); | |
566 | break; | |
567 | case 4: | |
568 | v = mem_get_si (sd.u.addr); | |
569 | break; | |
570 | default: | |
571 | abort (); | |
572 | } | |
573 | } | |
574 | else | |
575 | { | |
576 | v = get_reg (sd.u.reg); | |
577 | switch (sd.bytes) | |
578 | { | |
579 | case 1: | |
580 | v &= 0xff; | |
581 | break; | |
582 | case 2: | |
583 | v &= 0xffff; | |
584 | break; | |
585 | case 3: | |
586 | v &= 0xffffff; | |
587 | break; | |
588 | } | |
589 | } | |
590 | return v; | |
591 | } | |
592 | ||
593 | void | |
594 | put_dest (srcdest sd, int v) | |
595 | { | |
596 | if (sd.mem) | |
597 | { | |
598 | switch (sd.bytes) | |
599 | { | |
600 | case 1: | |
601 | mem_put_qi (sd.u.addr, v); | |
602 | break; | |
603 | case 2: | |
604 | mem_put_hi (sd.u.addr, v); | |
605 | break; | |
606 | case 3: | |
607 | mem_put_psi (sd.u.addr, v); | |
608 | break; | |
609 | case 4: | |
610 | mem_put_si (sd.u.addr, v); | |
611 | break; | |
612 | } | |
613 | } | |
614 | else | |
615 | { | |
616 | switch (sd.bytes) | |
617 | { | |
618 | case 1: | |
619 | v &= 0xff; | |
620 | break; | |
621 | case 2: | |
622 | v &= 0xffff; | |
623 | break; | |
624 | case 3: | |
625 | v &= 0xffffff; | |
626 | break; | |
627 | } | |
628 | put_reg (sd.u.reg, v); | |
629 | } | |
630 | } | |
631 | ||
632 | srcdest | |
633 | decode_bit (int destcode) | |
634 | { | |
635 | srcdest sd; | |
636 | int addr = 0; | |
637 | static const char *dc_names[] = { "r0", "r1", "r2", "r3", | |
638 | "a0", "a1", "[a0]", "[a1]", | |
639 | "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", | |
640 | "disp16[a0]", "disp16[a1]", "disp16[sb]", "abs16" | |
641 | }; | |
642 | ||
643 | if (trace) | |
644 | { | |
645 | const char *the_bits = bits (destcode, 4); | |
646 | printf ("decode: %s : %s\n", the_bits, dc_names[destcode]); | |
647 | } | |
648 | ||
649 | switch (destcode) | |
650 | { | |
651 | case 0: | |
652 | sd.u.reg = r0; | |
653 | break; | |
654 | case 1: | |
655 | sd.u.reg = r1; | |
656 | break; | |
657 | case 2: | |
658 | sd.u.reg = r2; | |
659 | break; | |
660 | case 3: | |
661 | sd.u.reg = r3; | |
662 | break; | |
663 | case 4: | |
664 | sd.u.reg = a0; | |
665 | break; | |
666 | case 5: | |
667 | sd.u.reg = a1; | |
668 | break; | |
669 | case 6: | |
670 | addr = get_reg (a0); | |
671 | break; | |
672 | case 7: | |
673 | addr = get_reg (a1); | |
674 | break; | |
675 | case 8: | |
676 | addr = get_reg (a0) + disp8 (); | |
677 | break; | |
678 | case 9: | |
679 | addr = get_reg (a1) + disp8 (); | |
680 | break; | |
681 | case 10: | |
682 | addr = get_reg (sb) * 8 + disp8 (); | |
683 | break; | |
684 | case 11: | |
685 | addr = get_reg (fb) * 8 + sign_ext (disp8 (), 8); | |
686 | break; | |
687 | case 12: | |
688 | addr = get_reg (a0) + disp16 (); | |
689 | break; | |
690 | case 13: | |
691 | addr = get_reg (a1) + disp16 (); | |
692 | break; | |
693 | case 14: | |
694 | addr = get_reg (sb) + disp16 (); | |
695 | break; | |
696 | case 15: | |
697 | addr = disp16 (); | |
698 | break; | |
699 | } | |
700 | ||
701 | if (destcode < 6) | |
702 | { | |
703 | int d = disp8 (); | |
704 | sd.mem = 0; | |
705 | sd.mask = 1 << (d & 0x0f); | |
706 | } | |
707 | else | |
708 | { | |
709 | addr &= addr_mask; | |
710 | sd.mem = 1; | |
711 | sd.mask = 1 << (addr & 7); | |
712 | sd.u.addr = addr >> 3; | |
713 | } | |
714 | return sd; | |
715 | } | |
716 | ||
717 | srcdest | |
718 | decode_bit11 (int op0) | |
719 | { | |
720 | srcdest sd; | |
721 | sd.mask = 1 << (op0 & 7); | |
722 | sd.mem = 1; | |
723 | sd.u.addr = get_reg (sb) + disp8 (); | |
724 | return sd; | |
725 | } | |
726 | ||
727 | int | |
728 | get_bit (srcdest sd) | |
729 | { | |
730 | int b; | |
731 | if (sd.mem) | |
732 | b = mem_get_qi (sd.u.addr) & sd.mask; | |
733 | else | |
734 | b = get_reg (sd.u.reg) & sd.mask; | |
735 | return b ? 1 : 0; | |
736 | } | |
737 | ||
738 | void | |
739 | put_bit (srcdest sd, int val) | |
740 | { | |
741 | int b; | |
742 | if (sd.mem) | |
743 | b = mem_get_qi (sd.u.addr); | |
744 | else | |
745 | b = get_reg (sd.u.reg); | |
746 | if (val) | |
747 | b |= sd.mask; | |
748 | else | |
749 | b &= ~sd.mask; | |
750 | if (sd.mem) | |
751 | mem_put_qi (sd.u.addr, b); | |
752 | else | |
753 | put_reg (sd.u.reg, b); | |
754 | } | |
755 | ||
756 | int | |
757 | get_bit2 (srcdest sd, int bit) | |
758 | { | |
759 | int b; | |
760 | if (sd.mem) | |
761 | b = mem_get_qi (sd.u.addr + (bit >> 3)) & (1 << (bit & 7)); | |
762 | else | |
763 | b = get_reg (sd.u.reg) & (1 << bit); | |
764 | return b ? 1 : 0; | |
765 | } | |
766 | ||
767 | void | |
768 | put_bit2 (srcdest sd, int bit, int val) | |
769 | { | |
770 | int b; | |
771 | if (sd.mem) | |
772 | b = mem_get_qi (sd.u.addr + (bit >> 3)); | |
773 | else | |
774 | b = get_reg (sd.u.reg); | |
775 | if (val) | |
776 | b |= (1 << (bit & 7)); | |
777 | else | |
778 | b &= ~(1 << (bit & 7)); | |
779 | if (sd.mem) | |
780 | mem_put_qi (sd.u.addr + (bit >> 3), b); | |
781 | else | |
782 | put_reg (sd.u.reg, b); | |
783 | } |