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