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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [genmodes.c] - Blame information for rev 328

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

Line No. Rev Author Line
1 280 jeremybenn
/* Generate the machine mode enumeration and associated tables.
2
   Copyright (C) 2003, 2004, 2005, 2006, 2007
3
   Free Software Foundation, Inc.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
#include "bconfig.h"
22
#include "system.h"
23
#include "errors.h"
24
#include "hashtab.h"
25
 
26
/* enum mode_class is normally defined by machmode.h but we can't
27
   include that header here.  */
28
#include "mode-classes.def"
29
 
30
#define DEF_MODE_CLASS(M) M
31
enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
32
#undef DEF_MODE_CLASS
33
 
34
/* Text names of mode classes, for output.  */
35
#define DEF_MODE_CLASS(M) #M
36
static const char *const mode_class_names[MAX_MODE_CLASS] =
37
{
38
  MODE_CLASSES
39
};
40
#undef DEF_MODE_CLASS
41
#undef MODE_CLASSES
42
 
43
#ifdef EXTRA_MODES_FILE
44
# define HAVE_EXTRA_MODES 1
45
#else
46
# define HAVE_EXTRA_MODES 0
47
# define EXTRA_MODES_FILE ""
48
#endif
49
 
50
/* Data structure for building up what we know about a mode.
51
   They're clustered by mode class.  */
52
struct mode_data
53
{
54
  struct mode_data *next;       /* next this class - arbitrary order */
55
 
56
  const char *name;             /* printable mode name -- SI, not SImode */
57
  enum mode_class cl;           /* this mode class */
58
  unsigned int precision;       /* size in bits, equiv to TYPE_PRECISION */
59
  unsigned int bytesize;        /* storage size in addressable units */
60
  unsigned int ncomponents;     /* number of subunits */
61
  unsigned int alignment;       /* mode alignment */
62
  const char *format;           /* floating point format - float modes only */
63
 
64
  struct mode_data *component;  /* mode of components */
65
  struct mode_data *wider;      /* next wider mode */
66
  struct mode_data *wider_2x;   /* 2x wider mode */
67
 
68
  struct mode_data *contained;  /* Pointer to list of modes that have
69
                                   this mode as a component.  */
70
  struct mode_data *next_cont;  /* Next mode in that list.  */
71
 
72
  const char *file;             /* file and line of definition, */
73
  unsigned int line;            /* for error reporting */
74
  unsigned int counter;         /* Rank ordering of modes */
75
  unsigned int ibit;            /* the number of integral bits */
76
  unsigned int fbit;            /* the number of fractional bits */
77
};
78
 
79
static struct mode_data *modes[MAX_MODE_CLASS];
80
static unsigned int n_modes[MAX_MODE_CLASS];
81
static struct mode_data *void_mode;
82
 
83
static const struct mode_data blank_mode = {
84
  0, "<unknown>", MAX_MODE_CLASS,
85
  -1U, -1U, -1U, -1U,
86
  0, 0, 0, 0, 0, 0,
87
  "<unknown>", 0, 0, 0, 0
88
};
89
 
90
static htab_t modes_by_name;
91
 
92
/* Data structure for recording target-specified runtime adjustments
93
   to a particular mode.  We support varying the byte size, the
94
   alignment, and the floating point format.  */
95
struct mode_adjust
96
{
97
  struct mode_adjust *next;
98
  struct mode_data *mode;
99
  const char *adjustment;
100
 
101
  const char *file;
102
  unsigned int line;
103
};
104
 
105
static struct mode_adjust *adj_bytesize;
106
static struct mode_adjust *adj_alignment;
107
static struct mode_adjust *adj_format;
108
static struct mode_adjust *adj_ibit;
109
static struct mode_adjust *adj_fbit;
110
 
111
/* Mode class operations.  */
112
static enum mode_class
113
complex_class (enum mode_class c)
114
{
115
  switch (c)
116
    {
117
    case MODE_INT: return MODE_COMPLEX_INT;
118
    case MODE_FLOAT: return MODE_COMPLEX_FLOAT;
119
    default:
120
      error ("no complex class for class %s", mode_class_names[c]);
121
      return MODE_RANDOM;
122
    }
123
}
124
 
125
static enum mode_class
126
vector_class (enum mode_class cl)
127
{
128
  switch (cl)
129
    {
130
    case MODE_INT: return MODE_VECTOR_INT;
131
    case MODE_FLOAT: return MODE_VECTOR_FLOAT;
132
    case MODE_FRACT: return MODE_VECTOR_FRACT;
133
    case MODE_UFRACT: return MODE_VECTOR_UFRACT;
134
    case MODE_ACCUM: return MODE_VECTOR_ACCUM;
135
    case MODE_UACCUM: return MODE_VECTOR_UACCUM;
136
    default:
137
      error ("no vector class for class %s", mode_class_names[cl]);
138
      return MODE_RANDOM;
139
    }
140
}
141
 
142
/* Utility routines.  */
143
static inline struct mode_data *
144
find_mode (const char *name)
145
{
146
  struct mode_data key;
147
 
148
  key.name = name;
149
  return (struct mode_data *) htab_find (modes_by_name, &key);
150
}
151
 
152
static struct mode_data *
153
new_mode (enum mode_class cl, const char *name,
154
          const char *file, unsigned int line)
155
{
156
  struct mode_data *m;
157
  static unsigned int count = 0;
158
 
159
  m = find_mode (name);
160
  if (m)
161
    {
162
      error ("%s:%d: duplicate definition of mode \"%s\"",
163
             trim_filename (file), line, name);
164
      error ("%s:%d: previous definition here", m->file, m->line);
165
      return m;
166
    }
167
 
168
  m = XNEW (struct mode_data);
169
  memcpy (m, &blank_mode, sizeof (struct mode_data));
170
  m->cl = cl;
171
  m->name = name;
172
  if (file)
173
    m->file = trim_filename (file);
174
  m->line = line;
175
  m->counter = count++;
176
 
177
  m->next = modes[cl];
178
  modes[cl] = m;
179
  n_modes[cl]++;
180
 
181
  *htab_find_slot (modes_by_name, m, INSERT) = m;
182
 
183
  return m;
184
}
185
 
