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