OpenCores
URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [sim/] [m32c/] [srcdest.c] - Blame information for rev 27

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.