OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [sim/] [m32c/] [opc2c.c] - Blame information for rev 302

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

Line No. Rev Author Line
1 227 jeremybenn
/* opc2c.c --- generate C simulator code from from .opc file
2
 
3
Copyright (C) 2005, 2007, 2008, 2009, 2010 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 <string.h>
24
#include <ctype.h>
25
#include <stdlib.h>
26
 
27
#include "safe-fgets.h"
28
 
29
static int errors = 0;
30
 
31
#define MAX_BYTES 10
32
 
33
typedef struct
34
{
35
  int varyno:16;
36
  int byte:8;
37
  int shift:8;
38
} VaryRef;
39
 
40
typedef struct
41
{
42
  char nbytes;
43
  char dbytes;
44
  char id[MAX_BYTES * 8 + 1];
45
  unsigned char var_start[MAX_BYTES * 8 + 1];
46
  struct
47
  {
48
    unsigned char decodable_mask;
49
    unsigned char decodable_bits;
50
  } b[MAX_BYTES];
51
  char *comment;
52
  int lineno;
53
  int nlines;
54
  char **lines;
55
  struct Indirect *last_ind;
56
  int semantics_label;
57
  int nvaries;
58
  VaryRef *vary;
59
} opcode;
60
 
61
int n_opcodes;
62
opcode **opcodes;
63
opcode *op;
64
 
65
typedef struct
66
{
67
  char *name;
68
  int nlen;
69
  unsigned char mask;
70
  int n_patterns;
71
  unsigned char *patterns;
72
} Vary;
73
 
74
Vary **vary = 0;
75
int n_varies = 0;
76
 
77
unsigned char cur_bits[MAX_BYTES + 1];
78
 
79
char *orig_filename;
80
 
81
FILE *sim_log = 0;
82
#define lprintf if (sim_log) fprintf
83
 
84
opcode prefix_text, suffix_text;
85
 
86
typedef enum
87
{
88
  T_unused,
89
  T_op,
90
  T_indirect,
91
  T_done
92
} OpType;
93
 
94
typedef struct Indirect
95
{
96
  OpType type;
97
  union
98
  {
99
    struct Indirect *ind;
100
    opcode *op;
101
  } u;
102
} Indirect;
103
 
104
Indirect indirect[256];
105
 
106
static int
107
next_varybits (int bits, opcode * op, int byte)
108
{
109
  int mask = op->b[byte].decodable_mask;
110
  int i;
111
 
112
  for (i = 0; i < 8; i++)
113
    if (!(mask & (1 << i)))
114
      {
115
        if (bits & (1 << i))
116
          {
117
            bits &= ~(1 << i);
118
          }
119
        else
120
          {
121
            bits |= (1 << i);
122
            return bits;
123
          }
124
      }
125
  return 0;
126
}
127
 
128
static int
129
valid_varybits (int bits, opcode * op, int byte)
130
{
131
  if (op->nvaries)
132
    {
133
      int vn;
134
      for (vn = 0; vn < op->nvaries; vn++)
135
        {
136
          int found = 0;
137
          int i;
138
          int ob;
139
 
140
          if (byte != op->vary[vn].byte)
141
            continue;
142
          Vary *v = vary[op->vary[vn].varyno];
143
          ob = (bits >> op->vary[vn].shift) & v->mask;
144
          lprintf (sim_log, "varybits: vary %s ob %x\n", v->name, ob);
145
 
146
          for (i = 0; i < v->n_patterns; i++)
147
            if (ob == v->patterns[i])
148
              {
149
                lprintf (sim_log, "  found at %d\n", i);
150
                found = 1;
151
                break;
152
              }
153
          if (!found)
154
            return 0;
155
        }
156
    }
157
  return 1;
158
}
159
 
160
char *
161
prmb (int mask, int bits)
162
{
163
  static char buf[8][30];
164
  static int bn = 0;
165
  char *bp;
166
 
167
  bn = (bn + 1) % 8;
168
  bp = buf[bn];
169
  int i;
170
  for (i = 0; i < 8; i++)
171
    {
172
      int bit = 0x80 >> i;
173
      if (!(mask & bit))
174
        *bp++ = '-';
175
      else if (bits & bit)
176
        *bp++ = '1';
177
      else
178
        *bp++ = '0';
179
      if (i % 4 == 3)
180
        *bp++ = ' ';
181
    }
182
  *--bp = 0;
183
  return buf[bn];
184
}
185
 
186
static int
187
op_cmp (const void *va, const void *vb)
188
{
189
  const opcode *a = *(const opcode **) va;
190
  const opcode *b = *(const opcode **) vb;
191
 
192
  if (a->nbytes != b->nbytes)
193
    return a->nbytes - b->nbytes;
194
 
195
  return strcmp (a->id, b->id);
196
}
197
 
198
void
199
dump_lines (opcode * op, int level, Indirect * ind)
200
{
201
  char *varnames[40];
202
  int i, vn = 0;
203
 
204
  if (op->semantics_label)
205
    {
206
      printf ("%*sgoto op_semantics_%d;\n", level, "", op->semantics_label);
207
      return;
208
    }
209
 
210
  if (ind != op->last_ind)
211
    {
212
      static int labelno = 0;
213
      labelno++;
214
      printf ("%*sop_semantics_%d:\n", level, "", labelno);
215
      op->semantics_label = labelno;
216
    }
217
 
218
  if (op->comment)
219
    {
220
      level += 2;
221
      printf ("%*s{\n", level, "");
222
      printf ("%*s  %s\n", level, "", op->comment);
223
    }
224
 
225
  for (i = 0; i < op->nbytes * 8;)
226
    {
227
      if (isalpha (op->id[i]))
228
        {
229
          int byte = i >> 3;
230
          int mask = 0;
231
          int shift = 0;
232
          char name[33];
233
          char *np = name;
234
          while (op->id[i] && isalpha (op->id[i]))
235
            {
236
              mask = (mask << 1) | 1;
237
              shift = 7 - (i & 7);
238
              *np++ = op->id[i++];
239
              if (op->var_start[i])
240
                break;
241
            }
242
          *np = 0;
243
          varnames[vn++] = strdup (name);
244
          printf ("#line %d \"%s\"\n", op->lineno, orig_filename);
245
          if (mask & ~0xff)
246
            {
247
              fprintf (stderr, "Error: variable %s spans bytes: %s\n",
248
                       name, op->comment);
249
              errors++;
250
            }
251
          else if (shift && (mask != 0xff))
252
            printf ("%*s  int %s AU = (op[%d] >> %d) & 0x%02x;\n",
253
                    level, "", name, byte, shift, mask);
254
          else if (mask != 0xff)
255
            printf ("%*s  int %s AU = op[%d] & 0x%02x;\n",
256
                    level, "", name, byte, mask);
257
          else
258
            printf ("%*s  int %s AU = op[%d];\n", level, "", name, byte);
259
        }
260
      else
261
        i++;
262
    }
263
  if (op->comment)
264
    {
265
      printf ("%*s  if (trace) {\n", level, "");
266
      printf ("%*s      printf(\"\\033[33m%%s\\033[0m ", level, "");
267
      for (i = 0; i < op->nbytes; i++)
268
        printf (" %%02x");
269
      printf ("\\n\"");
270
      printf (",\n%*s             \"%s\"", level, "", op->comment);
271
      for (i = 0; i < op->nbytes; i++)
272
        {
273
          if (i == 0)
274
            printf (",\n%*s             op[%d]", level, "", i);
275
          else
276
            printf (", op[%d]", i);
277
        }
278
      printf (");\n");
279
      for (i = 0; i < vn; i++)
280
        printf ("%*s      printf(\"  %s = 0x%%x%s\", %s);\n", level, "",
281
                varnames[i], (i < vn - 1) ? "," : "\\n", varnames[i]);
282
      printf ("%*s    }\n", level, "");
283
    }
284
  printf ("#line %d \"%s\"\n", op->lineno + 1, orig_filename);
285
  for (i = 0; i < op->nlines; i++)
286
    printf ("%*s%s", level, "", op->lines[i]);
287
  if (op->comment)
288
    printf ("%*s}\n", level, "");
289
}
290
 
291
void
292
store_opcode_bits (opcode * op, int byte, Indirect * ind)
293
{
294
  int bits = op->b[byte].decodable_bits;
295
 
296
  do
297
    {
298
      if (!valid_varybits (bits, op, byte))
299
        continue;
300
 
301
      switch (ind[bits].type)
302
        {
303
        case T_unused:
304
          if (byte == op->dbytes - 1)
305
            {
306
              ind[bits].type = T_op;
307
              ind[bits].u.op = op;
308
              op->last_ind = ind;
309
              break;
310
            }
311
          else
312
            {
313
              int i2;
314
              ind[bits].type = T_indirect;
315
              ind[bits].u.ind = (Indirect *) malloc (256 * sizeof (Indirect));
316
              for (i2 = 0; i2 < 256; i2++)
317
                ind[bits].u.ind[i2].type = T_unused;
318
              store_opcode_bits (op, byte + 1, ind[bits].u.ind);
319
            }
320
          break;
321
 
322
        case T_indirect:
323
          if (byte < op->dbytes - 1)
324
            store_opcode_bits (op, byte + 1, ind[bits].u.ind);
325
          break;
326
 
327
        case T_op:
328
          break;
329
 
330
        case T_done:
331
          break;
332
        }
333
    }
334
  while ((bits = next_varybits (bits, op, byte)) != 0);
335
}
336
 
337
void
338
emit_indirect (Indirect * ind, int byte)
339
{
340
  int unsup = 0;
341
  int j, n, mask;
342
 
343
  mask = 0;
344
  for (j = 0; j < 256; j++)
345
    {
346
      switch (ind[j].type)
347
        {
348
        case T_indirect:
349
          mask = 0xff;
350
          break;
351
        case T_op:
352
          mask |= ind[j].u.op->b[byte].decodable_mask;
353
          break;
354
        case T_done:
355
        case T_unused:
356
          break;
357
        }
358
    }
359
 
360
  printf ("%*s  GETBYTE();\n", byte * 6, "");
361
  printf ("%*s  switch (op[%d] & 0x%02x) {\n", byte * 6, "", byte, mask);
362
  for (j = 0; j < 256; j++)
363
    if ((j & ~mask) == 0)
364
      {
365
        switch (ind[j].type)
366
          {
367
          case T_done:
368
            break;
369
          case T_unused:
370
            unsup = 1;
371
            break;
372
          case T_op:
373
            for (n = j; n < 256; n++)
374
              if ((n & ~mask) == 0
375
                  && ind[n].type == T_op && ind[n].u.op == ind[j].u.op)
376
                {
377
                  ind[n].type = T_done;
378
                  printf ("%*s    case 0x%02x:\n", byte * 6, "", n);
379
                }
380
            for (n = byte; n < ind[j].u.op->nbytes - 1; n++)
381
              printf ("%*s      GETBYTE();\n", byte * 6, "");
382
            dump_lines (ind[j].u.op, byte * 6 + 6, ind);
383
            printf ("%*s      break;\n", byte * 6, "");
384
            break;
385
          case T_indirect:
386
            printf ("%*s    case 0x%02x:\n", byte * 6, "", j);
387
            emit_indirect (ind[j].u.ind, byte + 1);
388
            printf ("%*s      break;\n", byte * 6, "");
389
            break;
390
          }
391
      }
392
  if (unsup)
393
    printf ("%*s    default: UNSUPPORTED(); break;\n", byte * 6, "");
394
  printf ("%*s  }\n", byte * 6, "");
395
}
396
 
397
static char *
398
pv_dup (char *p, char *ep)
399
{
400
  int n = ep - p;
401
  char *rv = (char *) malloc (n + 1);
402
  memcpy (rv, p, n);
403
  rv[n] = 0;
404
  return rv;
405
}
406
 
407
static unsigned char
408
str2mask (char *str, char *ep)
409
{
410
  unsigned char rv = 0;
411
  while (str < ep)
412
    {
413
      rv *= 2;
414
      if (*str == '1')
415
        rv += 1;
416
      str++;
417
    }
418
  return rv;
419
}
420
 
421
static void
422
process_vary (char *line)
423
{
424
  char *cp, *ep;
425
  Vary *v = (Vary *) malloc (sizeof (Vary));
426
 
427
  n_varies++;
428
  if (vary)
429
    vary = (Vary **) realloc (vary, n_varies * sizeof (Vary *));
430
  else
431
    vary = (Vary **) malloc (n_varies * sizeof (Vary *));
432
  vary[n_varies - 1] = v;
433
 
434
  cp = line;
435
 
436
  for (cp = line; isspace (*cp); cp++);
437
  for (ep = cp; *ep && !isspace (*ep); ep++);
438
 
439
  v->name = pv_dup (cp, ep);
440
  v->nlen = strlen (v->name);
441
  v->mask = (1 << v->nlen) - 1;
442
 
443
  v->n_patterns = 0;
444
  v->patterns = (unsigned char *) malloc (1);
445
  while (1)
446
    {
447
      for (cp = ep; isspace (*cp); cp++);
448
      if (!isdigit (*cp))
449
        break;
450
      for (ep = cp; *ep && !isspace (*ep); ep++);
451
      v->n_patterns++;
452
      v->patterns = (unsigned char *) realloc (v->patterns, v->n_patterns);
453
      v->patterns[v->n_patterns - 1] = str2mask (cp, ep);
454
    }
455
}
456
 
457
static int
458
fieldcmp (opcode * op, int bit, char *name)
459
{
460
  int n = strlen (name);
461
  if (memcmp (op->id + bit, name, n) == 0
462
      && (!isalpha (op->id[bit + n]) || op->var_start[bit + n]))
463
    return 1;
464
  return 0;
465
}
466
 
467
static void
468
log_indirect (Indirect * ind, int byte)
469
{
470
  int i, j;
471
  char *last_c = 0;
472
 
473
  for (i = 0; i < 256; i++)
474
    {
475
 
476
      for (j = 0; j < byte; j++)
477
        fprintf (sim_log, "%s ", prmb (255, cur_bits[j]));
478
      fprintf (sim_log, "%s ", prmb (255, i));
479
 
480
      switch (ind[i].type)
481
        {
482
        case T_op:
483
        case T_done:
484
          if (last_c && (ind[i].u.op->comment == last_c))
485
            fprintf (sim_log, "''\n");
486
          else
487
            fprintf (sim_log, "%s\n", ind[i].u.op->comment);
488
          last_c = ind[i].u.op->comment;
489
          break;
490
        case T_unused:
491
          fprintf (sim_log, "unused\n");
492
          break;
493
        case T_indirect:
494
          fprintf (sim_log, "indirect\n");
495
          cur_bits[byte] = i;
496
          log_indirect (ind[i].u.ind, byte + 1);
497
          last_c = 0;
498
          break;
499
        }
500
    }
501
}
502
 
503
int
504
main (int argc, char **argv)
505
{
506
  char *line;
507
  FILE *in;
508
  int lineno = 0;
509
  int i;
510
  VaryRef *vlist;
511
 
512
  if (argc > 2 && strcmp (argv[1], "-l") == 0)
513
    {
514
      sim_log = fopen (argv[2], "w");
515
      fprintf (stderr, "sim_log: %s\n", argv[2]);
516
      argc -= 2;
517
      argv += 2;
518
    }
519
 
520
  if (argc < 2)
521
    {
522
      fprintf (stderr, "usage: opc2c infile.opc > outfile.opc\n");
523
      exit (1);
524
    }
525
 
526
  orig_filename = argv[1];
527
  in = fopen (argv[1], "r");
528
  if (!in)
529
    {
530
      fprintf (stderr, "Unable to open file %s for reading\n", argv[1]);
531
      perror ("The error was");
532
      exit (1);
533
    }
534
 
535
  n_opcodes = 0;
536
  opcodes = (opcode **) malloc (sizeof (opcode *));
537
  op = &prefix_text;
538
  op->lineno = 1;
539
  while ((line = safe_fgets (in)) != 0)
540
    {
541
      lineno++;
542
      if (strncmp (line, "  /** ", 6) == 0
543
          && (isdigit (line[6]) || memcmp (line + 6, "VARY", 4) == 0))
544
        line += 2;
545
      if (line[0] == '/' && line[1] == '*' && line[2] == '*')
546
        {
547
          if (strncmp (line, "/** */", 6) == 0)