186
static hashval_t
187
hash_mode (const void *p)
188
{
189
  const struct mode_data *m = (const struct mode_data *)p;
190
  return htab_hash_string (m->name);
191
}
192
 
193
static int
194
eq_mode (const void *p, const void *q)
195
{
196
  const struct mode_data *a = (const struct mode_data *)p;
197
  const struct mode_data *b = (const struct mode_data *)q;
198
 
199
  return !strcmp (a->name, b->name);
200
}
201
 
202
#define for_all_modes(C, M)                     \
203
  for (C = 0; C < MAX_MODE_CLASS; C++)           \
204
    for (M = modes[C]; M; M = M->next)
205
 
206
static void ATTRIBUTE_UNUSED
207
new_adjust (const char *name,
208
            struct mode_adjust **category, const char *catname,
209
            const char *adjustment,
210
            enum mode_class required_class_from,
211
            enum mode_class required_class_to,
212
            const char *file, unsigned int line)
213
{
214
  struct mode_data *mode = find_mode (name);
215
  struct mode_adjust *a;
216
 
217
  file = trim_filename (file);
218
 
219
  if (!mode)
220
    {
221
      error ("%s:%d: no mode \"%s\"", file, line, name);
222
      return;
223
    }
224
 
225
  if (required_class_from != MODE_RANDOM
226
      && (mode->cl < required_class_from || mode->cl > required_class_to))
227
    {
228
      error ("%s:%d: mode \"%s\" is not among class {%s, %s}",
229
             file, line, name, mode_class_names[required_class_from] + 5,
230
             mode_class_names[required_class_to] + 5);
231
      return;
232
    }
233
 
234
  for (a = *category; a; a = a->next)
235
    if (a->mode == mode)
236
      {
237
        error ("%s:%d: mode \"%s\" already has a %s adjustment",
238
               file, line, name, catname);
239
        error ("%s:%d: previous adjustment here", a->file, a->line);
240
        return;
241
      }
242
 
243
  a = XNEW (struct mode_adjust);
244
  a->mode = mode;
245
  a->adjustment = adjustment;
246
  a->file = file;
247
  a->line = line;
248
 
249
  a->next = *category;
250
  *category = a;
251
}
252
 
253
/* Diagnose failure to meet expectations in a partially filled out
254
   mode structure.  */
255
enum requirement { SET, UNSET, OPTIONAL };
256
 
257
#define validate_field_(mname, fname, req, val, unset, file, line) do { \
258
  switch (req)                                                          \
259
    {                                                                   \
260
    case SET:                                                           \
261
      if (val == unset)                                                 \
262
        error ("%s:%d: (%s) field %s must be set",                      \
263
               file, line, mname, fname);                               \
264
      break;                                                            \
265
    case UNSET:                                                         \
266
      if (val != unset)                                                 \
267
        error ("%s:%d: (%s) field %s must not be set",                  \
268
               file, line, mname, fname);                               \
269
    case OPTIONAL:                                                      \
270
      break;                                                            \
271
    }                                                                   \
272
} while (0)
273
 
274
#define validate_field(M, F) \
275
  validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
276
 
277
static void
278
validate_mode (struct mode_data *m,
279
               enum requirement r_precision,
280
               enum requirement r_bytesize,
281
               enum requirement r_component,
282
               enum requirement r_ncomponents,
283
               enum requirement r_format)
284
{
285
  validate_field (m, precision);
286
  validate_field (m, bytesize);
287
  validate_field (m, component);
288
  validate_field (m, ncomponents);
289
  validate_field (m, format);
290
}
291
#undef validate_field
292
#undef validate_field_
293
 
294
/* Given a partially-filled-out mode structure, figure out what we can
295
   and fill the rest of it in; die if it isn't enough.  */
