OSDN Git Service

* genmodes.c (calc_wider_mode): Allocate enough room for all the
[pf3gnuchains/gcc-fork.git] / gcc / genmodes.c
1 /* Generate the machine mode enumeration and associated tables.
2    Copyright (C) 2003
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 2, 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 COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 #include "bconfig.h"
23 #include "system.h"
24 #include "errors.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 class;        /* this mode class */
58   unsigned int bitsize;         /* 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 - MODE_FLOAT only */
63
64   struct mode_data *component;  /* mode of components */
65   struct mode_data *wider;      /* next wider mode */
66
67   const char *file;             /* file and line of definition, */
68   unsigned int line;            /* for error reporting */
69 };
70
71 static struct mode_data *known_modes[MAX_MODE_CLASS];
72 static unsigned int n_modes[MAX_MODE_CLASS];
73 static struct mode_data *void_mode;
74
75 static const struct mode_data blank_mode = {
76   0, "<unknown>", MAX_MODE_CLASS,
77   -1, -1, -1, -1,
78   0, 0, 0,
79   "<unknown>", 0
80 };
81
82 /* Mode class operations.  */
83 static enum mode_class
84 complex_class (enum mode_class class)
85 {
86   switch (class)
87     {
88     case MODE_INT: return MODE_COMPLEX_INT;
89     case MODE_FLOAT: return MODE_COMPLEX_FLOAT;
90     default:
91       error ("no complex class for class %s", mode_class_names[class]);
92       return MODE_RANDOM;
93     }
94 }
95
96 static enum mode_class
97 vector_class (enum mode_class class)
98 {
99   switch (class)
100     {
101     case MODE_INT: return MODE_VECTOR_INT;
102     case MODE_FLOAT: return MODE_VECTOR_FLOAT;
103     default:
104       error ("no vector class for class %s", mode_class_names[class]);
105       return MODE_RANDOM;
106     }
107 }
108
109 static struct mode_data *
110 find_mode (enum mode_class class, const char *name)
111 {
112   struct mode_data *m;
113
114   for (m = known_modes[class]; m; m = m->next)
115     if (!strcmp (name, m->name))
116       return m;
117
118   return 0;
119 }
120
121 static struct mode_data *
122 new_mode (enum mode_class class, const char *name,
123           const char *file, unsigned int line)
124 {
125   struct mode_data *m;
126
127   m = find_mode (class, name);
128   if (m)
129     {
130       error ("%s:%d: duplicate definition of mode \"%s\"",
131              trim_filename (file), line, name);
132       error ("%s:%d: previous definition here", m->file, m->line);
133       return m;
134     }
135
136   m = xmalloc (sizeof (struct mode_data));
137   memcpy (m, &blank_mode, sizeof (struct mode_data));
138   m->class = class;
139   m->name = name;
140   if (file)
141     m->file = trim_filename (file);
142   m->line = line;
143
144   m->next = known_modes[class];
145   known_modes[class] = m;
146   n_modes[class]++;
147   return m;
148 }
149
150 #define for_all_modes(C, M)                     \
151   for (C = 0; C < MAX_MODE_CLASS; C++)          \
152     for (M = known_modes[C]; M; M = M->next)
153
154
155 /* Diagnose failure to meet expectations in a partially filled out
156    mode structure.  */
157 enum requirement { SET, UNSET, OPTIONAL };
158
159 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
160   switch (req)                                                          \
161     {                                                                   \
162     case SET:                                                           \
163       if (val == unset)                                                 \
164         error ("%s:%d: (%s) field %s must be set",                      \
165                file, line, mname, fname);                               \
166       break;                                                            \
167     case UNSET:                                                         \
168       if (val != unset)                                                 \
169         error ("%s:%d: (%s) field %s must not be set",                  \
170                file, line, mname, fname);                               \
171     case OPTIONAL:                                                      \
172       break;                                                            \
173     }                                                                   \
174 } while (0)
175
176 #define validate_field(M, F) \
177   validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
178
179 static void
180 validate_mode (struct mode_data *m,
181                enum requirement r_bitsize,
182                enum requirement r_bytesize,
183                enum requirement r_component,
184                enum requirement r_ncomponents,
185                enum requirement r_format)
186 {
187   validate_field (m, bitsize);
188   validate_field (m, bytesize);
189   validate_field (m, component);
190   validate_field (m, ncomponents);
191   validate_field (m, format);
192 }
193 #undef validate_field
194 #undef validate_field_
195
196 /* Given a partially-filled-out mode structure, figure out what we can
197    and fill the rest of it in; die if it isn't enough.  */
198 static void
199 complete_mode (struct mode_data *m)
200 {
201   unsigned int alignment;
202
203   if (!m->name)
204     {
205       error ("%s:%d: mode with no name", m->file, m->line);
206       return;
207     }
208   if (m->class == MAX_MODE_CLASS)
209     {
210       error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
211       return;
212     }
213
214   switch (m->class)
215     {
216     case MODE_RANDOM:
217       /* Nothing more need be said.  */
218       if (!strcmp (m->name, "VOID"))
219         void_mode = m;
220
221       validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
222
223       m->bitsize = 0;
224       m->bytesize = 0;
225       m->ncomponents = 0;
226       m->component = 0;
227       break;
228
229     case MODE_CC:
230       /* Again, nothing more need be said.  For historical reasons,
231          the size of a CC mode is four units.  */
232       validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
233
234       m->bytesize = 4;
235       m->ncomponents = 0;
236       m->component = 0;
237       break;
238
239     case MODE_INT:
240     case MODE_FLOAT:
241       /* A scalar mode must have a byte size, may have a bit size,
242          and must not have components.   A float mode must have a
243          format.  */
244       validate_mode (m, OPTIONAL, SET, UNSET, UNSET,
245                      m->class == MODE_FLOAT ? SET : UNSET);
246
247       m->ncomponents = 0;
248       m->component = 0;
249       break;
250
251     case MODE_PARTIAL_INT:
252       /* A partial integer mode uses ->component to say what the
253          corresponding full-size integer mode is, and may also
254          specify a bit size.  */
255       validate_mode (m, OPTIONAL, UNSET, SET, UNSET, UNSET);
256
257       m->bytesize = m->component->bytesize;
258
259       m->ncomponents = 0;
260       m->component = 0;  /* ??? preserve this */
261       break;
262
263     case MODE_COMPLEX_INT:
264     case MODE_COMPLEX_FLOAT:
265       /* Complex modes should have a component indicated, but no more.  */
266       validate_mode (m, UNSET, UNSET, SET, UNSET, UNSET);
267       m->ncomponents = 2;
268       if (m->component->bitsize != (unsigned int)-1)
269         m->bitsize = 2 * m->component->bitsize;
270       m->bytesize = 2 * m->component->bytesize;
271       break;
272
273     case MODE_VECTOR_INT:
274     case MODE_VECTOR_FLOAT:
275       /* Vector modes should have a component and a number of components.  */
276       validate_mode (m, UNSET, UNSET, SET, SET, UNSET);
277       if (m->component->bitsize != (unsigned int)-1)
278         m->bitsize = m->ncomponents * m->component->bitsize;
279       m->bytesize = m->ncomponents * m->component->bytesize;
280       break;
281
282     default:
283       abort ();
284     }
285
286   /* If not already specified, the mode alignment defaults to the largest
287      power of two that divides the size of the object.  Complex types are
288      not more aligned than their contents.  */
289   if (m->class == MODE_COMPLEX_INT || m->class == MODE_COMPLEX_FLOAT)
290     alignment = m->component->bytesize;
291   else
292     alignment = m->bytesize;
293
294   m->alignment = alignment & (~alignment + 1);
295 }
296
297 static void
298 complete_all_modes (void)
299 {
300   struct mode_data *m;
301   enum mode_class c;
302   
303   for_all_modes (c, m)
304     complete_mode (m);
305 }
306
307 /* For each mode in class CLASS, construct a corresponding complex mode.  */
308 #define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
309 static void
310 make_complex_modes (enum mode_class class,
311                     const char *file, unsigned int line)
312 {
313   struct mode_data *m;
314   struct mode_data *c;
315   char buf[8];
316   enum mode_class cclass = complex_class (class);
317
318   if (cclass == MODE_RANDOM)
319     return;
320     
321   for (m = known_modes[class]; m; m = m->next)
322     {
323       /* Skip BImode.  FIXME: BImode probably shouldn't be MODE_INT.  */
324       if (m->bitsize == 1)
325         continue;
326
327       if (strlen (m->name) >= sizeof buf)
328         {
329           error ("%s:%d:mode name \"%s\" is too long",
330                  m->file, m->line, m->name);
331           continue;
332         }
333
334       /* Float complex modes are named SCmode, etc.
335          Int complex modes are named CSImode, etc.
336          This inconsistency should be eliminated.  */
337       if (class == MODE_FLOAT)
338         {
339           char *p;
340           strncpy (buf, m->name, sizeof buf);
341           p = strchr (buf, 'F');
342           if (p == 0)
343             {
344               error ("%s:%d: float mode \"%s\" has no 'F'",
345                      m->file, m->line, m->name);
346               continue;
347             }
348
349           *p = 'C';
350         }
351       else
352         snprintf (buf, sizeof buf, "C%s", m->name);
353
354       c = new_mode (cclass, xstrdup (buf), file, line);
355       c->component = m;
356     }
357 }
358
359 /* For all modes in class CLASS, construct vector modes of width
360    WIDTH, having as many components as necessary.  */
361 #define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
362 static void
363 make_vector_modes (enum mode_class class, unsigned int width,
364                    const char *file, unsigned int line)
365 {
366   struct mode_data *m;
367   struct mode_data *v;
368   char buf[8];
369   unsigned int ncomponents;
370   enum mode_class vclass = vector_class (class);
371
372   if (vclass == MODE_RANDOM)
373     return;
374
375   for (m = known_modes[class]; m; m = m->next)
376     {
377       /* Do not construct vector modes with only one element, or
378          vector modes where the element size doesn't divide the full
379          size evenly.  */
380       ncomponents = width / m->bytesize;
381       if (ncomponents < 2)
382         continue;
383       if (width % m->bytesize)
384         continue;
385
386       /* Skip QFmode and BImode.  FIXME: this special case should
387          not be necessary.  */
388       if (class == MODE_FLOAT && m->bytesize == 1)
389         continue;
390       if (class == MODE_INT && m->bitsize == 1)
391         continue;
392
393       if ((size_t)snprintf (buf, sizeof buf, "V%u%s", ncomponents, m->name)
394           >= sizeof buf)
395         {
396           error ("%s:%d: mode name \"%s\" is too long",
397                  m->file, m->line, m->name);
398           continue;
399         }
400
401       v = new_mode (vclass, xstrdup (buf), file, line);
402       v->component = m;
403       v->ncomponents = ncomponents;
404     }
405 }
406
407 /* Input.  */
408
409 #define _SPECIAL_MODE(C, N) make_special_mode(MODE_##C, #N, __FILE__, __LINE__)
410 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
411 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
412
413 static void
414 make_special_mode (enum mode_class class, const char *name,
415                    const char *file, unsigned int line)
416 {
417   new_mode (class, name, file, line);
418 }
419
420 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1, Y)
421 #define FRACTIONAL_INT_MODE(N, B, Y) \
422   make_int_mode (#N, B, Y, __FILE__, __LINE__)
423
424 static void
425 make_int_mode (const char *name,
426                unsigned int bitsize, unsigned int bytesize,
427                const char *file, unsigned int line)
428 {
429   struct mode_data *m = new_mode (MODE_INT, name, file, line);
430   m->bytesize = bytesize;
431   m->bitsize = bitsize;
432 }
433
434 #define FLOAT_MODE(N, Y, F)             FRACTIONAL_FLOAT_MODE (N, -1, Y, F)
435 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
436   make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
437
438 static void
439 make_float_mode (const char *name,
440                  unsigned int bitsize, unsigned int bytesize,
441                  const char *format,
442                  const char *file, unsigned int line)
443 {
444   struct mode_data *m = new_mode (MODE_FLOAT, name, file, line);
445   m->bytesize = bytesize;
446   m->bitsize = bitsize;
447   m->format = format;
448 }
449
450 #define RESET_FLOAT_FORMAT(N, F) \
451   reset_float_format (#N, #F, __FILE__, __LINE__)
452 static void ATTRIBUTE_UNUSED
453 reset_float_format (const char *name, const char *format,
454                     const char *file, const char *line)
455 {
456   struct mode_data *m = find_mode (MODE_FLOAT, name);
457   if (!m)
458     {
459       error ("%s:%d: no mode \"%s\" in class FLOAT", file, line, name);
460       return;
461     }
462   m->format = format;
463 }
464
465 /* Partial integer modes are specified by relation to a full integer mode.
466    For now, we do not attempt to narrow down their bit sizes.  */
467 #define PARTIAL_INT_MODE(M) \
468   make_partial_integer_mode (#M, "P" #M, -1, __FILE__, __LINE__)
469 static void ATTRIBUTE_UNUSED
470 make_partial_integer_mode (const char *base, const char *name,
471                            unsigned int bitsize,
472                            const char *file, unsigned int line)
473 {
474   struct mode_data *m;
475   struct mode_data *component = find_mode (MODE_INT, base);
476   if (!component)
477     {
478       error ("%s:%d: no mode \"%s\" in class INT", file, line, name);
479       return;
480     }
481   
482   m = new_mode (MODE_PARTIAL_INT, name, file, line);
483   m->bitsize = bitsize;
484   m->component = component;
485 }
486
487 /* A single vector mode can be specified by naming its component
488    mode and the number of components.  */
489 #define VECTOR_MODE(C, M, N) \
490   make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
491 static void ATTRIBUTE_UNUSED
492 make_vector_mode (enum mode_class bclass,
493                   const char *base,
494                   unsigned int ncomponents,
495                   const char *file, unsigned int line)
496 {
497   struct mode_data *v;
498   enum mode_class vclass = vector_class (bclass);
499   struct mode_data *component = find_mode (bclass, base);
500   char namebuf[8];
501
502   if (vclass == MODE_RANDOM)
503     return;
504   if (component == 0)
505     {
506       error ("%s:%d: no mode \"%s\" in class %s",
507              file, line, base, mode_class_names[bclass] + 5);
508       return;
509     }
510
511   if ((size_t)snprintf (namebuf, sizeof namebuf, "V%u%s",
512                         ncomponents, base) >= sizeof namebuf)
513     {
514       error ("%s:%d: mode name \"%s\" is too long",
515              base, file, line);
516       return;
517     }
518
519   v = new_mode (vclass, xstrdup (namebuf), file, line);
520   v->ncomponents = ncomponents;
521   v->component = component;
522 }
523   
524
525 static void
526 create_modes (void)
527 {
528 #include "machmode.def"
529 }
530
531 /* Processing.  */
532
533 /* Sort a list of modes into the order needed for the WIDER field:
534    major sort by bitsize, minor sort by component bitsize.
535
536    For instance:
537      QI < HI < SI < DI < TI
538      V4QI < V2HI < V8QI < V4HI < V2SI.
539
540    If the bitsize is not set, sort by the bytesize.  A mode with
541    bitsize set gets sorted before a mode without bitsize set, if
542    they have the same bytesize; this is the right thing because
543    the bitsize must always be smaller than the bytesize * BITS_PER_UNIT.
544    We don't have to do anything special to get this done -- an unset
545    bitsize shows up as (unsigned int)-1, i.e. UINT_MAX.  */
546 static int
547 cmp_modes (const void *a, const void *b)
548 {
549   struct mode_data *m = *(struct mode_data **)a;
550   struct mode_data *n = *(struct mode_data **)b;
551
552   if (m->bytesize > n->bytesize)
553     return 1;
554   else if (m->bytesize < n->bytesize)
555     return -1;
556
557   if (m->bitsize > n->bitsize)
558     return 1;
559   else if (m->bitsize < n->bitsize)
560     return -1;
561
562   if (!m->component && !n->component)
563     return 0;
564
565   if (m->component->bytesize > n->component->bytesize)
566     return 1;
567   else if (m->component->bytesize < n->component->bytesize)
568     return -1;
569
570   if (m->component->bitsize > n->component->bitsize)
571     return 1;
572   else if (m->component->bitsize < n->component->bitsize)
573     return -1;
574
575   return 0;
576 }
577
578 static void
579 calc_wider_mode (void)
580 {
581   enum mode_class c;
582   struct mode_data *m;
583   struct mode_data **sortbuf;
584   unsigned int max_n_modes = 0;
585   unsigned int i, j;
586
587   for (c = 0; c < MAX_MODE_CLASS; c++)
588     max_n_modes = MAX (max_n_modes, n_modes[c]);
589
590   /* Allocate max_n_modes + 1 entries to leave room for the extra null
591      pointer assigned after the qsort call below.  */
592   sortbuf = alloca ((max_n_modes + 1) * sizeof (struct mode_data *));
593
594   for (c = 0; c < MAX_MODE_CLASS; c++)
595     {
596       /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
597          However, we want these in textual order, and we have
598          precisely the reverse.  */
599       if (c == MODE_RANDOM || c == MODE_CC)
600         {
601           struct mode_data *prev, *next;
602
603           for (prev = 0, m = known_modes[c]; m; m = next)
604             {
605               m->wider = void_mode;
606
607               /* this is nreverse */
608               next = m->next;
609               m->next = prev;
610               prev = m;
611             }
612           known_modes[c] = prev;
613         }
614       else
615         {
616           if (!known_modes[c])
617             continue;
618
619           for (i = 0, m = known_modes[c]; m; i++, m = m->next)
620             sortbuf[i] = m;
621
622           qsort (sortbuf, i, sizeof (struct mode_data *), cmp_modes);
623
624           sortbuf[i] = 0;
625           for (j = 0; j < i; j++)
626             sortbuf[j]->next = sortbuf[j]->wider = sortbuf[j + 1];
627
628
629           known_modes[c] = sortbuf[0];
630         }
631     }
632 }
633
634 /* Output routines.  */
635
636 #define tagged_printf(FMT, ARG, TAG) do {               \
637   int count_;                                           \
638   printf ("  " FMT ",%n", ARG, &count_);                \
639   printf ("%*s/* %s */\n", 27 - count_, "", TAG);       \
640 } while (0)
641
642 #define print_decl(TYPE, NAME, ASIZE) \
643   printf ("\nconst %s %s[%s] =\n{\n", TYPE, NAME, ASIZE);
644
645 #define print_closer() puts ("};")
646
647 static void
648 emit_insn_modes_h (void)
649 {
650   enum mode_class c;
651   struct mode_data *m, *first, *last;
652
653   printf ("/* Generated automatically from machmode.def%s%s\n",
654            HAVE_EXTRA_MODES ? " and " : "",
655            EXTRA_MODES_FILE);
656
657   puts ("\
658    by genmodes.  */\n\
659 \n\
660 #ifndef GCC_INSN_MODES_H\n\
661 #define GCC_INSN_MODES_H\n\
662 \n\
663 enum machine_mode\n{");
664
665   for (c = 0; c < MAX_MODE_CLASS; c++)
666     for (m = known_modes[c]; m; m = m->next)
667       {
668         int count_;
669         printf ("  %smode,%n", m->name, &count_);
670         printf ("%*s/* %s:%d */\n", 27 - count_, "",
671                  trim_filename (m->file), m->line);
672       }
673
674   puts ("  MAX_MACHINE_MODE,\n");
675
676   for (c = 0; c < MAX_MODE_CLASS; c++)
677     {
678       first = known_modes[c];
679       last = 0;
680       for (m = first; m; last = m, m = m->next)
681         ;
682
683       /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
684          end will try to use it for bitfields in structures and the
685          like, which we do not want.  Only the target md file should
686          generate BImode widgets.  */
687       if (first && first->bitsize == 1)
688         first = first->next;
689
690       if (first && last)
691         printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
692                  mode_class_names[c], first->name,
693                  mode_class_names[c], last->name);
694       else
695         printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
696                  mode_class_names[c], void_mode->name,
697                  mode_class_names[c], void_mode->name);
698     }
699
700   puts ("\
701   NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
702 };\n\
703 \n\
704 #endif /* insn-modes.h */");
705 }
706
707 static void
708 emit_insn_modes_c_header (void)
709 {
710   printf ("/* Generated automatically from machmode.def%s%s\n",
711            HAVE_EXTRA_MODES ? " and " : "",
712            EXTRA_MODES_FILE);
713
714   puts ("\
715    by genmodes.  */\n\
716 \n\
717 #include \"config.h\"\n\
718 #include \"system.h\"\n\
719 #include \"coretypes.h\"\n\
720 #include \"tm.h\"\n\
721 #include \"machmode.h\"\n\
722 #include \"real.h\"");
723 }
724
725 static void
726 emit_min_insn_modes_c_header (void)
727 {
728   printf ("/* Generated automatically from machmode.def%s%s\n",
729            HAVE_EXTRA_MODES ? " and " : "",
730            EXTRA_MODES_FILE);
731
732   puts ("\
733    by genmodes.  */\n\
734 \n\
735 #include \"bconfig.h\"\n\
736 #include \"system.h\"\n\
737 #include \"machmode.h\"");
738 }
739
740 static void
741 emit_mode_name (void)
742 {
743   enum mode_class c;
744   struct mode_data *m;
745
746   print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
747
748   for_all_modes (c, m)
749     printf ("  \"%s\",\n", m->name);
750
751   print_closer ();
752 }
753
754 static void
755 emit_mode_class (void)
756 {
757   enum mode_class c;
758   struct mode_data *m;
759
760   print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
761
762   for_all_modes (c, m)
763     tagged_printf ("%s", mode_class_names[m->class], m->name);
764
765   print_closer ();
766 }
767
768 static void
769 emit_mode_bitsize (void)
770 {
771   enum mode_class c;
772   struct mode_data *m;
773
774   print_decl ("unsigned short", "mode_bitsize", "NUM_MACHINE_MODES");
775
776   for_all_modes (c, m)
777     if (m->bitsize != (unsigned int)-1)
778       tagged_printf ("%u", m->bitsize, m->name);
779     else
780       tagged_printf ("%u*BITS_PER_UNIT", m->bytesize, m->name);
781
782   print_closer ();
783 }
784
785 static void
786 emit_mode_size (void)
787 {
788   enum mode_class c;
789   struct mode_data *m;
790
791   print_decl ("unsigned char", "mode_size", "NUM_MACHINE_MODES");
792
793   for_all_modes (c, m)
794     tagged_printf ("%u", m->bytesize, m->name);
795
796   print_closer ();
797 }
798
799 static void
800 emit_mode_unit_size (void)
801 {
802   enum mode_class c;
803   struct mode_data *m;
804
805   print_decl ("unsigned char", "mode_unit_size", "NUM_MACHINE_MODES");
806
807   for_all_modes (c, m)
808     tagged_printf ("%u",
809                    m->component
810                    ? m->component->bytesize : m->bytesize,
811                    m->name);
812
813   print_closer ();
814 }
815
816 static void
817 emit_mode_wider (void)
818 {
819   enum mode_class c;
820   struct mode_data *m;
821
822   print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
823
824   for_all_modes (c, m)
825     tagged_printf ("%smode",
826                    m->wider ? m->wider->name : void_mode->name,
827                    m->name);
828
829   print_closer ();
830 }
831
832 static void
833 emit_mode_mask (void)
834 {
835   enum mode_class c;
836   struct mode_data *m;
837
838   print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
839               "NUM_MACHINE_MODES");
840   puts ("\
841 #define MODE_MASK(m)                          \\\n\
842   ((m) >= HOST_BITS_PER_WIDE_INT)             \\\n\
843    ? ~(unsigned HOST_WIDE_INT) 0              \\\n\
844    : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
845
846   for_all_modes (c, m)
847     if (m->bitsize != (unsigned int)-1)
848       tagged_printf ("MODE_MASK (%u)", m->bitsize, m->name);
849     else
850       tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m->bytesize, m->name);
851
852   puts ("#undef MODE_MASK");
853   print_closer ();
854 }
855
856 static void
857 emit_mode_inner (void)
858 {
859   enum mode_class c;
860   struct mode_data *m;
861
862   print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
863
864   for_all_modes (c, m)
865     tagged_printf ("%smode",
866                    m->component ? m->component->name : void_mode->name,
867                    m->name);
868
869   print_closer ();
870 }
871
872 static void
873 emit_mode_base_align (void)
874 {
875   enum mode_class c;
876   struct mode_data *m;
877
878   print_decl ("unsigned char", "mode_base_align", "NUM_MACHINE_MODES");
879
880   for_all_modes (c, m)
881     tagged_printf ("%u", m->alignment, m->name);
882
883   print_closer ();
884 }
885
886 static void
887 emit_class_narrowest_mode (void)
888 {
889   enum mode_class c;
890
891   print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
892
893   for (c = 0; c < MAX_MODE_CLASS; c++)
894     /* Bleah, all this to get the comment right for MIN_MODE_INT.  */
895     tagged_printf ("MIN_%s", mode_class_names[c],
896                    known_modes[c]
897                    ? (known_modes[c]->bitsize != 1
898                       ? known_modes[c]->name
899                       : (known_modes[c]->next
900                          ? known_modes[c]->next->name
901                          : void_mode->name))
902                    : void_mode->name);
903   
904   print_closer ();
905 }
906
907 static void
908 emit_real_format_for_mode (void)
909 {
910   struct mode_data *m;
911
912   /* This will produce a table which is not constant, but points to
913      entities that are constant, which is what we want.  */
914   print_decl ("struct real_format *\n ", "real_format_for_mode",
915               "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1");
916
917   for (m = known_modes[MODE_FLOAT]; m; m = m->next)
918     if (!strcmp (m->format, "0"))
919       tagged_printf ("%s", m->format, m->name);
920     else
921       tagged_printf ("&%s", m->format, m->name);
922
923   print_closer ();
924 }
925
926 static void
927 emit_insn_modes_c (void)
928 {
929   emit_insn_modes_c_header ();
930   emit_mode_name ();
931   emit_mode_class ();
932   emit_mode_bitsize ();
933   emit_mode_size ();
934   emit_mode_unit_size ();
935   emit_mode_wider ();
936   emit_mode_mask ();
937   emit_mode_inner ();
938   emit_mode_base_align ();
939   emit_class_narrowest_mode ();
940   emit_real_format_for_mode ();
941 }
942
943 static void
944 emit_min_insn_modes_c (void)
945 {
946   emit_min_insn_modes_c_header ();
947   emit_mode_name ();
948   emit_mode_class ();
949   emit_mode_wider ();
950   emit_class_narrowest_mode ();
951 }
952
953 /* Master control.  */
954 int
955 main(int argc, char **argv)
956 {
957   bool gen_header = false, gen_min = false;
958   progname = argv[0];
959
960   if (argc == 1)
961     ;
962   else if (argc == 2 && !strcmp (argv[1], "-h"))
963     gen_header = true;
964   else if (argc == 2 && !strcmp (argv[1], "-m"))
965     gen_min = true;
966   else
967     {
968       error ("usage: %s [-h|-m] > file", progname);
969       return FATAL_EXIT_CODE;
970     }
971
972   create_modes ();
973   complete_all_modes ();
974
975   if (have_error)
976     return FATAL_EXIT_CODE;
977   
978   calc_wider_mode ();
979
980   if (gen_header)
981     emit_insn_modes_h ();
982   else if (gen_min)
983     emit_min_insn_modes_c ();
984   else
985     emit_insn_modes_c ();
986
987   if (fflush (stdout) || fclose (stdout))
988     return FATAL_EXIT_CODE;
989   return SUCCESS_EXIT_CODE;
990 }