548
            {
549
              op = &suffix_text;
550
              op->lineno = lineno;
551
            }
552
          else if (strncmp (line, "/** VARY ", 9) == 0)
553
            process_vary (line + 9);
554
          else
555
            {
556
              char *lp;
557
              int i, bit, byte;
558
              int var_start = 1;
559
 
560
              n_opcodes++;
561
              opcodes =
562
                (opcode **) realloc (opcodes, n_opcodes * sizeof (opcode *));
563
              op = (opcode *) malloc (sizeof (opcode));
564
              opcodes[n_opcodes - 1] = op;
565
 
566
              op->nbytes = op->dbytes = 0;
567
              memset (op->id, 0, sizeof (op->id));
568
              memset (op->var_start, 0, sizeof (op->var_start));
569
              for (i = 0; i < MAX_BYTES; i++)
570
                {
571
                  op->b[i].decodable_mask = 0;
572
                  op->b[i].decodable_bits = 0;
573
                }
574
              op->comment = strdup (line);
575
              op->comment[strlen (op->comment) - 1] = 0;
576
              while (op->comment[0] && isspace (op->comment[0]))
577
                op->comment++;
578
              op->lineno = lineno;
579
              op->nlines = 0;
580
              op->lines = 0;
581
              op->last_ind = 0;
582
              op->semantics_label = 0;
583
              op->nvaries = 0;
584
              op->vary = 0;
585
 
586
              i = 0;
587
              for (lp = line + 4; *lp; lp++)
588
                {
589
                  bit = 7 - (i & 7);
590
                  byte = i >> 3;
591
 
592
                  if (strncmp (lp, "*/", 2) == 0)
593
                    break;
594
                  else if ((lp[0] == ' ' && lp[1] == ' ') || (lp[0] == '\t'))
595
                    break;
596
                  else if (*lp == ' ')
597
                    var_start = 1;
598
                  else
599
                    {
600
                      if (*lp == '0' || *lp == '1')
601
                        {
602
                          op->b[byte].decodable_mask |= 1 << bit;
603
                          var_start = 1;
604
                          if (op->dbytes < byte + 1)
605
                            op->dbytes = byte + 1;
606
                        }
607
                      else if (var_start)
608
                        {
609
                          op->var_start[i] = 1;
610
                          var_start = 0;
611
                        }
612
                      if (*lp == '1')
613
                        op->b[byte].decodable_bits |= 1 << bit;
614
 
615
                      op->nbytes = byte + 1;
616
                      op->id[i++] = *lp;
617
                    }
618
                }
619
            }