296
static void
297
complete_mode (struct mode_data *m)
298
{
299
  unsigned int alignment;
300
 
301
  if (!m->name)
302
    {
303
      error ("%s:%d: mode with no name", m->file, m->line);
304
      return;
305
    }
306
  if (m->cl == MAX_MODE_CLASS)
307
    {
308
      error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
309
      return;
310
    }
311
 
312
  switch (m->cl)
313
    {
314
    case MODE_RANDOM:
315
      /* Nothing more need be said.  */
316
      if (!strcmp (m->name, "VOID"))
317
        void_mode = m;
318
 
319
      validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
320
 
321
      m->precision = 0;
322
      m->bytesize = 0;
323
      m->ncomponents = 0;
324
      m->component = 0;
325
      break;
326
 
327
    case MODE_CC:
328
      /* Again, nothing more need be said.  For historical reasons,
329
         the size of a CC mode is four units.  */
330
      validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
331
 
332
      m->bytesize = 4;
333
      m->ncomponents = 1;
334
      m->component = 0;
335
      break;
336
 
337
    case MODE_INT:
338
    case MODE_FLOAT:
339
    case MODE_DECIMAL_FLOAT:
340
    case MODE_FRACT:
341
    case MODE_UFRACT:
342
    case MODE_ACCUM:
343
    case MODE_UACCUM:
344
      /* A scalar mode must have a byte size, may have a bit size,
345
         and must not have components.   A float mode must have a
346
         format.  */
347
      validate_mode (m, OPTIONAL, SET, UNSET, UNSET,
348
                     (m->cl == MODE_FLOAT || m->cl == MODE_DECIMAL_FLOAT)
349
                     ? SET : UNSET);
350
 
351
      m->ncomponents = 1;
352
      m->component = 0;
353
      break;
354
 
355
    case MODE_PARTIAL_INT:
356
      /* A partial integer mode uses ->component to say what the
357
         corresponding full-size integer mode is, and may also
358
         specify a bit size.  */
359
      validate_mode (m, OPTIONAL, UNSET, SET, UNSET, UNSET);
360
 
361
      m->bytesize = m->component->bytesize;
362
 
363
      m->ncomponents = 1;
364
      m->component = 0;  /* ??? preserve this */
365
      break;
366
 
367
    case MODE_COMPLEX_INT:
368
    case MODE_COMPLEX_FLOAT:
369
      /* Complex modes should have a component indicated, but no more.  */
370
      validate_mode (m, UNSET, UNSET, SET, UNSET, UNSET);
371
      m->ncomponents = 2;
372
      if (m->component->precision != (unsigned int)-1)
373
        m->precision = 2 * m->component->precision;
374
      m->bytesize = 2 * m->component->bytesize;
375
      break;
376
 
377
    case MODE_VECTOR_INT:
378
    case MODE_VECTOR_FLOAT:
379
    case MODE_VECTOR_FRACT:
380
    case MODE_VECTOR_UFRACT:
381
    case MODE_VECTOR_ACCUM:
382
    case MODE_VECTOR_UACCUM:
383
      /* Vector modes should have a component and a number of components.  */
384
      validate_mode (m, UNSET, UNSET, SET, SET, UNSET);
385
      if (m->component->precision != (unsigned int)-1)
386
        m->precision = m->ncomponents * m->component->precision;
387
      m->bytesize = m->ncomponents * m->component->bytesize;
388
      break;
389
 
390
    default:
391
      gcc_unreachable ();
392
    }
393
 
394
  /* If not already specified, the mode alignment defaults to the largest
395
     power of two that divides the size of the object.  Complex types are
396
     not more aligned than their contents.  */
397
  if (m->cl == MODE_COMPLEX_INT || m->cl == MODE_COMPLEX_FLOAT)
398
    alignment = m->component->bytesize;
399
  else
400
    alignment = m->bytesize;
401
 
402
  m->alignment = alignment & (~alignment + 1);
403
 
404
  /* If this mode has components, make the component mode point back
405
     to this mode, for the sake of adjustments.  */
406
  if (m->component)
407
    {
408
      m->next_cont = m->component->contained;
409
      m->component->contained = m;
410
    }
411
}
412
 
413
static void
414
complete_all_modes (void)
415
{
416
  struct mode_data *m;
417
  int cl;
418
 
419
  for_all_modes (cl, m)
420
    complete_mode (m);
421
}
422
 
423
/* For each mode in class CLASS, construct a corresponding complex mode.  */
424
#define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
425
static void
426
make_complex_modes (enum mode_class cl,
427
                    const char *file, unsigned int line)
428
{
429
  struct mode_data *m;
430
  struct mode_data *c;
431
  char buf[8];
432
  enum mode_class cclass = complex_class (cl);
433
 
434
  if (cclass == MODE_RANDOM)
435
    return;
436
 
437
  for (m = modes[cl]; m; m = m->next)
438
    {
439
      /* Skip BImode.  FIXME: BImode probably shouldn't be MODE_INT.  */
440
      if (m->precision == 1)
441
        continue;
442
 
443
      if (strlen (m->name) >= sizeof buf)
444
        {
445
          error ("%s:%d:mode name \"%s\" is too long",
446
                 m->file, m->line, m->name);
447
          continue;
448
        }
449
 
450
      /* Float complex modes are named SCmode, etc.
451
         Int complex modes are named CSImode, etc.
452
         This inconsistency should be eliminated.  */
453
      if (cl == MODE_FLOAT)
454
        {
455
          char *p, *q = 0;
456
          strncpy (buf, m->name, sizeof buf);
457
          p = strchr (buf, 'F');
458
          if (p == 0)
459
            q = strchr (buf, 'D');
460
          if (p == 0 && q == 0)
461
            {
462
              error ("%s:%d: float mode \"%s\" has no 'F' or 'D'",
463
                     m->file, m->line, m->name);
464
              continue;
465
            }
466
 
467
          if (p != 0)
468
            *p = 'C';
469
          else
470
            snprintf (buf, sizeof buf, "C%s", m->name);
471
        }
472
      else
473
        snprintf (buf, sizeof buf, "C%s", m->name);
474
 
475
      c = new_mode (cclass, xstrdup (buf), file, line);
476
      c->component = m;
477
    }
478
}
479
 
480
/* For all modes in class CL, construct vector modes of width
481
   WIDTH, having as many components as necessary.  */
482
#define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
483
static void ATTRIBUTE_UNUSED
484
make_vector_modes (enum mode_class cl, unsigned int width,
485
                   const char *file, unsigned int line)
486
{
487
  struct mode_data *m;
488
  struct mode_data *v;
489
  char buf[8];
490
  unsigned int ncomponents;
491
  enum mode_class vclass = vector_class (cl);
492
 
493
  if (vclass == MODE_RANDOM)
494
    return;
495
 
496
  for (m = modes[cl]; m; m = m->next)
497
    {
498
      /* Do not construct vector modes with only one element, or
499
         vector modes where the element size doesn't divide the full
500
         size evenly.  */
501
      ncomponents = width / m->bytesize;
502
      if (ncomponents < 2)
503
        continue;
504
      if (width % m->bytesize)
505
        continue;
506
 
507
      /* Skip QFmode and BImode.  FIXME: this special case should
508
         not be necessary.  */
509
      if (cl == MODE_FLOAT && m->bytesize == 1)
510
        continue;
511
      if (cl == MODE_INT && m->precision == 1)
512
        continue;
513
 
514
      if ((size_t)snprintf (buf, sizeof buf, "V%u%s", ncomponents, m->name)
515
          >= sizeof buf)
516
        {
517
          error ("%s:%d: mode name \"%s\" is too long",
518
                 m->file, m->line, m->name);
519
          continue;
520
        }
521
 
522
      v = new_mode (vclass, xstrdup (buf), file, line);
523
      v->component = m;
524
      v->ncomponents = ncomponents;
525
    }
526
}
527
 
528
/* Input.  */
529
 
