* de.po: Update.
[official-gcc.git] / gcc / genmodes.c
blob9907d6997616d1837e924fe647cd2d5192f10602
1 /* Generate the machine mode enumeration and associated tables.
2 Copyright (C) 2003-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
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.
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.
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/>. */
20 #include "bconfig.h"
21 #include "system.h"
22 #include "errors.h"
23 #include "hashtab.h"
25 /* enum mode_class is normally defined by machmode.h but we can't
26 include that header here. */
27 #include "mode-classes.def"
29 #define DEF_MODE_CLASS(M) M
30 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
31 #undef DEF_MODE_CLASS
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] =
37 MODE_CLASSES
39 #undef DEF_MODE_CLASS
40 #undef MODE_CLASSES
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
49 /* Data structure for building up what we know about a mode.
50 They're clustered by mode class. */
51 struct mode_data
53 struct mode_data *next; /* next this class - arbitrary order */
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 */
63 struct mode_data *component; /* mode of components */
64 struct mode_data *wider; /* next wider mode */
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. */
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 */
77 static struct mode_data *modes[MAX_MODE_CLASS];
78 static unsigned int n_modes[MAX_MODE_CLASS];
79 static struct mode_data *void_mode;
81 static const struct mode_data blank_mode = {
82 0, "<unknown>", MAX_MODE_CLASS,
83 -1U, -1U, -1U, -1U,
84 0, 0, 0, 0, 0,
85 "<unknown>", 0, 0, 0, 0
88 static htab_t modes_by_name;
90 /* Data structure for recording target-specified runtime adjustments
91 to a particular mode. We support varying the byte size, the
92 alignment, and the floating point format. */
93 struct mode_adjust
95 struct mode_adjust *next;
96 struct mode_data *mode;
97 const char *adjustment;
99 const char *file;
100 unsigned int line;
103 static struct mode_adjust *adj_bytesize;
104 static struct mode_adjust *adj_alignment;
105 static struct mode_adjust *adj_format;
106 static struct mode_adjust *adj_ibit;
107 static struct mode_adjust *adj_fbit;
109 /* Mode class operations. */
110 static enum mode_class
111 complex_class (enum mode_class c)
113 switch (c)
115 case MODE_INT: return MODE_COMPLEX_INT;
116 case MODE_FLOAT: return MODE_COMPLEX_FLOAT;
117 default:
118 error ("no complex class for class %s", mode_class_names[c]);
119 return MODE_RANDOM;
123 static enum mode_class
124 vector_class (enum mode_class cl)
126 switch (cl)
128 case MODE_INT: return MODE_VECTOR_INT;
129 case MODE_FLOAT: return MODE_VECTOR_FLOAT;
130 case MODE_FRACT: return MODE_VECTOR_FRACT;
131 case MODE_UFRACT: return MODE_VECTOR_UFRACT;
132 case MODE_ACCUM: return MODE_VECTOR_ACCUM;
133 case MODE_UACCUM: return MODE_VECTOR_UACCUM;
134 default:
135 error ("no vector class for class %s", mode_class_names[cl]);
136 return MODE_RANDOM;
140 /* Utility routines. */
141 static inline struct mode_data *
142 find_mode (const char *name)
144 struct mode_data key;
146 key.name = name;
147 return (struct mode_data *) htab_find (modes_by_name, &key);
150 static struct mode_data *
151 new_mode (enum mode_class cl, const char *name,
152 const char *file, unsigned int line)
154 struct mode_data *m;
155 static unsigned int count = 0;
157 m = find_mode (name);
158 if (m)
160 error ("%s:%d: duplicate definition of mode \"%s\"",
161 trim_filename (file), line, name);
162 error ("%s:%d: previous definition here", m->file, m->line);
163 return m;
166 m = XNEW (struct mode_data);
167 memcpy (m, &blank_mode, sizeof (struct mode_data));
168 m->cl = cl;
169 m->name = name;
170 if (file)
171 m->file = trim_filename (file);
172 m->line = line;
173 m->counter = count++;
175 m->next = modes[cl];
176 modes[cl] = m;
177 n_modes[cl]++;
179 *htab_find_slot (modes_by_name, m, INSERT) = m;
181 return m;
184 static hashval_t
185 hash_mode (const void *p)
187 const struct mode_data *m = (const struct mode_data *)p;
188 return htab_hash_string (m->name);
191 static int
192 eq_mode (const void *p, const void *q)
194 const struct mode_data *a = (const struct mode_data *)p;
195 const struct mode_data *b = (const struct mode_data *)q;
197 return !strcmp (a->name, b->name);
200 #define for_all_modes(C, M) \
201 for (C = 0; C < MAX_MODE_CLASS; C++) \
202 for (M = modes[C]; M; M = M->next)
204 static void ATTRIBUTE_UNUSED
205 new_adjust (const char *name,
206 struct mode_adjust **category, const char *catname,
207 const char *adjustment,
208 enum mode_class required_class_from,
209 enum mode_class required_class_to,
210 const char *file, unsigned int line)
212 struct mode_data *mode = find_mode (name);
213 struct mode_adjust *a;
215 file = trim_filename (file);
217 if (!mode)
219 error ("%s:%d: no mode \"%s\"", file, line, name);
220 return;
223 if (required_class_from != MODE_RANDOM
224 && (mode->cl < required_class_from || mode->cl > required_class_to))
226 error ("%s:%d: mode \"%s\" is not among class {%s, %s}",
227 file, line, name, mode_class_names[required_class_from] + 5,
228 mode_class_names[required_class_to] + 5);
229 return;
232 for (a = *category; a; a = a->next)
233 if (a->mode == mode)
235 error ("%s:%d: mode \"%s\" already has a %s adjustment",
236 file, line, name, catname);
237 error ("%s:%d: previous adjustment here", a->file, a->line);
238 return;
241 a = XNEW (struct mode_adjust);
242 a->mode = mode;
243 a->adjustment = adjustment;
244 a->file = file;
245 a->line = line;
247 a->next = *category;
248 *category = a;
251 /* Diagnose failure to meet expectations in a partially filled out
252 mode structure. */
253 enum requirement { SET, UNSET, OPTIONAL };
255 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
256 switch (req) \
258 case SET: \
259 if (val == unset) \
260 error ("%s:%d: (%s) field %s must be set", \
261 file, line, mname, fname); \
262 break; \
263 case UNSET: \
264 if (val != unset) \
265 error ("%s:%d: (%s) field %s must not be set", \
266 file, line, mname, fname); \
267 case OPTIONAL: \
268 break; \
270 } while (0)
272 #define validate_field(M, F) \
273 validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
275 static void
276 validate_mode (struct mode_data *m,
277 enum requirement r_precision,
278 enum requirement r_bytesize,
279 enum requirement r_component,
280 enum requirement r_ncomponents,
281 enum requirement r_format)
283 validate_field (m, precision);
284 validate_field (m, bytesize);
285 validate_field (m, component);
286 validate_field (m, ncomponents);
287 validate_field (m, format);
289 #undef validate_field
290 #undef validate_field_
292 /* Given a partially-filled-out mode structure, figure out what we can
293 and fill the rest of it in; die if it isn't enough. */
294 static void
295 complete_mode (struct mode_data *m)
297 unsigned int alignment;
299 if (!m->name)
301 error ("%s:%d: mode with no name", m->file, m->line);
302 return;
304 if (m->cl == MAX_MODE_CLASS)
306 error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
307 return;
310 switch (m->cl)
312 case MODE_RANDOM:
313 /* Nothing more need be said. */
314 if (!strcmp (m->name, "VOID"))
315 void_mode = m;
317 validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
319 m->precision = 0;
320 m->bytesize = 0;
321 m->ncomponents = 0;
322 m->component = 0;
323 break;
325 case MODE_CC:
326 /* Again, nothing more need be said. For historical reasons,
327 the size of a CC mode is four units. */
328 validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
330 m->bytesize = 4;
331 m->ncomponents = 1;
332 m->component = 0;
333 break;
335 case MODE_INT:
336 case MODE_FLOAT:
337 case MODE_DECIMAL_FLOAT:
338 case MODE_FRACT:
339 case MODE_UFRACT:
340 case MODE_ACCUM:
341 case MODE_UACCUM:
342 /* A scalar mode must have a byte size, may have a bit size,
343 and must not have components. A float mode must have a
344 format. */
345 validate_mode (m, OPTIONAL, SET, UNSET, UNSET,
346 (m->cl == MODE_FLOAT || m->cl == MODE_DECIMAL_FLOAT)
347 ? SET : UNSET);
349 m->ncomponents = 1;
350 m->component = 0;
351 break;
353 case MODE_PARTIAL_INT:
354 /* A partial integer mode uses ->component to say what the
355 corresponding full-size integer mode is, and may also
356 specify a bit size. */
357 validate_mode (m, OPTIONAL, UNSET, SET, UNSET, UNSET);
359 m->bytesize = m->component->bytesize;
361 m->ncomponents = 1;
362 break;
364 case MODE_COMPLEX_INT:
365 case MODE_COMPLEX_FLOAT:
366 /* Complex modes should have a component indicated, but no more. */
367 validate_mode (m, UNSET, UNSET, SET, UNSET, UNSET);
368 m->ncomponents = 2;
369 if (m->component->precision != (unsigned int)-1)
370 m->precision = 2 * m->component->precision;
371 m->bytesize = 2 * m->component->bytesize;
372 break;
374 case MODE_VECTOR_INT:
375 case MODE_VECTOR_FLOAT:
376 case MODE_VECTOR_FRACT:
377 case MODE_VECTOR_UFRACT:
378 case MODE_VECTOR_ACCUM:
379 case MODE_VECTOR_UACCUM:
380 /* Vector modes should have a component and a number of components. */
381 validate_mode (m, UNSET, UNSET, SET, SET, UNSET);
382 if (m->component->precision != (unsigned int)-1)
383 m->precision = m->ncomponents * m->component->precision;
384 m->bytesize = m->ncomponents * m->component->bytesize;
385 break;
387 default:
388 gcc_unreachable ();
391 /* If not already specified, the mode alignment defaults to the largest
392 power of two that divides the size of the object. Complex types are
393 not more aligned than their contents. */
394 if (m->cl == MODE_COMPLEX_INT || m->cl == MODE_COMPLEX_FLOAT)
395 alignment = m->component->bytesize;
396 else
397 alignment = m->bytesize;
399 m->alignment = alignment & (~alignment + 1);
401 /* If this mode has components, make the component mode point back
402 to this mode, for the sake of adjustments. */
403 if (m->component)
405 m->next_cont = m->component->contained;
406 m->component->contained = m;
410 static void
411 complete_all_modes (void)
413 struct mode_data *m;
414 int cl;
416 for_all_modes (cl, m)
417 complete_mode (m);
420 /* For each mode in class CLASS, construct a corresponding complex mode. */
421 #define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
422 static void
423 make_complex_modes (enum mode_class cl,
424 const char *file, unsigned int line)
426 struct mode_data *m;
427 struct mode_data *c;
428 enum mode_class cclass = complex_class (cl);
430 if (cclass == MODE_RANDOM)
431 return;
433 for (m = modes[cl]; m; m = m->next)
435 char *p, *buf;
436 size_t m_len;
438 /* Skip BImode. FIXME: BImode probably shouldn't be MODE_INT. */
439 if (m->precision == 1)
440 continue;
442 m_len = strlen (m->name);
443 /* The leading "1 +" is in case we prepend a "C" below. */
444 buf = (char *) xmalloc (1 + m_len + 1);
446 /* Float complex modes are named SCmode, etc.
447 Int complex modes are named CSImode, etc.
448 This inconsistency should be eliminated. */
449 p = 0;
450 if (cl == MODE_FLOAT)
452 memcpy (buf, m->name, m_len + 1);
453 p = strchr (buf, 'F');
454 if (p == 0 && strchr (buf, 'D') == 0)
456 error ("%s:%d: float mode \"%s\" has no 'F' or 'D'",
457 m->file, m->line, m->name);
458 free (buf);
459 continue;
462 if (p != 0)
463 *p = 'C';
464 else
466 buf[0] = 'C';
467 memcpy (buf + 1, m->name, m_len + 1);
470 c = new_mode (cclass, buf, file, line);
471 c->component = m;
475 /* For all modes in class CL, construct vector modes of width
476 WIDTH, having as many components as necessary. */
477 #define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
478 static void ATTRIBUTE_UNUSED
479 make_vector_modes (enum mode_class cl, unsigned int width,
480 const char *file, unsigned int line)
482 struct mode_data *m;
483 struct mode_data *v;
484 char buf[8];
485 unsigned int ncomponents;
486 enum mode_class vclass = vector_class (cl);
488 if (vclass == MODE_RANDOM)
489 return;
491 for (m = modes[cl]; m; m = m->next)
493 /* Do not construct vector modes with only one element, or
494 vector modes where the element size doesn't divide the full
495 size evenly. */
496 ncomponents = width / m->bytesize;
497 if (ncomponents < 2)
498 continue;
499 if (width % m->bytesize)
500 continue;
502 /* Skip QFmode and BImode. FIXME: this special case should
503 not be necessary. */
504 if (cl == MODE_FLOAT && m->bytesize == 1)
505 continue;
506 if (cl == MODE_INT && m->precision == 1)
507 continue;
509 if ((size_t)snprintf (buf, sizeof buf, "V%u%s", ncomponents, m->name)
510 >= sizeof buf)
512 error ("%s:%d: mode name \"%s\" is too long",
513 m->file, m->line, m->name);
514 continue;
517 v = new_mode (vclass, xstrdup (buf), file, line);
518 v->component = m;
519 v->ncomponents = ncomponents;
523 /* Input. */
525 #define _SPECIAL_MODE(C, N) make_special_mode(MODE_##C, #N, __FILE__, __LINE__)
526 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
527 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
529 static void
530 make_special_mode (enum mode_class cl, const char *name,
531 const char *file, unsigned int line)
533 new_mode (cl, name, file, line);
536 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
537 #define FRACTIONAL_INT_MODE(N, B, Y) \
538 make_int_mode (#N, B, Y, __FILE__, __LINE__)
540 static void
541 make_int_mode (const char *name,
542 unsigned int precision, unsigned int bytesize,
543 const char *file, unsigned int line)
545 struct mode_data *m = new_mode (MODE_INT, name, file, line);
546 m->bytesize = bytesize;
547 m->precision = precision;
550 #define FRACT_MODE(N, Y, F) \
551 make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
553 #define UFRACT_MODE(N, Y, F) \
554 make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
556 #define ACCUM_MODE(N, Y, I, F) \
557 make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
559 #define UACCUM_MODE(N, Y, I, F) \
560 make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
562 /* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
563 FILE, and LINE. */
565 static void
566 make_fixed_point_mode (enum mode_class cl,
567 const char *name,
568 unsigned int bytesize,
569 unsigned int ibit,
570 unsigned int fbit,
571 const char *file, unsigned int line)
573 struct mode_data *m = new_mode (cl, name, file, line);
574 m->bytesize = bytesize;
575 m->ibit = ibit;
576 m->fbit = fbit;
579 #define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
580 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
581 make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
583 static void
584 make_float_mode (const char *name,
585 unsigned int precision, unsigned int bytesize,
586 const char *format,
587 const char *file, unsigned int line)
589 struct mode_data *m = new_mode (MODE_FLOAT, name, file, line);
590 m->bytesize = bytesize;
591 m->precision = precision;
592 m->format = format;
595 #define DECIMAL_FLOAT_MODE(N, Y, F) \
596 FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
597 #define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F) \
598 make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
600 static void
601 make_decimal_float_mode (const char *name,
602 unsigned int precision, unsigned int bytesize,
603 const char *format,
604 const char *file, unsigned int line)
606 struct mode_data *m = new_mode (MODE_DECIMAL_FLOAT, name, file, line);
607 m->bytesize = bytesize;
608 m->precision = precision;
609 m->format = format;
612 #define RESET_FLOAT_FORMAT(N, F) \
613 reset_float_format (#N, #F, __FILE__, __LINE__)
614 static void ATTRIBUTE_UNUSED
615 reset_float_format (const char *name, const char *format,
616 const char *file, unsigned int line)
618 struct mode_data *m = find_mode (name);
619 if (!m)
621 error ("%s:%d: no mode \"%s\"", file, line, name);
622 return;
624 if (m->cl != MODE_FLOAT && m->cl != MODE_DECIMAL_FLOAT)
626 error ("%s:%d: mode \"%s\" is not a FLOAT class", file, line, name);
627 return;
629 m->format = format;
632 /* Partial integer modes are specified by relation to a full integer mode.
633 For now, we do not attempt to narrow down their bit sizes. */
634 #define PARTIAL_INT_MODE(M) \
635 make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__)
636 static void ATTRIBUTE_UNUSED
637 make_partial_integer_mode (const char *base, const char *name,
638 unsigned int precision,
639 const char *file, unsigned int line)
641 struct mode_data *m;
642 struct mode_data *component = find_mode (base);
643 if (!component)
645 error ("%s:%d: no mode \"%s\"", file, line, name);
646 return;
648 if (component->cl != MODE_INT)
650 error ("%s:%d: mode \"%s\" is not class INT", file, line, name);
651 return;
654 m = new_mode (MODE_PARTIAL_INT, name, file, line);
655 m->precision = precision;
656 m->component = component;
659 /* A single vector mode can be specified by naming its component
660 mode and the number of components. */
661 #define VECTOR_MODE(C, M, N) \
662 make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
663 static void ATTRIBUTE_UNUSED
664 make_vector_mode (enum mode_class bclass,
665 const char *base,
666 unsigned int ncomponents,
667 const char *file, unsigned int line)
669 struct mode_data *v;
670 enum mode_class vclass = vector_class (bclass);
671 struct mode_data *component = find_mode (base);
672 char namebuf[8];
674 if (vclass == MODE_RANDOM)
675 return;
676 if (component == 0)
678 error ("%s:%d: no mode \"%s\"", file, line, base);
679 return;
681 if (component->cl != bclass
682 && (component->cl != MODE_PARTIAL_INT
683 || bclass != MODE_INT))
685 error ("%s:%d: mode \"%s\" is not class %s",
686 file, line, base, mode_class_names[bclass] + 5);
687 return;
690 if ((size_t)snprintf (namebuf, sizeof namebuf, "V%u%s",
691 ncomponents, base) >= sizeof namebuf)
693 error ("%s:%d: mode name \"%s\" is too long",
694 file, line, base);
695 return;
698 v = new_mode (vclass, xstrdup (namebuf), file, line);
699 v->ncomponents = ncomponents;
700 v->component = component;
703 /* Adjustability. */
704 #define _ADD_ADJUST(A, M, X, C1, C2) \
705 new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
707 #define ADJUST_BYTESIZE(M, X) _ADD_ADJUST(bytesize, M, X, RANDOM, RANDOM)
708 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST(alignment, M, X, RANDOM, RANDOM)
709 #define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST(format, M, X, FLOAT, FLOAT)
710 #define ADJUST_IBIT(M, X) _ADD_ADJUST(ibit, M, X, ACCUM, UACCUM)
711 #define ADJUST_FBIT(M, X) _ADD_ADJUST(fbit, M, X, FRACT, UACCUM)
713 static void
714 create_modes (void)
716 #include "machmode.def"
719 /* Processing. */
721 /* Sort a list of modes into the order needed for the WIDER field:
722 major sort by precision, minor sort by component precision.
724 For instance:
725 QI < HI < SI < DI < TI
726 V4QI < V2HI < V8QI < V4HI < V2SI.
728 If the precision is not set, sort by the bytesize. A mode with
729 precision set gets sorted before a mode without precision set, if
730 they have the same bytesize; this is the right thing because
731 the precision must always be smaller than the bytesize * BITS_PER_UNIT.
732 We don't have to do anything special to get this done -- an unset
733 precision shows up as (unsigned int)-1, i.e. UINT_MAX. */
734 static int
735 cmp_modes (const void *a, const void *b)
737 const struct mode_data *const m = *(const struct mode_data *const*)a;
738 const struct mode_data *const n = *(const struct mode_data *const*)b;
740 if (m->bytesize > n->bytesize)
741 return 1;
742 else if (m->bytesize < n->bytesize)
743 return -1;
745 if (m->precision > n->precision)
746 return 1;
747 else if (m->precision < n->precision)
748 return -1;
750 if (!m->component && !n->component)
752 if (m->counter < n->counter)
753 return -1;
754 else
755 return 1;
758 if (m->component->bytesize > n->component->bytesize)
759 return 1;
760 else if (m->component->bytesize < n->component->bytesize)
761 return -1;
763 if (m->component->precision > n->component->precision)
764 return 1;
765 else if (m->component->precision < n->component->precision)
766 return -1;
768 if (m->counter < n->counter)
769 return -1;
770 else
771 return 1;
774 static void
775 calc_wider_mode (void)
777 int c;
778 struct mode_data *m;
779 struct mode_data **sortbuf;
780 unsigned int max_n_modes = 0;
781 unsigned int i, j;
783 for (c = 0; c < MAX_MODE_CLASS; c++)
784 max_n_modes = MAX (max_n_modes, n_modes[c]);
786 /* Allocate max_n_modes + 1 entries to leave room for the extra null
787 pointer assigned after the qsort call below. */
788 sortbuf = XALLOCAVEC (struct mode_data *, max_n_modes + 1);
790 for (c = 0; c < MAX_MODE_CLASS; c++)
792 /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
793 However, we want these in textual order, and we have
794 precisely the reverse. */
795 if (c == MODE_RANDOM || c == MODE_CC)
797 struct mode_data *prev, *next;
799 for (prev = 0, m = modes[c]; m; m = next)
801 m->wider = void_mode;
803 /* this is nreverse */
804 next = m->next;
805 m->next = prev;
806 prev = m;
808 modes[c] = prev;
810 else
812 if (!modes[c])
813 continue;
815 for (i = 0, m = modes[c]; m; i++, m = m->next)
816 sortbuf[i] = m;
818 qsort (sortbuf, i, sizeof (struct mode_data *), cmp_modes);
820 sortbuf[i] = 0;
821 for (j = 0; j < i; j++)
823 sortbuf[j]->next = sortbuf[j + 1];
824 if (c == MODE_PARTIAL_INT)
825 sortbuf[j]->wider = sortbuf[j]->component;
826 else
827 sortbuf[j]->wider = sortbuf[j]->next;
830 modes[c] = sortbuf[0];
835 /* Output routines. */
837 #define tagged_printf(FMT, ARG, TAG) do { \
838 int count_ = printf (" " FMT ",", ARG); \
839 printf ("%*s/* %s */\n", 27 - count_, "", TAG); \
840 } while (0)
842 #define print_decl(TYPE, NAME, ASIZE) \
843 puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
845 #define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY) \
846 printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n", \
847 adj_##CATEGORY ? "" : "const ")
849 #define print_closer() puts ("};")
851 static void
852 emit_insn_modes_h (void)
854 int c;
855 struct mode_data *m, *first, *last;
857 printf ("/* Generated automatically from machmode.def%s%s\n",
858 HAVE_EXTRA_MODES ? " and " : "",
859 EXTRA_MODES_FILE);
861 puts ("\
862 by genmodes. */\n\
864 #ifndef GCC_INSN_MODES_H\n\
865 #define GCC_INSN_MODES_H\n\
867 enum machine_mode\n{");
869 for (c = 0; c < MAX_MODE_CLASS; c++)
870 for (m = modes[c]; m; m = m->next)
872 int count_ = printf (" %smode,", m->name);
873 printf ("%*s/* %s:%d */\n", 27 - count_, "",
874 trim_filename (m->file), m->line);
877 puts (" MAX_MACHINE_MODE,\n");
879 for (c = 0; c < MAX_MODE_CLASS; c++)
881 first = modes[c];
882 last = 0;
883 for (m = first; m; last = m, m = m->next)
886 /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
887 end will try to use it for bitfields in structures and the
888 like, which we do not want. Only the target md file should
889 generate BImode widgets. */
890 if (first && first->precision == 1)
891 first = first->next;
893 if (first && last)
894 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
895 mode_class_names[c], first->name,
896 mode_class_names[c], last->name);
897 else
898 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
899 mode_class_names[c], void_mode->name,
900 mode_class_names[c], void_mode->name);
903 puts ("\
904 NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
905 };\n");
907 /* I can't think of a better idea, can you? */
908 printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize ? "" : " const");
909 printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment ? "" : " const");
910 #if 0 /* disabled for backward compatibility, temporary */
911 printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format ? "" :" const");
912 #endif
913 printf ("#define CONST_MODE_IBIT%s\n", adj_ibit ? "" : " const");
914 printf ("#define CONST_MODE_FBIT%s\n", adj_fbit ? "" : " const");
915 puts ("\
917 #endif /* insn-modes.h */");
920 static void
921 emit_insn_modes_c_header (void)
923 printf ("/* Generated automatically from machmode.def%s%s\n",
924 HAVE_EXTRA_MODES ? " and " : "",
925 EXTRA_MODES_FILE);
927 puts ("\
928 by genmodes. */\n\
930 #include \"config.h\"\n\
931 #include \"system.h\"\n\
932 #include \"coretypes.h\"\n\
933 #include \"tm.h\"\n\
934 #include \"machmode.h\"\n\
935 #include \"real.h\"");
938 static void
939 emit_min_insn_modes_c_header (void)
941 printf ("/* Generated automatically from machmode.def%s%s\n",
942 HAVE_EXTRA_MODES ? " and " : "",
943 EXTRA_MODES_FILE);
945 puts ("\
946 by genmodes. */\n\
948 #include \"bconfig.h\"\n\
949 #include \"system.h\"\n\
950 #include \"machmode.h\"");
953 static void
954 emit_mode_name (void)
956 int c;
957 struct mode_data *m;
959 print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
961 for_all_modes (c, m)
962 printf (" \"%s\",\n", m->name);
964 print_closer ();
967 static void
968 emit_mode_class (void)
970 int c;
971 struct mode_data *m;
973 print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
975 for_all_modes (c, m)
976 tagged_printf ("%s", mode_class_names[m->cl], m->name);
978 print_closer ();
981 static void
982 emit_mode_precision (void)
984 int c;
985 struct mode_data *m;
987 print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
989 for_all_modes (c, m)
990 if (m->precision != (unsigned int)-1)
991 tagged_printf ("%u", m->precision, m->name);
992 else
993 tagged_printf ("%u*BITS_PER_UNIT", m->bytesize, m->name);
995 print_closer ();
998 static void
999 emit_mode_size (void)
1001 int c;
1002 struct mode_data *m;
1004 print_maybe_const_decl ("%sunsigned char", "mode_size",
1005 "NUM_MACHINE_MODES", bytesize);
1007 for_all_modes (c, m)
1008 tagged_printf ("%u", m->bytesize, m->name);
1010 print_closer ();
1013 static void
1014 emit_mode_nunits (void)
1016 int c;
1017 struct mode_data *m;
1019 print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1021 for_all_modes (c, m)
1022 tagged_printf ("%u", m->ncomponents, m->name);
1024 print_closer ();
1027 static void
1028 emit_mode_wider (void)
1030 int c;
1031 struct mode_data *m;
1033 print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1035 for_all_modes (c, m)
1036 tagged_printf ("%smode",
1037 m->wider ? m->wider->name : void_mode->name,
1038 m->name);
1040 print_closer ();
1041 print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1043 for_all_modes (c, m)
1045 struct mode_data * m2;
1047 for (m2 = m;
1048 m2 && m2 != void_mode;
1049 m2 = m2->wider)
1051 if (m2->bytesize < 2 * m->bytesize)
1052 continue;
1053 if (m->precision != (unsigned int) -1)
1055 if (m2->precision != 2 * m->precision)
1056 continue;
1058 else
1060 if (m2->precision != (unsigned int) -1)
1061 continue;
1064 /* For vectors we want twice the number of components,
1065 with the same element type. */
1066 if (m->cl == MODE_VECTOR_INT
1067 || m->cl == MODE_VECTOR_FLOAT
1068 || m->cl == MODE_VECTOR_FRACT
1069 || m->cl == MODE_VECTOR_UFRACT
1070 || m->cl == MODE_VECTOR_ACCUM
1071 || m->cl == MODE_VECTOR_UACCUM)
1073 if (m2->ncomponents != 2 * m->ncomponents)
1074 continue;
1075 if (m->component != m2->component)
1076 continue;
1079 break;
1081 if (m2 == void_mode)
1082 m2 = 0;
1083 tagged_printf ("%smode",
1084 m2 ? m2->name : void_mode->name,
1085 m->name);
1088 print_closer ();
1091 static void
1092 emit_mode_mask (void)
1094 int c;
1095 struct mode_data *m;
1097 print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1098 "NUM_MACHINE_MODES");
1099 puts ("\
1100 #define MODE_MASK(m) \\\n\
1101 ((m) >= HOST_BITS_PER_WIDE_INT) \\\n\
1102 ? ~(unsigned HOST_WIDE_INT) 0 \\\n\
1103 : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
1105 for_all_modes (c, m)
1106 if (m->precision != (unsigned int)-1)
1107 tagged_printf ("MODE_MASK (%u)", m->precision, m->name);
1108 else
1109 tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m->bytesize, m->name);
1111 puts ("#undef MODE_MASK");
1112 print_closer ();
1115 static void
1116 emit_mode_inner (void)
1118 int c;
1119 struct mode_data *m;
1121 print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1123 for_all_modes (c, m)
1124 tagged_printf ("%smode",
1125 c != MODE_PARTIAL_INT && m->component
1126 ? m->component->name : void_mode->name,
1127 m->name);
1129 print_closer ();
1132 static void
1133 emit_mode_base_align (void)
1135 int c;
1136 struct mode_data *m;
1138 print_maybe_const_decl ("%sunsigned char",
1139 "mode_base_align", "NUM_MACHINE_MODES",
1140 alignment);
1142 for_all_modes (c, m)
1143 tagged_printf ("%u", m->alignment, m->name);
1145 print_closer ();
1148 static void
1149 emit_class_narrowest_mode (void)
1151 int c;
1153 print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1155 for (c = 0; c < MAX_MODE_CLASS; c++)
1156 /* Bleah, all this to get the comment right for MIN_MODE_INT. */
1157 tagged_printf ("MIN_%s", mode_class_names[c],
1158 modes[c]
1159 ? (modes[c]->precision != 1
1160 ? modes[c]->name
1161 : (modes[c]->next
1162 ? modes[c]->next->name
1163 : void_mode->name))
1164 : void_mode->name);
1166 print_closer ();
1169 static void
1170 emit_real_format_for_mode (void)
1172 struct mode_data *m;
1174 /* The entities pointed to by this table are constant, whether
1175 or not the table itself is constant.
1177 For backward compatibility this table is always writable
1178 (several targets modify it in TARGET_OPTION_OVERRIDE). FIXME:
1179 convert all said targets to use ADJUST_FORMAT instead. */
1180 #if 0
1181 print_maybe_const_decl ("const struct real_format *%s",
1182 "real_format_for_mode",
1183 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1184 format);
1185 #else
1186 print_decl ("struct real_format *\n", "real_format_for_mode",
1187 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1188 "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1189 #endif
1191 /* The beginning of the table is entries for float modes. */
1192 for (m = modes[MODE_FLOAT]; m; m = m->next)
1193 if (!strcmp (m->format, "0"))
1194 tagged_printf ("%s", m->format, m->name);
1195 else
1196 tagged_printf ("&%s", m->format, m->name);
1198 /* The end of the table is entries for decimal float modes. */
1199 for (m = modes[MODE_DECIMAL_FLOAT]; m; m = m->next)
1200 if (!strcmp (m->format, "0"))
1201 tagged_printf ("%s", m->format, m->name);
1202 else
1203 tagged_printf ("&%s", m->format, m->name);
1205 print_closer ();
1208 static void
1209 emit_mode_adjustments (void)
1211 struct mode_adjust *a;
1212 struct mode_data *m;
1214 puts ("\
1215 \nvoid\
1216 \ninit_adjust_machine_modes (void)\
1217 \n{\
1218 \n size_t s ATTRIBUTE_UNUSED;");
1220 /* Size adjustments must be propagated to all containing modes.
1221 A size adjustment forces us to recalculate the alignment too. */
1222 for (a = adj_bytesize; a; a = a->next)
1224 printf ("\n /* %s:%d */\n s = %s;\n",
1225 a->file, a->line, a->adjustment);
1226 printf (" mode_size[%smode] = s;\n", a->mode->name);
1227 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1228 a->mode->name);
1230 for (m = a->mode->contained; m; m = m->next_cont)
1232 switch (m->cl)
1234 case MODE_COMPLEX_INT:
1235 case MODE_COMPLEX_FLOAT:
1236 printf (" mode_size[%smode] = 2*s;\n", m->name);
1237 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1238 m->name);
1239 break;
1241 case MODE_VECTOR_INT:
1242 case MODE_VECTOR_FLOAT:
1243 case MODE_VECTOR_FRACT:
1244 case MODE_VECTOR_UFRACT:
1245 case MODE_VECTOR_ACCUM:
1246 case MODE_VECTOR_UACCUM:
1247 printf (" mode_size[%smode] = %d*s;\n",
1248 m->name, m->ncomponents);
1249 printf (" mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1250 m->name, m->ncomponents, m->ncomponents);
1251 break;
1253 default:
1254 internal_error (
1255 "mode %s is neither vector nor complex but contains %s",
1256 m->name, a->mode->name);
1257 /* NOTREACHED */
1262 /* Alignment adjustments propagate too.
1263 ??? This may not be the right thing for vector modes. */
1264 for (a = adj_alignment; a; a = a->next)
1266 printf ("\n /* %s:%d */\n s = %s;\n",
1267 a->file, a->line, a->adjustment);
1268 printf (" mode_base_align[%smode] = s;\n", a->mode->name);
1270 for (m = a->mode->contained; m; m = m->next_cont)
1272 switch (m->cl)
1274 case MODE_COMPLEX_INT:
1275 case MODE_COMPLEX_FLOAT:
1276 printf (" mode_base_align[%smode] = s;\n", m->name);
1277 break;
1279 case MODE_VECTOR_INT:
1280 case MODE_VECTOR_FLOAT:
1281 case MODE_VECTOR_FRACT:
1282 case MODE_VECTOR_UFRACT:
1283 case MODE_VECTOR_ACCUM:
1284 case MODE_VECTOR_UACCUM:
1285 printf (" mode_base_align[%smode] = %d*s;\n",
1286 m->name, m->ncomponents);
1287 break;
1289 default:
1290 internal_error (
1291 "mode %s is neither vector nor complex but contains %s",
1292 m->name, a->mode->name);
1293 /* NOTREACHED */
1298 /* Ibit adjustments don't have to propagate. */
1299 for (a = adj_ibit; a; a = a->next)
1301 printf ("\n /* %s:%d */\n s = %s;\n",
1302 a->file, a->line, a->adjustment);
1303 printf (" mode_ibit[%smode] = s;\n", a->mode->name);
1306 /* Fbit adjustments don't have to propagate. */
1307 for (a = adj_fbit; a; a = a->next)
1309 printf ("\n /* %s:%d */\n s = %s;\n",
1310 a->file, a->line, a->adjustment);
1311 printf (" mode_fbit[%smode] = s;\n", a->mode->name);
1314 /* Real mode formats don't have to propagate anywhere. */
1315 for (a = adj_format; a; a = a->next)
1316 printf ("\n /* %s:%d */\n REAL_MODE_FORMAT (%smode) = %s;\n",
1317 a->file, a->line, a->mode->name, a->adjustment);
1319 puts ("}");
1322 /* Emit ibit for all modes. */
1324 static void
1325 emit_mode_ibit (void)
1327 int c;
1328 struct mode_data *m;
1330 print_maybe_const_decl ("%sunsigned char",
1331 "mode_ibit", "NUM_MACHINE_MODES",
1332 ibit);
1334 for_all_modes (c, m)
1335 tagged_printf ("%u", m->ibit, m->name);
1337 print_closer ();
1340 /* Emit fbit for all modes. */
1342 static void
1343 emit_mode_fbit (void)
1345 int c;
1346 struct mode_data *m;
1348 print_maybe_const_decl ("%sunsigned char",
1349 "mode_fbit", "NUM_MACHINE_MODES",
1350 fbit);
1352 for_all_modes (c, m)
1353 tagged_printf ("%u", m->fbit, m->name);
1355 print_closer ();
1359 static void
1360 emit_insn_modes_c (void)
1362 emit_insn_modes_c_header ();
1363 emit_mode_name ();
1364 emit_mode_class ();
1365 emit_mode_precision ();
1366 emit_mode_size ();
1367 emit_mode_nunits ();
1368 emit_mode_wider ();
1369 emit_mode_mask ();
1370 emit_mode_inner ();
1371 emit_mode_base_align ();
1372 emit_class_narrowest_mode ();
1373 emit_real_format_for_mode ();
1374 emit_mode_adjustments ();
1375 emit_mode_ibit ();
1376 emit_mode_fbit ();
1379 static void
1380 emit_min_insn_modes_c (void)
1382 emit_min_insn_modes_c_header ();
1383 emit_mode_name ();
1384 emit_mode_class ();
1385 emit_mode_wider ();
1386 emit_class_narrowest_mode ();
1389 /* Master control. */
1391 main (int argc, char **argv)
1393 bool gen_header = false, gen_min = false;
1394 progname = argv[0];
1396 if (argc == 1)
1398 else if (argc == 2 && !strcmp (argv[1], "-h"))
1399 gen_header = true;
1400 else if (argc == 2 && !strcmp (argv[1], "-m"))
1401 gen_min = true;
1402 else
1404 error ("usage: %s [-h|-m] > file", progname);
1405 return FATAL_EXIT_CODE;
1408 modes_by_name = htab_create_alloc (64, hash_mode, eq_mode, 0, xcalloc, free);
1410 create_modes ();
1411 complete_all_modes ();
1413 if (have_error)
1414 return FATAL_EXIT_CODE;
1416 calc_wider_mode ();
1418 if (gen_header)
1419 emit_insn_modes_h ();
1420 else if (gen_min)
1421 emit_min_insn_modes_c ();
1422 else
1423 emit_insn_modes_c ();
1425 if (fflush (stdout) || fclose (stdout))
1426 return FATAL_EXIT_CODE;
1427 return SUCCESS_EXIT_CODE;