620
        }
621
      else
622
        {
623
          op->nlines++;
624
          if (op->lines)
625
            op->lines =
626
              (char **) realloc (op->lines, op->nlines * sizeof (char *));
627
          else
628
            op->lines = (char **) malloc (op->nlines * sizeof (char *));
629
          op->lines[op->nlines - 1] = strdup (line);
630
        }
631
    }
632
 
633
  {
634
    int i, j;
635
    for (i = 0; i < n_varies; i++)
636
      {
637
        Vary *v = vary[i];
638
        lprintf (sim_log, "V[%s] %d\n", v->name, v->nlen);
639
        for (j = 0; j < v->n_patterns; j++)
640
          lprintf (sim_log, "  P %02x\n", v->patterns[j]);
641
      }
642
  }
643
 
644
  for (i = n_opcodes - 2; i >= 0; i--)
645
    {
646
      if (opcodes[i]->nlines == 0)
647
        {
648
          opcodes[i]->nlines = opcodes[i + 1]->nlines;
649
          opcodes[i]->lines = opcodes[i + 1]->lines;
650
        }
651
    }
652
 
653
  for (i = 0; i < 256; i++)
654
    indirect[i].type = T_unused;
655
 
656
  qsort (opcodes, n_opcodes, sizeof (opcodes[0]), op_cmp);