530
#define _SPECIAL_MODE(C, N) make_special_mode(MODE_##C, #N, __FILE__, __LINE__)
531
#define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
532
#define CC_MODE(N) _SPECIAL_MODE (CC, N)
533
 
534
static void
535
make_special_mode (enum mode_class cl, const char *name,
536
                   const char *file, unsigned int line)
537
{
538
  new_mode (cl, name, file, line);
539
}
540
 
541
#define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
542
#define FRACTIONAL_INT_MODE(N, B, Y) \
543
  make_int_mode (#N, B, Y, __FILE__, __LINE__)
544
 
545
static void
546
make_int_mode (const char *name,
547
               unsigned int precision, unsigned int bytesize,
548
               const char *file, unsigned int line)
549
{
550
  struct mode_data *m = new_mode (MODE_INT, name, file, line);
551
  m->bytesize = bytesize;
552
  m->precision = precision;
553
}
554
 
555
#define FRACT_MODE(N, Y, F) \
556
        make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
557
 
558
#define UFRACT_MODE(N, Y, F) \
559
        make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
560
 
561
#define ACCUM_MODE(N, Y, I, F) \
562
        make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
563
 
564
#define UACCUM_MODE(N, Y, I, F) \
565
        make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
566
 
567
/* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
568
   FILE, and LINE.  */
569
 
570
static void
571
make_fixed_point_mode (enum mode_class cl,
572
                       const char *name,
573
                       unsigned int bytesize,
574
                       unsigned int ibit,
575
                       unsigned int fbit,
576
                       const char *file, unsigned int line)
577
{
578
  struct mode_data *m = new_mode (cl, name, file, line);
579
  m->bytesize = bytesize;
580
  m->ibit = ibit;
581
  m->fbit = fbit;
582
}
583
 
584
#define FLOAT_MODE(N, Y, F)             FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
585
#define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
586
  make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
587
 
588
static void
589
make_float_mode (const char *name,
590
                 unsigned int precision, unsigned int bytesize,
591
                 const char *format,
592
                 const char *file, unsigned int line)
593
{
594
  struct mode_data *m = new_mode (MODE_FLOAT, name, file, line);
595
  m->bytesize = bytesize;
596
  m->precision = precision;
597
  m->format = format;
598
}
599
 
600
#define DECIMAL_FLOAT_MODE(N, Y, F)     \
601
        FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
602
#define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F)       \
603
  make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
604
 
605
static void
606
make_decimal_float_mode (const char *name,
607
                         unsigned int precision, unsigned int bytesize,
608
                         const char *format,
609
                         const char *file, unsigned int line)
610
{
611
  struct mode_data *m = new_mode (MODE_DECIMAL_FLOAT, name, file, line);
612
  m->bytesize = bytesize;
613
  m->precision = precision;
614
  m->format = format;
615
}
616
 
617
#define RESET_FLOAT_FORMAT(N, F) \
618
  reset_float_format (#N, #F, __FILE__, __LINE__)
619
static void ATTRIBUTE_UNUSED
620
reset_float_format (const char *name, const char *format,
621
                    const char *file, unsigned int line)
622
{
623
  struct mode_data *m = find_mode (name);
624
  if (!m)
625
    {
626
      error ("%s:%d: no mode \"%s\"", file, line, name);
627
      return;
628
    }
629
  if (m->cl != MODE_FLOAT && m->cl != MODE_DECIMAL_FLOAT)
630
    {
631
      error ("%s:%d: mode \"%s\" is not a FLOAT class", file, line, name);
632
      return;
633
    }
634
  m->format = format;
635
}
636
 
637
/* Partial integer modes are specified by relation to a full integer mode.
638
   For now, we do not attempt to narrow down their bit sizes.  */
639
#define PARTIAL_INT_MODE(M) \
640
  make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__)
641
static void ATTRIBUTE_UNUSED
642
make_partial_integer_mode (const char *base, const char *name,
643
                           unsigned int precision,
644
                           const char *file, unsigned int line)
645
{
646
  struct mode_data *m;
647
  struct mode_data *component = find_mode (base);
648
  if (!component)
649
    {
650
      error ("%s:%d: no mode \"%s\"", file, line, name);
651
      return;
652
    }
653
  if (component->cl != MODE_INT)
654
    {
655
      error ("%s:%d: mode \"%s\" is not class INT", file, line, name);
656
      return;
657
    }
658
 
659
  m = new_mode (MODE_PARTIAL_INT, name, file, line);
660
  m->precision = precision;
661
  m->component = component;
662
}
663
 
664
/* A single vector mode can be specified by naming its component
665
   mode and the number of components.  */
666
#define VECTOR_MODE(C, M, N) \
667
  make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
668
static void ATTRIBUTE_UNUSED
669
make_vector_mode (enum mode_class bclass,
670
                  const char *base,
671
                  unsigned int ncomponents,
672
                  const char *file, unsigned int line)
673
{
674
  struct mode_data *v;
675
  enum mode_class vclass = vector_class (bclass);
676
  struct mode_data *component = find_mode (base);
677
  char namebuf[8];
678
 
679
  if (vclass == MODE_RANDOM)
680
    return;
681
  if (component == 0)
682
    {
683
      error ("%s:%d: no mode \"%s\"", file, line, base);
684
      return;
685
    }
686
  if (component->cl != bclass
687
      && (component->cl != MODE_PARTIAL_INT
688
          || bclass != MODE_INT))
689
    {
690
      error ("%s:%d: mode \"%s\" is not class %s",
691
             file, line, base, mode_class_names[bclass] + 5);
692
      return;
693
    }
694
 
695
  if ((size_t)snprintf (namebuf, sizeof namebuf, "V%u%s",
696
                        ncomponents, base) >= sizeof namebuf)
697
    {
698
      error ("%s:%d: mode name \"%s\" is too long",
699
             file, line, base);
700
      return;
701
    }
702
 
703
  v = new_mode (vclass, xstrdup (namebuf), file, line);
704
  v->ncomponents = ncomponents;
705
  v->component = component;
706
}
707
 
708
/* Adjustability.  */
709
#define _ADD_ADJUST(A, M, X, C1, C2) \
710
  new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
711
 
712
#define ADJUST_BYTESIZE(M, X)  _ADD_ADJUST(bytesize, M, X, RANDOM, RANDOM)
713
#define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST(alignment, M, X, RANDOM, RANDOM)
714
#define ADJUST_FLOAT_FORMAT(M, X)    _ADD_ADJUST(format, M, X, FLOAT, FLOAT)
715
#define ADJUST_IBIT(M, X)  _ADD_ADJUST(ibit, M, X, ACCUM, UACCUM)
716
#define ADJUST_FBIT(M, X)  _ADD_ADJUST(fbit, M, X, FRACT, UACCUM)
717
 
718
static void
719
create_modes (void)
720
{
721
#include "machmode.def"
722
}
723
 
724
/* Processing.  */
725
 
726
/* Sort a list of modes into the order needed for the WIDER field:
727
   major sort by precision, minor sort by component precision.
728
 
729
   For instance:
730
     QI < HI < SI < DI < TI
731
     V4QI < V2HI < V8QI < V4HI < V2SI.
732
 
733
   If the precision is not set, sort by the bytesize.  A mode with
734
   precision set gets sorted before a mode without precision set, if
735
   they have the same bytesize; this is the right thing because
736
   the precision must always be smaller than the bytesize * BITS_PER_UNIT.
737
   We don't have to do anything special to get this done -- an unset
738
   precision shows up as (unsigned int)-1, i.e. UINT_MAX.  */
739
static int
740
cmp_modes (const void *a, const void *b)
741
{
742
  const struct mode_data *const m = *(const struct mode_data *const*)a;
743
  const struct mode_data *const n = *(const struct mode_data *const*)b;
744
 
745
  if (m->bytesize > n->bytesize)
746
    return 1;
747
  else if (m->bytesize < n->bytesize)
748
    return -1;
749
 
750
  if (m->precision > n->precision)
751
    return 1;
752
  else if (m->precision < n->precision)
753
    return -1;
754
 
755
  if (!m->component && !n->component)
756
    {
757
      if (m->counter < n->counter)
758
        return -1;
759
      else
760
        return 1;
761
    }
762
 
763
  if (m->component->bytesize > n->component->bytesize)
764
    return 1;
765
  else if (m->component->bytesize < n->component->bytesize)
766
    return -1;
767
 
768
  if (m->component->precision > n->component->precision)
769
    return 1;
770
  else if (m->component->precision < n->component->precision)
771
    return -1;
772
 
773
  if (m->counter < n->counter)
774
    return -1;
775
  else
776
    return 1;
777
}
778
 
779
static void
780
calc_wider_mode (void)
781
{
782
  int c;
783
  struct mode_data *m;
784
  struct mode_data **sortbuf;
785
  unsigned int max_n_modes = 0;
786
  unsigned int i, j;
787
 
788
  for (c = 0; c < MAX_MODE_CLASS; c++)
789
    max_n_modes = MAX (max_n_modes, n_modes[c]);
790
 
791
  /* Allocate max_n_modes + 1 entries to leave room for the extra null
792
     pointer assigned after the qsort call below.  */
793
  sortbuf = (struct mode_data **) alloca ((max_n_modes + 1) * sizeof (struct mode_data *));
794
 
795
  for (c = 0; c < MAX_MODE_CLASS; c++)
796
    {
797
      /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
798
         However, we want these in textual order, and we have
799
         precisely the reverse.  */
800
      if (c == MODE_RANDOM || c == MODE_CC)
801
        {
802
          struct mode_data *prev, *next;
803
 
804
          for (prev = 0, m = modes[c]; m; m = next)
805
            {
806
              m->wider = void_mode;
807
              m->wider_2x = void_mode;
808
 
809
              /* this is nreverse */
810
              next = m->next;
811
              m->next = prev;
812
              prev = m;
813
            }
814
          modes[c] = prev;
815
        }
816
      else
817
        {
818
          if (!modes[c])
819
            continue;
820
 
821
          for (i = 0, m = modes[c]; m; i++, m = m->next)
822
            sortbuf[i] = m;
823
 
824
          qsort (sortbuf, i, sizeof (struct mode_data *), cmp_modes);
825
 
826
          sortbuf[i] = 0;
827
          for (j = 0; j < i; j++)
828
            sortbuf[j]->next = sortbuf[j]->wider = sortbuf[j + 1];
829
 
830
 
831
          modes[c] = sortbuf[0];
832
        }
833
    }
834
}
835
 
836
/* Output routines.  */
837
 
838
#define tagged_printf(FMT, ARG, TAG) do {               \
839
  int count_ = printf ("  " FMT ",", ARG);              \
840
  printf ("%*s/* %s */\n", 27 - count_, "", TAG);       \
841
} while (0)
842
 
