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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [opcodes/] [opc2c.c] - Blame information for rev 18

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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