657
 
658
  vlist = (VaryRef *) malloc (n_varies * sizeof (VaryRef));
659
 
660
  for (i = 0; i < n_opcodes; i++)
661
    {
662
      int j, b, v;
663
 
664
      for (j = 0; j < opcodes[i]->nbytes; j++)
665
        lprintf (sim_log, "%s ",
666
                 prmb (opcodes[i]->b[j].decodable_mask,
667
                       opcodes[i]->b[j].decodable_bits));
668
      lprintf (sim_log, " %s\n", opcodes[i]->comment);
669
 
670
      for (j = 0; j < opcodes[i]->nbytes; j++)
671
        {
672
          for (b = 0; b < 8; b++)
673
            if (isalpha (opcodes[i]->id[j * 8 + b]))
674
              for (v = 0; v < n_varies; v++)
675
                if (fieldcmp (opcodes[i], j * 8 + b, vary[v]->name))
676
                  {
677
                    int nv = opcodes[i]->nvaries++;
678
                    if (nv)
679
                      opcodes[i]->vary =
680
                        (VaryRef *) realloc (opcodes[i]->vary,
681
                                             (nv + 1) * sizeof (VaryRef));
682
                    else
683
                      opcodes[i]->vary =
684
                        (VaryRef *) malloc ((nv + 1) * sizeof (VaryRef));
685
 
686
                    opcodes[i]->vary[nv].varyno = v;
687
                    opcodes[i]->vary[nv].byte = j;
688
                    opcodes[i]->vary[nv].shift = 8 - b - vary[v]->nlen;
689
                    lprintf (sim_log, "[vary %s shift %d]\n",
690
                             vary[v]->name, opcodes[i]->vary[nv].shift);
691
                  }
692
 
693
        }
694
    }