843
#define print_decl(TYPE, NAME, ASIZE) \
844
  puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
845
 
846
#define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY)     \
847
  printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n",             \
848
          adj_##CATEGORY ? "" : "const ")
849
 
850
#define print_closer() puts ("};")
851
 
852
static void
853
emit_insn_modes_h (void)
854
{
855
  int c;
856
  struct mode_data *m, *first, *last;
857
 
858
  printf ("/* Generated automatically from machmode.def%s%s\n",
859
           HAVE_EXTRA_MODES ? " and " : "",
860
           EXTRA_MODES_FILE);
861
 
862
  puts ("\
863
   by genmodes.  */\n\
864
\n\
865
#ifndef GCC_INSN_MODES_H\n\
866
#define GCC_INSN_MODES_H\n\
867
\n\
868
enum machine_mode\n{");
869
 
870
  for (c = 0; c < MAX_MODE_CLASS; c++)
871
    for (m = modes[c]; m; m = m->next)
872
      {
873
        int count_ = printf ("  %smode,", m->name);
874
        printf ("%*s/* %s:%d */\n", 27 - count_, "",
875
                 trim_filename (m->file), m->line);
876
      }
877
 
878
  puts ("  MAX_MACHINE_MODE,\n");
879
 
880
  for (c = 0; c < MAX_MODE_CLASS; c++)
881
    {
882
      first = modes[c];
883
      last = 0;
884
      for (m = first; m; last = m, m = m->next)
885
        ;
886
 
887
      /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
888
         end will try to use it for bitfields in structures and the
889
         like, which we do not want.  Only the target md file should
890
         generate BImode widgets.  */
891
      if (first && first->precision == 1)
892
        first = first->next;
893
 
894
      if (first && last)
895
        printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
896
                 mode_class_names[c], first->name,
897
                 mode_class_names[c], last->name);
898
      else
899
        printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
900
                 mode_class_names[c], void_mode->name,
901
                 mode_class_names[c], void_mode->name);
902
    }
903
 
904
  puts ("\
905
  NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
906
};\n");
907
 
908
  /* I can't think of a better idea, can you?  */
909
  printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize ? "" : " const");
