Daily bump.
[official-gcc.git] / gcc / genmodes.c
blobf7eaeef2fe609d97502fa89626430250a7ea0835
1 /* Generate the machine mode enumeration and associated tables.
2 Copyright (C) 2003-2017 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"
24 /* enum mode_class is normally defined by machmode.h but we can't
25 include that header here. */
26 #include "mode-classes.def"
28 #define DEF_MODE_CLASS(M) M
29 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
30 #undef DEF_MODE_CLASS
32 /* Text names of mode classes, for output. */
33 #define DEF_MODE_CLASS(M) #M
34 static const char *const mode_class_names[MAX_MODE_CLASS] =
36 MODE_CLASSES
38 #undef DEF_MODE_CLASS
39 #undef MODE_CLASSES
41 #ifdef EXTRA_MODES_FILE
42 # define HAVE_EXTRA_MODES 1
43 #else
44 # define HAVE_EXTRA_MODES 0
45 # define EXTRA_MODES_FILE ""
46 #endif
48 /* Data structure for building up what we know about a mode.
49 They're clustered by mode class. */
50 struct mode_data
52 struct mode_data *next; /* next this class - arbitrary order */
54 const char *name; /* printable mode name -- SI, not SImode */
55 enum mode_class cl; /* this mode class */
56 unsigned int precision; /* size in bits, equiv to TYPE_PRECISION */
57 unsigned int bytesize; /* storage size in addressable units */
58 unsigned int ncomponents; /* number of subunits */
59 unsigned int alignment; /* mode alignment */
60 const char *format; /* floating point format - float modes only */
62 struct mode_data *component; /* mode of components */
63 struct mode_data *wider; /* next wider mode */
65 struct mode_data *contained; /* Pointer to list of modes that have
66 this mode as a component. */
67 struct mode_data *next_cont; /* Next mode in that list. */
69 struct mode_data *complex; /* complex type with mode as component. */
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 */
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;
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, 0,
88 "<unknown>", 0, 0, 0, 0, false, 0
91 static htab_t modes_by_name;
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
98 struct mode_adjust *next;
99 struct mode_data *mode;
100 const char *adjustment;
102 const char *file;
103 unsigned int line;
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;
112 /* Mode class operations. */
113 static enum mode_class
114 complex_class (enum mode_class c)
116 switch (c)
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;
126 static enum mode_class
127 vector_class (enum mode_class cl)
129 switch (cl)
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;
143 /* Utility routines. */
144 static inline struct mode_data *
145 find_mode (const char *name)
147 struct mode_data key;
149 key.name = name;
150 return (struct mode_data *) htab_find (modes_by_name, &key);
153 static struct mode_data *
154 new_mode (enum mode_class cl, const char *name,
155 const char *file, unsigned int line)
157 struct mode_data *m;
158 static unsigned int count = 0;
160 m = find_mode (name);
161 if (m)
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;
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++;
178 m->next = modes[cl];
179 modes[cl] = m;
180 n_modes[cl]++;
182 *htab_find_slot (modes_by_name, m, INSERT) = m;
184 return m;
187 static hashval_t
188 hash_mode (const void *p)
190 const struct mode_data *m = (const struct mode_data *)p;
191 return htab_hash_string (m->name);
194 static int
195 eq_mode (const void *p, const void *q)
197 const struct mode_data *a = (const struct mode_data *)p;
198 const struct mode_data *b = (const struct mode_data *)q;
200 return !strcmp (a->name, b->name);
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)
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)
215 struct mode_data *mode = find_mode (name);
216 struct mode_adjust *a;
218 file = trim_filename (file);
220 if (!mode)
222 error ("%s:%d: no mode \"%s\"", file, line, name);
223 return;
226 if (required_class_from != MODE_RANDOM
227 && (mode->cl < required_class_from || mode->cl > required_class_to))
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;
235 for (a = *category; a; a = a->next)
236 if (a->mode == mode)
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;
244 a = XNEW (struct mode_adjust);
245 a->mode = mode;
246 a->adjustment = adjustment;
247 a->file = file;
248 a->line = line;
250 a->next = *category;
251 *category = a;
254 /* Diagnose failure to meet expectations in a partially filled out
255 mode structure. */
256 enum requirement { SET, UNSET, OPTIONAL };
258 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
259 switch (req) \
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; \
273 } while (0)
275 #define validate_field(M, F) \
276 validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
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)
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);
292 #undef validate_field
293 #undef validate_field_
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)
300 unsigned int alignment;
302 if (!m->name)
304 error ("%s:%d: mode with no name", m->file, m->line);
305 return;
307 if (m->cl == MAX_MODE_CLASS)
309 error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
310 return;
313 switch (m->cl)
315 case MODE_RANDOM:
316 /* Nothing more need be said. */
317 if (!strcmp (m->name, "VOID"))
318 void_mode = m;
320 validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
322 m->precision = 0;
323 m->bytesize = 0;
324 m->ncomponents = 0;
325 m->component = 0;
326 break;
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);
333 m->bytesize = 4;
334 m->ncomponents = 1;
335 m->component = 0;
336 break;
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);
353 m->ncomponents = 1;
354 m->component = 0;
355 break;
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);
363 m->bytesize = m->component->bytesize;
365 m->ncomponents = 1;
366 break;
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;
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;
391 default:
392 gcc_unreachable ();
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;
403 m->alignment = alignment & (~alignment + 1);
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)
409 m->next_cont = m->component->contained;
410 m->component->contained = m;
414 static void
415 complete_all_modes (void)
417 struct mode_data *m;
418 int cl;
420 for_all_modes (cl, m)
421 complete_mode (m);
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)
430 struct mode_data *m;
431 struct mode_data *c;
432 enum mode_class cclass = complex_class (cl);
434 if (cclass == MODE_RANDOM)
435 return;
437 for (m = modes[cl]; m; m = m->next)
439 char *p, *buf;
440 size_t m_len;
442 /* Skip BImode. FIXME: BImode probably shouldn't be MODE_INT. */
443 if (m->precision == 1)
444 continue;
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);
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)
456 memcpy (buf, m->name, m_len + 1);
457 p = strchr (buf, 'F');
458 if (p == 0 && strchr (buf, 'D') == 0)
460 error ("%s:%d: float mode \"%s\" has no 'F' or 'D'",
461 m->file, m->line, m->name);
462 free (buf);
463 continue;
466 if (p != 0)
467 *p = 'C';
468 else
470 buf[0] = 'C';
471 memcpy (buf + 1, m->name, m_len + 1);
474 c = new_mode (cclass, buf, file, line);
475 c->component = m;
476 m->complex = c;
480 /* For all modes in class CL, construct vector modes of width
481 WIDTH, having as many components as necessary. */
482 #define VECTOR_MODES(C, W) make_vector_modes (MODE_##C, W, __FILE__, __LINE__)
483 static void ATTRIBUTE_UNUSED
484 make_vector_modes (enum mode_class cl, unsigned int width,
485 const char *file, unsigned int line)
487 struct mode_data *m;
488 struct mode_data *v;
489 /* Big enough for a 32-bit UINT_MAX plus the text. */
490 char buf[12];
491 unsigned int ncomponents;
492 enum mode_class vclass = vector_class (cl);
494 if (vclass == MODE_RANDOM)
495 return;
497 for (m = modes[cl]; m; m = m->next)
499 /* Do not construct vector modes with only one element, or
500 vector modes where the element size doesn't divide the full
501 size evenly. */
502 ncomponents = width / m->bytesize;
503 if (ncomponents < 2)
504 continue;
505 if (width % m->bytesize)
506 continue;
508 /* Skip QFmode and BImode. FIXME: this special case should
509 not be necessary. */
510 if (cl == MODE_FLOAT && m->bytesize == 1)
511 continue;
512 if (cl == MODE_INT && m->precision == 1)
513 continue;
515 if ((size_t)snprintf (buf, sizeof buf, "V%u%s", ncomponents, m->name)
516 >= sizeof buf)
518 error ("%s:%d: mode name \"%s\" is too long",
519 m->file, m->line, m->name);
520 continue;
523 v = new_mode (vclass, xstrdup (buf), file, line);
524 v->component = m;
525 v->ncomponents = ncomponents;
529 /* Input. */
531 #define _SPECIAL_MODE(C, N) \
532 make_special_mode (MODE_##C, #N, __FILE__, __LINE__)
533 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
534 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
536 static void
537 make_special_mode (enum mode_class cl, const char *name,
538 const char *file, unsigned int line)
540 new_mode (cl, name, file, line);
543 #define POINTER_BOUNDS_MODE(N, Y) \
544 make_pointer_bounds_mode (#N, Y, __FILE__, __LINE__)
546 static void ATTRIBUTE_UNUSED
547 make_pointer_bounds_mode (const char *name,
548 unsigned int bytesize,
549 const char *file, unsigned int line)
551 struct mode_data *m = new_mode (MODE_POINTER_BOUNDS, name, file, line);
552 m->bytesize = bytesize;
556 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
557 #define FRACTIONAL_INT_MODE(N, B, Y) \
558 make_int_mode (#N, B, Y, __FILE__, __LINE__)
560 static void
561 make_int_mode (const char *name,
562 unsigned int precision, unsigned int bytesize,
563 const char *file, unsigned int line)
565 struct mode_data *m = new_mode (MODE_INT, name, file, line);
566 m->bytesize = bytesize;
567 m->precision = precision;
570 #define FRACT_MODE(N, Y, F) \
571 make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
573 #define UFRACT_MODE(N, Y, F) \
574 make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
576 #define ACCUM_MODE(N, Y, I, F) \
577 make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
579 #define UACCUM_MODE(N, Y, I, F) \
580 make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
582 /* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
583 FILE, and LINE. */
585 static void
586 make_fixed_point_mode (enum mode_class cl,
587 const char *name,
588 unsigned int bytesize,
589 unsigned int ibit,
590 unsigned int fbit,
591 const char *file, unsigned int line)
593 struct mode_data *m = new_mode (cl, name, file, line);
594 m->bytesize = bytesize;
595 m->ibit = ibit;
596 m->fbit = fbit;
599 #define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
600 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
601 make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
603 static void
604 make_float_mode (const char *name,
605 unsigned int precision, unsigned int bytesize,
606 const char *format,
607 const char *file, unsigned int line)
609 struct mode_data *m = new_mode (MODE_FLOAT, name, file, line);
610 m->bytesize = bytesize;
611 m->precision = precision;
612 m->format = format;
615 #define DECIMAL_FLOAT_MODE(N, Y, F) \
616 FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
617 #define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F) \
618 make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
620 static void
621 make_decimal_float_mode (const char *name,
622 unsigned int precision, unsigned int bytesize,
623 const char *format,
624 const char *file, unsigned int line)
626 struct mode_data *m = new_mode (MODE_DECIMAL_FLOAT, name, file, line);
627 m->bytesize = bytesize;
628 m->precision = precision;
629 m->format = format;
632 #define RESET_FLOAT_FORMAT(N, F) \
633 reset_float_format (#N, #F, __FILE__, __LINE__)
634 static void ATTRIBUTE_UNUSED
635 reset_float_format (const char *name, const char *format,
636 const char *file, unsigned int line)
638 struct mode_data *m = find_mode (name);
639 if (!m)
641 error ("%s:%d: no mode \"%s\"", file, line, name);
642 return;
644 if (m->cl != MODE_FLOAT && m->cl != MODE_DECIMAL_FLOAT)
646 error ("%s:%d: mode \"%s\" is not a FLOAT class", file, line, name);
647 return;
649 m->format = format;
652 /* __intN support. */
653 #define INT_N(M,PREC) \
654 make_int_n (#M, PREC, __FILE__, __LINE__)
655 static void ATTRIBUTE_UNUSED
656 make_int_n (const char *m, int bitsize,
657 const char *file, unsigned int line)
659 struct mode_data *component = find_mode (m);
660 if (!component)
662 error ("%s:%d: no mode \"%s\"", file, line, m);
663 return;
665 if (component->cl != MODE_INT
666 && component->cl != MODE_PARTIAL_INT)
668 error ("%s:%d: mode \"%s\" is not class INT or PARTIAL_INT", file, line, m);
669 return;
671 if (component->int_n != 0)
673 error ("%s:%d: mode \"%s\" already has an intN", file, line, m);
674 return;
677 component->int_n = bitsize;
680 /* Partial integer modes are specified by relation to a full integer
681 mode. */
682 #define PARTIAL_INT_MODE(M,PREC,NAME) \
683 make_partial_integer_mode (#M, #NAME, PREC, __FILE__, __LINE__)
684 static void ATTRIBUTE_UNUSED
685 make_partial_integer_mode (const char *base, const char *name,
686 unsigned int precision,
687 const char *file, unsigned int line)
689 struct mode_data *m;
690 struct mode_data *component = find_mode (base);
691 if (!component)
693 error ("%s:%d: no mode \"%s\"", file, line, name);
694 return;
696 if (component->cl != MODE_INT)
698 error ("%s:%d: mode \"%s\" is not class INT", file, line, name);
699 return;
702 m = new_mode (MODE_PARTIAL_INT, name, file, line);
703 m->precision = precision;
704 m->component = component;
707 /* A single vector mode can be specified by naming its component
708 mode and the number of components. */
709 #define VECTOR_MODE(C, M, N) \
710 make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
711 static void ATTRIBUTE_UNUSED
712 make_vector_mode (enum mode_class bclass,
713 const char *base,
714 unsigned int ncomponents,
715 const char *file, unsigned int line)
717 struct mode_data *v;
718 enum mode_class vclass = vector_class (bclass);
719 struct mode_data *component = find_mode (base);
720 char namebuf[16];
722 if (vclass == MODE_RANDOM)
723 return;
724 if (component == 0)
726 error ("%s:%d: no mode \"%s\"", file, line, base);
727 return;
729 if (component->cl != bclass
730 && (component->cl != MODE_PARTIAL_INT
731 || bclass != MODE_INT))
733 error ("%s:%d: mode \"%s\" is not class %s",
734 file, line, base, mode_class_names[bclass] + 5);
735 return;
738 if ((size_t)snprintf (namebuf, sizeof namebuf, "V%u%s",
739 ncomponents, base) >= sizeof namebuf)
741 error ("%s:%d: mode name \"%s\" is too long",
742 file, line, base);
743 return;
746 v = new_mode (vclass, xstrdup (namebuf), file, line);
747 v->ncomponents = ncomponents;
748 v->component = component;
751 /* Adjustability. */
752 #define _ADD_ADJUST(A, M, X, C1, C2) \
753 new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
755 #define ADJUST_BYTESIZE(M, X) _ADD_ADJUST (bytesize, M, X, RANDOM, RANDOM)
756 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST (alignment, M, X, RANDOM, RANDOM)
757 #define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST (format, M, X, FLOAT, FLOAT)
758 #define ADJUST_IBIT(M, X) _ADD_ADJUST (ibit, M, X, ACCUM, UACCUM)
759 #define ADJUST_FBIT(M, X) _ADD_ADJUST (fbit, M, X, FRACT, UACCUM)
761 static int bits_per_unit;
762 static int max_bitsize_mode_any_int;
764 static void
765 create_modes (void)
767 #include "machmode.def"
769 /* So put the default value unless the target needs a non standard
770 value. */
771 #ifdef BITS_PER_UNIT
772 bits_per_unit = BITS_PER_UNIT;
773 #else
774 bits_per_unit = 8;
775 #endif
777 #ifdef MAX_BITSIZE_MODE_ANY_INT
778 max_bitsize_mode_any_int = MAX_BITSIZE_MODE_ANY_INT;
779 #else
780 max_bitsize_mode_any_int = 0;
781 #endif
784 /* Processing. */
786 /* Sort a list of modes into the order needed for the WIDER field:
787 major sort by precision, minor sort by component precision.
789 For instance:
790 QI < HI < SI < DI < TI
791 V4QI < V2HI < V8QI < V4HI < V2SI.
793 If the precision is not set, sort by the bytesize. A mode with
794 precision set gets sorted before a mode without precision set, if
795 they have the same bytesize; this is the right thing because
796 the precision must always be smaller than the bytesize * BITS_PER_UNIT.
797 We don't have to do anything special to get this done -- an unset
798 precision shows up as (unsigned int)-1, i.e. UINT_MAX. */
799 static int
800 cmp_modes (const void *a, const void *b)
802 const struct mode_data *const m = *(const struct mode_data *const*)a;
803 const struct mode_data *const n = *(const struct mode_data *const*)b;
805 if (m->bytesize > n->bytesize)
806 return 1;
807 else if (m->bytesize < n->bytesize)
808 return -1;
810 if (m->precision > n->precision)
811 return 1;
812 else if (m->precision < n->precision)
813 return -1;
815 if (!m->component && !n->component)
817 if (m->counter < n->counter)
818 return -1;
819 else
820 return 1;
823 if (m->component->bytesize > n->component->bytesize)
824 return 1;
825 else if (m->component->bytesize < n->component->bytesize)
826 return -1;
828 if (m->component->precision > n->component->precision)
829 return 1;
830 else if (m->component->precision < n->component->precision)
831 return -1;
833 if (m->counter < n->counter)
834 return -1;
835 else
836 return 1;
839 static void
840 calc_wider_mode (void)
842 int c;
843 struct mode_data *m;
844 struct mode_data **sortbuf;
845 unsigned int max_n_modes = 0;
846 unsigned int i, j;
848 for (c = 0; c < MAX_MODE_CLASS; c++)
849 max_n_modes = MAX (max_n_modes, n_modes[c]);
851 /* Allocate max_n_modes + 1 entries to leave room for the extra null
852 pointer assigned after the qsort call below. */
853 sortbuf = XALLOCAVEC (struct mode_data *, max_n_modes + 1);
855 for (c = 0; c < MAX_MODE_CLASS; c++)
857 /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
858 However, we want these in textual order, and we have
859 precisely the reverse. */
860 if (c == MODE_RANDOM || c == MODE_CC)
862 struct mode_data *prev, *next;
864 for (prev = 0, m = modes[c]; m; m = next)
866 m->wider = void_mode;
868 /* this is nreverse */
869 next = m->next;
870 m->next = prev;
871 prev = m;
873 modes[c] = prev;
875 else
877 if (!modes[c])
878 continue;
880 for (i = 0, m = modes[c]; m; i++, m = m->next)
881 sortbuf[i] = m;
883 qsort (sortbuf, i, sizeof (struct mode_data *), cmp_modes);
885 sortbuf[i] = 0;
886 for (j = 0; j < i; j++)
888 sortbuf[j]->next = sortbuf[j + 1];
889 if (c == MODE_PARTIAL_INT)
890 sortbuf[j]->wider = sortbuf[j]->component;
891 else
892 sortbuf[j]->wider = sortbuf[j]->next;
895 modes[c] = sortbuf[0];
900 /* Output routines. */
902 #define tagged_printf(FMT, ARG, TAG) do { \
903 int count_ = printf (" " FMT ",", ARG); \
904 printf ("%*s/* %s */\n", 27 - count_, "", TAG); \
905 } while (0)
907 #define print_decl(TYPE, NAME, ASIZE) \
908 puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
910 #define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY) \
911 printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n", \
912 adj_##CATEGORY ? "" : "const ")
914 #define print_closer() puts ("};")
916 /* Compute the max bitsize of some of the classes of integers. It may
917 be that there are needs for the other integer classes, and this
918 code is easy to extend. */
919 static void
920 emit_max_int (void)
922 unsigned int max, mmax;
923 struct mode_data *i;
924 int j;
926 puts ("");
928 printf ("#define BITS_PER_UNIT (%d)\n", bits_per_unit);
930 if (max_bitsize_mode_any_int == 0)
932 for (max = 1, i = modes[MODE_INT]; i; i = i->next)
933 if (max < i->bytesize)
934 max = i->bytesize;
935 mmax = max;
936 for (max = 1, i = modes[MODE_PARTIAL_INT]; i; i = i->next)
937 if (max < i->bytesize)
938 max = i->bytesize;
939 if (max > mmax)
940 mmax = max;
941 printf ("#define MAX_BITSIZE_MODE_ANY_INT (%d*BITS_PER_UNIT)\n", mmax);
943 else
944 printf ("#define MAX_BITSIZE_MODE_ANY_INT %d\n", max_bitsize_mode_any_int);
946 mmax = 0;
947 for (j = 0; j < MAX_MODE_CLASS; j++)
948 for (i = modes[j]; i; i = i->next)
949 if (mmax < i->bytesize)
950 mmax = i->bytesize;
951 printf ("#define MAX_BITSIZE_MODE_ANY_MODE (%d*BITS_PER_UNIT)\n", mmax);
954 /* Emit mode_size_inline routine into insn-modes.h header. */
955 static void
956 emit_mode_size_inline (void)
958 int c;
959 struct mode_adjust *a;
960 struct mode_data *m;
962 /* Size adjustments must be propagated to all containing modes. */
963 for (a = adj_bytesize; a; a = a->next)
965 a->mode->need_bytesize_adj = true;
966 for (m = a->mode->contained; m; m = m->next_cont)
967 m->need_bytesize_adj = true;
970 printf ("\
971 #ifdef __cplusplus\n\
972 inline __attribute__((__always_inline__))\n\
973 #else\n\
974 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
975 #endif\n\
976 unsigned short\n\
977 mode_size_inline (machine_mode mode)\n\
978 {\n\
979 extern %sunsigned short mode_size[NUM_MACHINE_MODES];\n\
980 gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\
981 switch (mode)\n\
982 {\n", adj_bytesize ? "" : "const ");
984 for_all_modes (c, m)
985 if (!m->need_bytesize_adj)
986 printf (" case %smode: return %u;\n", m->name, m->bytesize);
988 puts ("\
989 default: return mode_size[mode];\n\
990 }\n\
991 }\n");
994 /* Emit mode_nunits_inline routine into insn-modes.h header. */
995 static void
996 emit_mode_nunits_inline (void)
998 int c;
999 struct mode_data *m;
1001 puts ("\
1002 #ifdef __cplusplus\n\
1003 inline __attribute__((__always_inline__))\n\
1004 #else\n\
1005 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1006 #endif\n\
1007 unsigned char\n\
1008 mode_nunits_inline (machine_mode mode)\n\
1009 {\n\
1010 extern const unsigned char mode_nunits[NUM_MACHINE_MODES];\n\
1011 gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\
1012 switch (mode)\n\
1013 {");
1015 for_all_modes (c, m)
1016 printf (" case %smode: return %u;\n", m->name, m->ncomponents);
1018 puts ("\
1019 default: return mode_nunits[mode];\n\
1020 }\n\
1021 }\n");
1024 /* Emit mode_inner_inline routine into insn-modes.h header. */
1025 static void
1026 emit_mode_inner_inline (void)
1028 int c;
1029 struct mode_data *m;
1031 puts ("\
1032 #ifdef __cplusplus\n\
1033 inline __attribute__((__always_inline__))\n\
1034 #else\n\
1035 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1036 #endif\n\
1037 unsigned char\n\
1038 mode_inner_inline (machine_mode mode)\n\
1039 {\n\
1040 extern const unsigned char mode_inner[NUM_MACHINE_MODES];\n\
1041 gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\
1042 switch (mode)\n\
1043 {");
1045 for_all_modes (c, m)
1046 printf (" case %smode: return %smode;\n", m->name,
1047 c != MODE_PARTIAL_INT && m->component
1048 ? m->component->name : m->name);
1050 puts ("\
1051 default: return mode_inner[mode];\n\
1052 }\n\
1053 }\n");
1056 /* Emit mode_unit_size_inline routine into insn-modes.h header. */
1057 static void
1058 emit_mode_unit_size_inline (void)
1060 int c;
1061 struct mode_data *m;
1063 puts ("\
1064 #ifdef __cplusplus\n\
1065 inline __attribute__((__always_inline__))\n\
1066 #else\n\
1067 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1068 #endif\n\
1069 unsigned char\n\
1070 mode_unit_size_inline (machine_mode mode)\n\
1071 {\n\
1072 extern CONST_MODE_UNIT_SIZE unsigned char mode_unit_size[NUM_MACHINE_MODES];\
1074 gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\
1075 switch (mode)\n\
1076 {");
1078 for_all_modes (c, m)
1080 const char *name = m->name;
1081 struct mode_data *m2 = m;
1082 if (c != MODE_PARTIAL_INT && m2->component)
1083 m2 = m2->component;
1084 if (!m2->need_bytesize_adj)
1085 printf (" case %smode: return %u;\n", name, m2->bytesize);
1088 puts ("\
1089 default: return mode_unit_size[mode];\n\
1090 }\n\
1091 }\n");
1094 /* Emit mode_unit_precision_inline routine into insn-modes.h header. */
1095 static void
1096 emit_mode_unit_precision_inline (void)
1098 int c;
1099 struct mode_data *m;
1101 puts ("\
1102 #ifdef __cplusplus\n\
1103 inline __attribute__((__always_inline__))\n\
1104 #else\n\
1105 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1106 #endif\n\
1107 unsigned short\n\
1108 mode_unit_precision_inline (machine_mode mode)\n\
1109 {\n\
1110 extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];\n\
1111 gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\
1112 switch (mode)\n\
1113 {");
1115 for_all_modes (c, m)
1117 struct mode_data *m2
1118 = (c != MODE_PARTIAL_INT && m->component) ? m->component : m;
1119 if (m2->precision != (unsigned int)-1)
1120 printf (" case %smode: return %u;\n", m->name, m2->precision);
1121 else
1122 printf (" case %smode: return %u*BITS_PER_UNIT;\n",
1123 m->name, m2->bytesize);
1126 puts ("\
1127 default: return mode_unit_precision[mode];\n\
1128 }\n\
1129 }\n");
1132 static void
1133 emit_insn_modes_h (void)
1135 int c;
1136 struct mode_data *m, *first, *last;
1137 int n_int_n_ents = 0;
1139 printf ("/* Generated automatically from machmode.def%s%s\n",
1140 HAVE_EXTRA_MODES ? " and " : "",
1141 EXTRA_MODES_FILE);
1143 puts ("\
1144 by genmodes. */\n\
1146 #ifndef GCC_INSN_MODES_H\n\
1147 #define GCC_INSN_MODES_H\n\
1149 enum machine_mode\n{");
1151 for (c = 0; c < MAX_MODE_CLASS; c++)
1152 for (m = modes[c]; m; m = m->next)
1154 int count_ = printf (" %smode,", m->name);
1155 printf ("%*s/* %s:%d */\n", 27 - count_, "",
1156 trim_filename (m->file), m->line);
1157 printf ("#define HAVE_%smode\n", m->name);
1160 puts (" MAX_MACHINE_MODE,\n");
1162 for (c = 0; c < MAX_MODE_CLASS; c++)
1164 first = modes[c];
1165 last = 0;
1166 for (m = first; m; last = m, m = m->next)
1169 /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
1170 end will try to use it for bitfields in structures and the
1171 like, which we do not want. Only the target md file should
1172 generate BImode widgets. */
1173 if (first && first->precision == 1 && c == MODE_INT)
1174 first = first->next;
1176 if (first && last)
1177 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
1178 mode_class_names[c], first->name,
1179 mode_class_names[c], last->name);
1180 else
1181 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
1182 mode_class_names[c], void_mode->name,
1183 mode_class_names[c], void_mode->name);
1186 puts ("\
1187 NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
1188 };\n");
1190 /* I can't think of a better idea, can you? */
1191 printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize ? "" : " const");
1192 printf ("#define CONST_MODE_UNIT_SIZE%s\n", adj_bytesize ? "" : " const");
1193 printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment ? "" : " const");
1194 #if 0 /* disabled for backward compatibility, temporary */
1195 printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format ? "" :" const");
1196 #endif
1197 printf ("#define CONST_MODE_IBIT%s\n", adj_ibit ? "" : " const");
1198 printf ("#define CONST_MODE_FBIT%s\n", adj_fbit ? "" : " const");
1199 emit_max_int ();
1201 for_all_modes (c, m)
1202 if (m->int_n)
1203 n_int_n_ents ++;
1205 printf ("#define NUM_INT_N_ENTS %d\n", n_int_n_ents);
1207 puts ("\
1209 #endif /* insn-modes.h */");
1212 static void
1213 emit_insn_modes_inline_h (void)
1215 printf ("/* Generated automatically from machmode.def%s%s\n",
1216 HAVE_EXTRA_MODES ? " and " : "",
1217 EXTRA_MODES_FILE);
1219 puts ("\
1220 by genmodes. */\n\
1222 #ifndef GCC_INSN_MODES_INLINE_H\n\
1223 #define GCC_INSN_MODES_INLINE_H");
1225 puts ("\n#if !defined (USED_FOR_TARGET) && GCC_VERSION >= 4001\n");
1226 emit_mode_size_inline ();
1227 emit_mode_nunits_inline ();
1228 emit_mode_inner_inline ();
1229 emit_mode_unit_size_inline ();
1230 emit_mode_unit_precision_inline ();
1231 puts ("#endif /* GCC_VERSION >= 4001 */");
1233 puts ("\
1235 #endif /* insn-modes-inline.h */");
1238 static void
1239 emit_insn_modes_c_header (void)
1241 printf ("/* Generated automatically from machmode.def%s%s\n",
1242 HAVE_EXTRA_MODES ? " and " : "",
1243 EXTRA_MODES_FILE);
1245 puts ("\
1246 by genmodes. */\n\
1248 #include \"config.h\"\n\
1249 #include \"system.h\"\n\
1250 #include \"coretypes.h\"\n\
1251 #include \"tm.h\"\n\
1252 #include \"real.h\"");
1255 static void
1256 emit_min_insn_modes_c_header (void)
1258 printf ("/* Generated automatically from machmode.def%s%s\n",
1259 HAVE_EXTRA_MODES ? " and " : "",
1260 EXTRA_MODES_FILE);
1262 puts ("\
1263 by genmodes. */\n\
1265 #include \"bconfig.h\"\n\
1266 #include \"system.h\"\n\
1267 #include \"coretypes.h\"");
1270 static void
1271 emit_mode_name (void)
1273 int c;
1274 struct mode_data *m;
1276 print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
1278 for_all_modes (c, m)
1279 printf (" \"%s\",\n", m->name);
1281 print_closer ();
1284 static void
1285 emit_mode_class (void)
1287 int c;
1288 struct mode_data *m;
1290 print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
1292 for_all_modes (c, m)
1293 tagged_printf ("%s", mode_class_names[m->cl], m->name);
1295 print_closer ();
1298 static void
1299 emit_mode_precision (void)
1301 int c;
1302 struct mode_data *m;
1304 print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
1306 for_all_modes (c, m)
1307 if (m->precision != (unsigned int)-1)
1308 tagged_printf ("%u", m->precision, m->name);
1309 else
1310 tagged_printf ("%u*BITS_PER_UNIT", m->bytesize, m->name);
1312 print_closer ();
1315 static void
1316 emit_mode_size (void)
1318 int c;
1319 struct mode_data *m;
1321 print_maybe_const_decl ("%sunsigned short", "mode_size",
1322 "NUM_MACHINE_MODES", bytesize);
1324 for_all_modes (c, m)
1325 tagged_printf ("%u", m->bytesize, m->name);
1327 print_closer ();
1330 static void
1331 emit_mode_nunits (void)
1333 int c;
1334 struct mode_data *m;
1336 print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1338 for_all_modes (c, m)
1339 tagged_printf ("%u", m->ncomponents, m->name);
1341 print_closer ();
1344 static void
1345 emit_mode_wider (void)
1347 int c;
1348 struct mode_data *m;
1350 print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1352 for_all_modes (c, m)
1353 tagged_printf ("%smode",
1354 m->wider ? m->wider->name : void_mode->name,
1355 m->name);
1357 print_closer ();
1358 print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1360 for_all_modes (c, m)
1362 struct mode_data * m2;
1364 for (m2 = m;
1365 m2 && m2 != void_mode;
1366 m2 = m2->wider)
1368 if (m2->bytesize < 2 * m->bytesize)
1369 continue;
1370 if (m->precision != (unsigned int) -1)
1372 if (m2->precision != 2 * m->precision)
1373 continue;
1375 else
1377 if (m2->precision != (unsigned int) -1)
1378 continue;
1381 /* For vectors we want twice the number of components,
1382 with the same element type. */
1383 if (m->cl == MODE_VECTOR_INT
1384 || m->cl == MODE_VECTOR_FLOAT
1385 || m->cl == MODE_VECTOR_FRACT
1386 || m->cl == MODE_VECTOR_UFRACT
1387 || m->cl == MODE_VECTOR_ACCUM
1388 || m->cl == MODE_VECTOR_UACCUM)
1390 if (m2->ncomponents != 2 * m->ncomponents)
1391 continue;
1392 if (m->component != m2->component)
1393 continue;
1396 break;
1398 if (m2 == void_mode)
1399 m2 = 0;
1400 tagged_printf ("%smode",
1401 m2 ? m2->name : void_mode->name,
1402 m->name);
1405 print_closer ();
1408 static void
1409 emit_mode_complex (void)
1411 int c;
1412 struct mode_data *m;
1414 print_decl ("unsigned char", "mode_complex", "NUM_MACHINE_MODES");
1416 for_all_modes (c, m)
1417 tagged_printf ("%smode",
1418 m->complex ? m->complex->name : void_mode->name,
1419 m->name);
1421 print_closer ();
1424 static void
1425 emit_mode_mask (void)
1427 int c;
1428 struct mode_data *m;
1430 print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1431 "NUM_MACHINE_MODES");
1432 puts ("\
1433 #define MODE_MASK(m) \\\n\
1434 ((m) >= HOST_BITS_PER_WIDE_INT) \\\n\
1435 ? HOST_WIDE_INT_M1U \\\n\
1436 : (HOST_WIDE_INT_1U << (m)) - 1\n");
1438 for_all_modes (c, m)
1439 if (m->precision != (unsigned int)-1)
1440 tagged_printf ("MODE_MASK (%u)", m->precision, m->name);
1441 else
1442 tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m->bytesize, m->name);
1444 puts ("#undef MODE_MASK");
1445 print_closer ();
1448 static void
1449 emit_mode_inner (void)
1451 int c;
1452 struct mode_data *m;
1454 print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1456 for_all_modes (c, m)
1457 tagged_printf ("%smode",
1458 c != MODE_PARTIAL_INT && m->component
1459 ? m->component->name : m->name,
1460 m->name);
1462 print_closer ();
1465 /* Emit mode_unit_size array into insn-modes.c file. */
1466 static void
1467 emit_mode_unit_size (void)
1469 int c;
1470 struct mode_data *m;
1472 print_maybe_const_decl ("%sunsigned char", "mode_unit_size",
1473 "NUM_MACHINE_MODES", bytesize);
1475 for_all_modes (c, m)
1476 tagged_printf ("%u",
1477 c != MODE_PARTIAL_INT && m->component
1478 ? m->component->bytesize : m->bytesize, m->name);
1480 print_closer ();
1483 /* Emit mode_unit_precision array into insn-modes.c file. */
1484 static void
1485 emit_mode_unit_precision (void)
1487 int c;
1488 struct mode_data *m;
1490 print_decl ("unsigned short", "mode_unit_precision", "NUM_MACHINE_MODES");
1492 for_all_modes (c, m)
1494 struct mode_data *m2 = (c != MODE_PARTIAL_INT && m->component) ?
1495 m->component : m;
1496 if (m2->precision != (unsigned int)-1)
1497 tagged_printf ("%u", m2->precision, m->name);
1498 else
1499 tagged_printf ("%u*BITS_PER_UNIT", m2->bytesize, m->name);
1502 print_closer ();
1506 static void
1507 emit_mode_base_align (void)
1509 int c;
1510 struct mode_data *m;
1512 print_maybe_const_decl ("%sunsigned short",
1513 "mode_base_align", "NUM_MACHINE_MODES",
1514 alignment);
1516 for_all_modes (c, m)
1517 tagged_printf ("%u", m->alignment, m->name);
1519 print_closer ();
1522 static void
1523 emit_class_narrowest_mode (void)
1525 int c;
1527 print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1529 for (c = 0; c < MAX_MODE_CLASS; c++)
1530 /* Bleah, all this to get the comment right for MIN_MODE_INT. */
1531 tagged_printf ("MIN_%s", mode_class_names[c],
1532 modes[c]
1533 ? ((c != MODE_INT || modes[c]->precision != 1)
1534 ? modes[c]->name
1535 : (modes[c]->next
1536 ? modes[c]->next->name
1537 : void_mode->name))
1538 : void_mode->name);
1540 print_closer ();
1543 static void
1544 emit_real_format_for_mode (void)
1546 struct mode_data *m;
1548 /* The entities pointed to by this table are constant, whether
1549 or not the table itself is constant.
1551 For backward compatibility this table is always writable
1552 (several targets modify it in TARGET_OPTION_OVERRIDE). FIXME:
1553 convert all said targets to use ADJUST_FORMAT instead. */
1554 #if 0
1555 print_maybe_const_decl ("const struct real_format *%s",
1556 "real_format_for_mode",
1557 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1558 format);
1559 #else
1560 print_decl ("struct real_format *\n", "real_format_for_mode",
1561 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1562 "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1563 #endif
1565 /* The beginning of the table is entries for float modes. */
1566 for (m = modes[MODE_FLOAT]; m; m = m->next)
1567 if (!strcmp (m->format, "0"))
1568 tagged_printf ("%s", m->format, m->name);
1569 else
1570 tagged_printf ("&%s", m->format, m->name);
1572 /* The end of the table is entries for decimal float modes. */
1573 for (m = modes[MODE_DECIMAL_FLOAT]; m; m = m->next)
1574 if (!strcmp (m->format, "0"))
1575 tagged_printf ("%s", m->format, m->name);
1576 else
1577 tagged_printf ("&%s", m->format, m->name);
1579 print_closer ();
1582 static void
1583 emit_mode_adjustments (void)
1585 struct mode_adjust *a;
1586 struct mode_data *m;
1588 puts ("\
1589 \nvoid\
1590 \ninit_adjust_machine_modes (void)\
1591 \n{\
1592 \n size_t s ATTRIBUTE_UNUSED;");
1594 /* Size adjustments must be propagated to all containing modes.
1595 A size adjustment forces us to recalculate the alignment too. */
1596 for (a = adj_bytesize; a; a = a->next)
1598 printf ("\n /* %s:%d */\n s = %s;\n",
1599 a->file, a->line, a->adjustment);
1600 printf (" mode_size[%smode] = s;\n", a->mode->name);
1601 printf (" mode_unit_size[%smode] = s;\n", a->mode->name);
1602 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1603 a->mode->name);
1605 for (m = a->mode->contained; m; m = m->next_cont)
1607 switch (m->cl)
1609 case MODE_COMPLEX_INT:
1610 case MODE_COMPLEX_FLOAT:
1611 printf (" mode_size[%smode] = 2*s;\n", m->name);
1612 printf (" mode_unit_size[%smode] = s;\n", m->name);
1613 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1614 m->name);
1615 break;
1617 case MODE_VECTOR_INT:
1618 case MODE_VECTOR_FLOAT:
1619 case MODE_VECTOR_FRACT:
1620 case MODE_VECTOR_UFRACT:
1621 case MODE_VECTOR_ACCUM:
1622 case MODE_VECTOR_UACCUM:
1623 printf (" mode_size[%smode] = %d*s;\n",
1624 m->name, m->ncomponents);
1625 printf (" mode_unit_size[%smode] = s;\n", m->name);
1626 printf (" mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1627 m->name, m->ncomponents, m->ncomponents);
1628 break;
1630 default:
1631 internal_error (
1632 "mode %s is neither vector nor complex but contains %s",
1633 m->name, a->mode->name);
1634 /* NOTREACHED */
1639 /* Alignment adjustments propagate too.
1640 ??? This may not be the right thing for vector modes. */
1641 for (a = adj_alignment; a; a = a->next)
1643 printf ("\n /* %s:%d */\n s = %s;\n",
1644 a->file, a->line, a->adjustment);
1645 printf (" mode_base_align[%smode] = s;\n", a->mode->name);
1647 for (m = a->mode->contained; m; m = m->next_cont)
1649 switch (m->cl)
1651 case MODE_COMPLEX_INT:
1652 case MODE_COMPLEX_FLOAT:
1653 printf (" mode_base_align[%smode] = s;\n", m->name);
1654 break;
1656 case MODE_VECTOR_INT:
1657 case MODE_VECTOR_FLOAT:
1658 case MODE_VECTOR_FRACT:
1659 case MODE_VECTOR_UFRACT:
1660 case MODE_VECTOR_ACCUM:
1661 case MODE_VECTOR_UACCUM:
1662 printf (" mode_base_align[%smode] = %d*s;\n",
1663 m->name, m->ncomponents);
1664 break;
1666 default:
1667 internal_error (
1668 "mode %s is neither vector nor complex but contains %s",
1669 m->name, a->mode->name);
1670 /* NOTREACHED */
1675 /* Ibit adjustments don't have to propagate. */
1676 for (a = adj_ibit; a; a = a->next)
1678 printf ("\n /* %s:%d */\n s = %s;\n",
1679 a->file, a->line, a->adjustment);
1680 printf (" mode_ibit[%smode] = s;\n", a->mode->name);
1683 /* Fbit adjustments don't have to propagate. */
1684 for (a = adj_fbit; a; a = a->next)
1686 printf ("\n /* %s:%d */\n s = %s;\n",
1687 a->file, a->line, a->adjustment);
1688 printf (" mode_fbit[%smode] = s;\n", a->mode->name);
1691 /* Real mode formats don't have to propagate anywhere. */
1692 for (a = adj_format; a; a = a->next)
1693 printf ("\n /* %s:%d */\n REAL_MODE_FORMAT (%smode) = %s;\n",
1694 a->file, a->line, a->mode->name, a->adjustment);
1696 puts ("}");
1699 /* Emit ibit for all modes. */
1701 static void
1702 emit_mode_ibit (void)
1704 int c;
1705 struct mode_data *m;
1707 print_maybe_const_decl ("%sunsigned char",
1708 "mode_ibit", "NUM_MACHINE_MODES",
1709 ibit);
1711 for_all_modes (c, m)
1712 tagged_printf ("%u", m->ibit, m->name);
1714 print_closer ();
1717 /* Emit fbit for all modes. */
1719 static void
1720 emit_mode_fbit (void)
1722 int c;
1723 struct mode_data *m;
1725 print_maybe_const_decl ("%sunsigned char",
1726 "mode_fbit", "NUM_MACHINE_MODES",
1727 fbit);
1729 for_all_modes (c, m)
1730 tagged_printf ("%u", m->fbit, m->name);
1732 print_closer ();
1735 /* Emit __intN for all modes. */
1737 static void
1738 emit_mode_int_n (void)
1740 int c;
1741 struct mode_data *m;
1742 struct mode_data **mode_sort;
1743 int n_modes = 0;
1744 int i, j;
1746 print_decl ("int_n_data_t", "int_n_data", "");
1748 n_modes = 0;
1749 for_all_modes (c, m)
1750 if (m->int_n)
1751 n_modes ++;
1752 mode_sort = XALLOCAVEC (struct mode_data *, n_modes);
1754 n_modes = 0;
1755 for_all_modes (c, m)
1756 if (m->int_n)
1757 mode_sort[n_modes++] = m;
1759 /* Yes, this is a bubblesort, but there are at most four (and
1760 usually only 1-2) entries to sort. */
1761 for (i = 0; i<n_modes - 1; i++)
1762 for (j = i + 1; j < n_modes; j++)
1763 if (mode_sort[i]->int_n > mode_sort[j]->int_n)
1764 std::swap (mode_sort[i], mode_sort[j]);
1766 for (i = 0; i < n_modes; i ++)
1768 m = mode_sort[i];
1769 printf(" {\n");
1770 tagged_printf ("%u", m->int_n, m->name);
1771 printf ("%smode,", m->name);
1772 printf(" },\n");
1775 print_closer ();
1779 static void
1780 emit_insn_modes_c (void)
1782 emit_insn_modes_c_header ();
1783 emit_mode_name ();
1784 emit_mode_class ();
1785 emit_mode_precision ();
1786 emit_mode_size ();
1787 emit_mode_nunits ();
1788 emit_mode_wider ();
1789 emit_mode_complex ();
1790 emit_mode_mask ();
1791 emit_mode_inner ();
1792 emit_mode_unit_size ();
1793 emit_mode_unit_precision ();
1794 emit_mode_base_align ();
1795 emit_class_narrowest_mode ();
1796 emit_real_format_for_mode ();
1797 emit_mode_adjustments ();
1798 emit_mode_ibit ();
1799 emit_mode_fbit ();
1800 emit_mode_int_n ();
1803 static void
1804 emit_min_insn_modes_c (void)
1806 emit_min_insn_modes_c_header ();
1807 emit_mode_name ();
1808 emit_mode_class ();
1809 emit_mode_nunits ();
1810 emit_mode_wider ();
1811 emit_mode_inner ();
1812 emit_class_narrowest_mode ();
1815 /* Master control. */
1817 main (int argc, char **argv)
1819 bool gen_header = false, gen_inlines = false, gen_min = false;
1820 progname = argv[0];
1822 if (argc == 1)
1824 else if (argc == 2 && !strcmp (argv[1], "-h"))
1825 gen_header = true;
1826 else if (argc == 2 && !strcmp (argv[1], "-i"))
1827 gen_inlines = true;
1828 else if (argc == 2 && !strcmp (argv[1], "-m"))
1829 gen_min = true;
1830 else
1832 error ("usage: %s [-h|-i|-m] > file", progname);
1833 return FATAL_EXIT_CODE;
1836 modes_by_name = htab_create_alloc (64, hash_mode, eq_mode, 0, xcalloc, free);
1838 create_modes ();
1839 complete_all_modes ();
1841 if (have_error)
1842 return FATAL_EXIT_CODE;
1844 calc_wider_mode ();
1846 if (gen_header)
1847 emit_insn_modes_h ();
1848 else if (gen_inlines)
1849 emit_insn_modes_inline_h ();
1850 else if (gen_min)
1851 emit_min_insn_modes_c ();
1852 else
1853 emit_insn_modes_c ();
1855 if (fflush (stdout) || fclose (stdout))
1856 return FATAL_EXIT_CODE;
1857 return SUCCESS_EXIT_CODE;