695
 
696
  for (i = 0; i < n_opcodes; i++)
697
    {
698
      int i2;
699
      int bytes = opcodes[i]->dbytes;
700
 
701
      lprintf (sim_log, "\nmask:");
702
      for (i2 = 0; i2 < opcodes[i]->nbytes; i2++)
703
        lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_mask);
704
      lprintf (sim_log, "%*s%s\n", 13 - 3 * opcodes[i]->nbytes, "",
705
               opcodes[i]->comment);
706
 
707
      lprintf (sim_log, "bits:");
708
      for (i2 = 0; i2 < opcodes[i]->nbytes; i2++)
709
        lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_bits);
710
      lprintf (sim_log, "%*s(%s) %d byte%s\n", 13 - 3 * opcodes[i]->nbytes,
711
               "", opcodes[i]->id, bytes, bytes == 1 ? "" : "s");
712
 
713
      store_opcode_bits (opcodes[i], 0, indirect);
714
    }
715
 
716
  dump_lines (&prefix_text, 0, 0);
717
 
718
  emit_indirect (indirect, 0);
719
 
720
  dump_lines (&suffix_text, 0, 0);
721
 
722
  if (sim_log)
723
    log_indirect (indirect, 0);
724
 
725
  return errors;
726
}

powered by: WebSVN 2.1.0

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