910
  printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment ? "" : " const");
911
#if 0 /* disabled for backward compatibility, temporary */
912
  printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format ? "" :" const");
913
#endif
914
  printf ("#define CONST_MODE_IBIT%s\n", adj_ibit ? "" : " const");
915
  printf ("#define CONST_MODE_FBIT%s\n", adj_fbit ? "" : " const");
916
  puts ("\
917
\n\
918
#endif /* insn-modes.h */");
919
}
920
 
921
static void
922
emit_insn_modes_c_header (void)
923
{
924
  printf ("/* Generated automatically from machmode.def%s%s\n",
925
           HAVE_EXTRA_MODES ? " and " : "",
926
           EXTRA_MODES_FILE);
927
 
928
  puts ("\
929
   by genmodes.  */\n\
930
\n\
931
#include \"config.h\"\n\
932
#include \"system.h\"\n\
933
#include \"coretypes.h\"\n\
934
#include \"tm.h\"\n\
935
#include \"machmode.h\"\n\
936
#include \"real.h\"");
937
}
938
 
939
static void
940
emit_min_insn_modes_c_header (void)
941
{
942
  printf ("/* Generated automatically from machmode.def%s%s\n",
943
           HAVE_EXTRA_MODES ? " and " : "",
944
           EXTRA_MODES_FILE);
945
 
946
  puts ("\
947
   by genmodes.  */\n\
948
\n\
949
#include \"bconfig.h\"\n\
950
#include \"system.h\"\n\
951
#include \"machmode.h\"");
952
}
953
 
954
static void
955
emit_mode_name (void)
956
{
957
  int c;
958
  struct mode_data *m;
959
 
960
  print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
961
 
962
  for_all_modes (c, m)
963
    printf ("  \"%s\",\n", m->name);
964
 
965
  print_closer ();
966
}
967
 
968
static void
969
emit_mode_class (void)
970
{
971
  int c;
972
  struct mode_data *m;
973
 
974
  print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
975
 
976
  for_all_modes (c, m)
977
    tagged_printf ("%s", mode_class_names[m->cl], m->name);
978
 
979
  print_closer ();
980
}
981
 
982
static void
983
emit_mode_precision (void)
984
{
985
  int c;
986
  struct mode_data *m;
987
 
988
  print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
989
 
990
  for_all_modes (c, m)
991
    if (m->precision != (unsigned int)-1)
992
      tagged_printf ("%u", m->precision, m->name);
993
    else
994
      tagged_printf ("%u*BITS_PER_UNIT", m->bytesize, m->name);
995
 
996
  print_closer ();
997
}
998
 
999
static void
1000
emit_mode_size (void)
1001
{
1002
  int c;
1003
  struct mode_data *m;
1004
 
1005
  print_maybe_const_decl ("%sunsigned char", "mode_size",
1006
                          "NUM_MACHINE_MODES", bytesize);
1007
 
1008
  for_all_modes (c, m)
1009
    tagged_printf ("%u", m->bytesize, m->name);
1010
 
1011
  print_closer ();
1012
}
1013
 
1014
static void
1015
emit_mode_nunits (void)
1016
{
1017
  int c;
1018
  struct mode_data *m;
1019
 
1020
  print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1021
 
1022
  for_all_modes (c, m)
1023
    tagged_printf ("%u", m->ncomponents, m->name);
1024
 
1025
  print_closer ();
1026
}
1027
 
1028
static void
1029
emit_mode_wider (void)
1030
{
1031
  int c;
1032
  struct mode_data *m;
1033
 
1034
  print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1035
 
1036
  for_all_modes (c, m)
1037
    tagged_printf ("%smode",
1038
                   m->wider ? m->wider->name : void_mode->name,
1039
                   m->name);
1040
 
1041
  print_closer ();
1042
  print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1043
 
1044
  for_all_modes (c, m)
1045
    {
1046
      struct mode_data * m2;
1047
 
1048
      for (m2 = m;
1049
           m2 && m2 != void_mode;
1050
           m2 = m2->wider)
1051
        {
1052
          if (m2->bytesize < 2 * m->bytesize)
1053
            continue;
1054
          if (m->precision != (unsigned int) -1)
1055
            {
1056
              if (m2->precision != 2 * m->precision)
1057
                continue;
1058
            }
1059
          else
1060
            {
1061
              if (m2->precision != (unsigned int) -1)
1062
                continue;
1063
            }
1064
 
1065
          break;
1066
        }
1067
      if (m2 == void_mode)
1068
        m2 = 0;
1069
      tagged_printf ("%smode",
1070
                     m2 ? m2->name : void_mode->name,
1071
                     m->name);
1072
    }
1073
 
1074
  print_closer ();
1075
}
1076
 
1077
static void
1078
emit_mode_mask (void)
1079
{
1080
  int c;
1081
  struct mode_data *m;
1082
 
1083
  print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1084
              "NUM_MACHINE_MODES");
1085
  puts ("\
1086
#define MODE_MASK(m)                          \\\n\
1087
  ((m) >= HOST_BITS_PER_WIDE_INT)             \\\n\
1088
   ? ~(unsigned HOST_WIDE_INT) 0              \\\n\
1089
   : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
1090
 
1091
  for_all_modes (c, m)
1092
    if (m->precision != (unsigned int)-1)
1093
      tagged_printf ("MODE_MASK (%u)", m->precision, m->name);
1094
    else
1095
      tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m->bytesize, m->name);
1096
 
1097
  puts ("#undef MODE_MASK");
1098
  print_closer ();
1099
}
1100
 
1101
static void
1102
emit_mode_inner (void)
1103
{
1104
  int c;
1105
  struct mode_data *m;
1106
 
1107
  print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1108
 
1109
  for_all_modes (c, m)
1110
    tagged_printf ("%smode",
1111
                   m->component ? m->component->name : void_mode->name,
1112
                   m->name);
1113
 
1114
  print_closer ();
1115
}
1116
 
1117
static void
1118
emit_mode_base_align (void)
1119
{
1120
  int c;
1121
  struct mode_data *m;
1122
 
1123
  print_maybe_const_decl ("%sunsigned char",
1124
                          "mode_base_align", "NUM_MACHINE_MODES",
1125
                          alignment);
1126
 
1127
  for_all_modes (c, m)
1128
    tagged_printf ("%u", m->alignment, m->name);
1129
 
1130
  print_closer ();
1131
}
1132
 
1133
static void
1134
emit_class_narrowest_mode (void)
1135
{
1136
  int c;
1137
 
1138
  print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1139
 
1140
  for (c = 0; c < MAX_MODE_CLASS; c++)
1141
    /* Bleah, all this to get the comment right for MIN_MODE_INT.  */
1142
    tagged_printf ("MIN_%s", mode_class_names[c],
1143
                   modes[c]
1144
                   ? (modes[c]->precision != 1
1145
                      ? modes[c]->name
1146
                      : (modes[c]->next
1147
                         ? modes[c]->next->name
1148
                         : void_mode->name))
1149
                   : void_mode->name);
1150
 
1151
  print_closer ();
1152
}
1153
 
1154
static void
1155
emit_real_format_for_mode (void)
1156
{
1157
  struct mode_data *m;
1158
 
1159
  /* The entities pointed to by this table are constant, whether
1160
     or not the table itself is constant.
1161
 
1162
     For backward compatibility this table is always writable
1163
     (several targets modify it in OVERRIDE_OPTIONS).   FIXME:
1164
     convert all said targets to use ADJUST_FORMAT instead.  */
1165
#if 0
1166
  print_maybe_const_decl ("const struct real_format *%s",
1167
                          "real_format_for_mode",
1168
                          "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1169
                          format);
1170
#else
1171
  print_decl ("struct real_format *\n", "real_format_for_mode",
1172
              "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1173
              "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1174
#endif
1175
 
1176
  /* The beginning of the table is entries for float modes.  */
1177
  for (m = modes[MODE_FLOAT]; m; m = m->next)
1178
    if (!strcmp (m->format, "0"))
1179
      tagged_printf ("%s", m->format, m->name);
1180
    else
1181
      tagged_printf ("&%s", m->format, m->name);
1182
 
1183
  /* The end of the table is entries for decimal float modes.  */
1184
  for (m = modes[MODE_DECIMAL_FLOAT]; m; m = m->next)
1185
    if (!strcmp (m->format, "0"))
1186
      tagged_printf ("%s", m->format, m->name);
1187
    else
1188
      tagged_printf ("&%s", m->format, m->name);
1189
 
1190
  print_closer ();
1191
}
1192
 
1193
static void
1194
emit_mode_adjustments (void)
1195
{
1196
  struct mode_adjust *a;
1197
  struct mode_data *m;
1198
 
1199
  puts ("\
1200
\nvoid\
1201
\ninit_adjust_machine_modes (void)\
1202
\n{\
1203
\n  size_t s ATTRIBUTE_UNUSED;");
1204
 
1205
  /* Size adjustments must be propagated to all containing modes.
1206
     A size adjustment forces us to recalculate the alignment too.  */
1207
  for (a = adj_bytesize; a; a = a->next)
1208
    {
1209
      printf ("\n  /* %s:%d */\n  s = %s;\n",
1210
              a->file, a->line, a->adjustment);
1211
      printf ("  mode_size[%smode] = s;\n", a->mode->name);
1212
      printf ("  mode_base_align[%smode] = s & (~s + 1);\n",
1213
              a->mode->name);
1214
 
1215
      for (m = a->mode->contained; m; m = m->next_cont)
1216
        {
1217
          switch (m->cl)
1218
            {
1219
            case MODE_COMPLEX_INT:
1220
            case MODE_COMPLEX_FLOAT:
1221
              printf ("  mode_size[%smode] = 2*s;\n", m->name);
1222
              printf ("  mode_base_align[%smode] = s & (~s + 1);\n",
1223
                      m->name);
1224
              break;
1225
 
1226
            case MODE_VECTOR_INT:
1227
            case MODE_VECTOR_FLOAT:
1228
            case MODE_VECTOR_FRACT:
1229
            case MODE_VECTOR_UFRACT:
1230
            case MODE_VECTOR_ACCUM:
1231
            case MODE_VECTOR_UACCUM:
1232
              printf ("  mode_size[%smode] = %d*s;\n",
1233
                      m->name, m->ncomponents);
1234
              printf ("  mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1235
                      m->name, m->ncomponents, m->ncomponents);
1236
              break;
1237
 
1238
            default:
1239
              internal_error (
1240
              "mode %s is neither vector nor complex but contains %s",
1241
              m->name, a->mode->name);
1242
              /* NOTREACHED */
1243
            }
1244
        }
1245
    }
1246
 
1247
  /* Alignment adjustments propagate too.
1248
     ??? This may not be the right thing for vector modes.  */
1249
  for (a = adj_alignment; a; a = a->next)
1250
    {
1251
      printf ("\n  /* %s:%d */\n  s = %s;\n",
1252
              a->file, a->line, a->adjustment);
1253
      printf ("  mode_base_align[%smode] = s;\n", a->mode->name);
1254
 
1255
      for (m = a->mode->contained; m; m = m->next_cont)
1256
        {
1257
          switch (m->cl)
1258
            {
1259
            case MODE_COMPLEX_INT:
1260
            case MODE_COMPLEX_FLOAT:
1261
              printf ("  mode_base_align[%smode] = s;\n", m->name);
1262
              break;
1263
 
1264
            case MODE_VECTOR_INT:
1265
            case MODE_VECTOR_FLOAT:
1266
            case MODE_VECTOR_FRACT:
1267
            case MODE_VECTOR_UFRACT:
1268
            case MODE_VECTOR_ACCUM:
1269
            case MODE_VECTOR_UACCUM:
1270
              printf ("  mode_base_align[%smode] = %d*s;\n",
1271
                      m->name, m->ncomponents);
1272
              break;
1273
 
1274
            default:
1275
              internal_error (
1276
              "mode %s is neither vector nor complex but contains %s",
1277
              m->name, a->mode->name);
1278
              /* NOTREACHED */
1279
            }
1280
        }
1281
    }
1282
 
1283
  /* Ibit adjustments don't have to propagate.  */
1284
  for (a = adj_ibit; a; a = a->next)
1285
    {
1286
      printf ("\n  /* %s:%d */\n  s = %s;\n",
1287
              a->file, a->line, a->adjustment);
1288
      printf ("  mode_ibit[%smode] = s;\n", a->mode->name);
1289
    }
1290
 
1291
  /* Fbit adjustments don't have to propagate.  */
1292
  for (a = adj_fbit; a; a = a->next)
1293
    {
1294
      printf ("\n  /* %s:%d */\n  s = %s;\n",
1295
              a->file, a->line, a->adjustment);
1296
      printf ("  mode_fbit[%smode] = s;\n", a->mode->name);
1297
    }
1298
 
1299
  /* Real mode formats don't have to propagate anywhere.  */
1300
  for (a = adj_format; a; a = a->next)
1301
    printf ("\n  /* %s:%d */\n  REAL_MODE_FORMAT (%smode) = %s;\n",
1302
            a->file, a->line, a->mode->name, a->adjustment);
1303
 
1304
  puts ("}");
1305
}
1306
 
1307
/* Emit ibit for all modes.  */
1308
 
1309
static void
1310
emit_mode_ibit (void)
1311
{
1312
  int c;
1313
  struct mode_data *m;
1314
 
1315
  print_maybe_const_decl ("%sunsigned char",
1316
                          "mode_ibit", "NUM_MACHINE_MODES",
1317
                          ibit);
1318
 
1319
  for_all_modes (c, m)
1320
    tagged_printf ("%u", m->ibit, m->name);
1321
 
1322
  print_closer ();
1323
}
1324
 
1325
/* Emit fbit for all modes.  */
1326
 
1327
static void
1328
emit_mode_fbit (void)
1329
{
1330
  int c;
1331
  struct mode_data *m;
1332
 
1333
  print_maybe_const_decl ("%sunsigned char",
1334
                          "mode_fbit", "NUM_MACHINE_MODES",
1335
                          fbit);
1336
 
1337
  for_all_modes (c, m)
1338
    tagged_printf ("%u", m->fbit, m->name);
1339
 
1340
  print_closer ();
1341
}
1342
 
1343
 
1344
static void
1345
emit_insn_modes_c (void)
1346
{
1347
  emit_insn_modes_c_header ();
1348
  emit_mode_name ();
1349
  emit_mode_class ();
1350
  emit_mode_precision ();
1351
  emit_mode_size ();
1352
  emit_mode_nunits ();
1353
  emit_mode_wider ();
1354
  emit_mode_mask ();
1355
  emit_mode_inner ();
1356
  emit_mode_base_align ();
1357
  emit_class_narrowest_mode ();
1358
  emit_real_format_for_mode ();
1359
  emit_mode_adjustments ();
1360
  emit_mode_ibit ();
1361
  emit_mode_fbit ();
1362
}
1363
 
1364
static void
1365
emit_min_insn_modes_c (void)
1366
{
1367
  emit_min_insn_modes_c_header ();
1368
  emit_mode_name ();
1369
  emit_mode_class ();
1370
  emit_mode_wider ();
1371
  emit_class_narrowest_mode ();
1372
}
1373
 
1374
/* Master control.  */
1375
int
1376
main (int argc, char **argv)
1377
{
1378
  bool gen_header = false, gen_min = false;
1379
  progname = argv[0];
1380
 
1381
  if (argc == 1)
1382
    ;
1383
  else if (argc == 2 && !strcmp (argv[1], "-h"))
1384
    gen_header = true;
1385
  else if (argc == 2 && !strcmp (argv[1], "-m"))
1386
    gen_min = true;
1387
  else
1388
    {
1389
      error ("usage: %s [-h|-m] > file", progname);
1390
      return FATAL_EXIT_CODE;
1391
    }
1392
 
1393
  modes_by_name = htab_create_alloc (64, hash_mode, eq_mode, 0, xcalloc, free);
1394
 
1395
  create_modes ();
1396
  complete_all_modes ();
1397
 
1398
  if (have_error)
1399
    return FATAL_EXIT_CODE;
1400
 
1401
  calc_wider_mode ();
1402
 
1403
  if (gen_header)
1404
    emit_insn_modes_h ();
1405
  else if (gen_min)
1406
    emit_min_insn_modes_c ();
1407
  else
1408
    emit_insn_modes_c ();
1409
 
1410
  if (fflush (stdout) || fclose (stdout))
1411
    return FATAL_EXIT_CODE;
1412
  return SUCCESS_EXIT_CODE;
1413
}

powered by: WebSVN 2.1.0

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