1 /* Generate the machine mode enumeration and associated tables.
2 Copyright (C) 2003-2015 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
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
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/>. */
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
};
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
] =
41 #ifdef EXTRA_MODES_FILE
42 # define HAVE_EXTRA_MODES 1
44 # define HAVE_EXTRA_MODES 0
45 # define EXTRA_MODES_FILE ""
48 /* Data structure for building up what we know about a mode.
49 They're clustered by mode class. */
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 const char *file
; /* file and line of definition, */
70 unsigned int line
; /* for error reporting */
71 unsigned int counter
; /* Rank ordering of modes */
72 unsigned int ibit
; /* the number of integral bits */
73 unsigned int fbit
; /* the number of fractional bits */
74 bool need_bytesize_adj
; /* true if this mode need dynamic size
76 unsigned int int_n
; /* If nonzero, then __int<INT_N> will be defined */
79 static struct mode_data
*modes
[MAX_MODE_CLASS
];
80 static unsigned int n_modes
[MAX_MODE_CLASS
];
81 static struct mode_data
*void_mode
;
83 static const struct mode_data blank_mode
= {
84 0, "<unknown>", MAX_MODE_CLASS
,
87 "<unknown>", 0, 0, 0, 0, false, 0
90 static htab_t modes_by_name
;
92 /* Data structure for recording target-specified runtime adjustments
93 to a particular mode. We support varying the byte size, the
94 alignment, and the floating point format. */
97 struct mode_adjust
*next
;
98 struct mode_data
*mode
;
99 const char *adjustment
;
105 static struct mode_adjust
*adj_bytesize
;
106 static struct mode_adjust
*adj_alignment
;
107 static struct mode_adjust
*adj_format
;
108 static struct mode_adjust
*adj_ibit
;
109 static struct mode_adjust
*adj_fbit
;
111 /* Mode class operations. */
112 static enum mode_class
113 complex_class (enum mode_class c
)
117 case MODE_INT
: return MODE_COMPLEX_INT
;
118 case MODE_FLOAT
: return MODE_COMPLEX_FLOAT
;
120 error ("no complex class for class %s", mode_class_names
[c
]);
125 static enum mode_class
126 vector_class (enum mode_class cl
)
130 case MODE_INT
: return MODE_VECTOR_INT
;
131 case MODE_FLOAT
: return MODE_VECTOR_FLOAT
;
132 case MODE_FRACT
: return MODE_VECTOR_FRACT
;
133 case MODE_UFRACT
: return MODE_VECTOR_UFRACT
;
134 case MODE_ACCUM
: return MODE_VECTOR_ACCUM
;
135 case MODE_UACCUM
: return MODE_VECTOR_UACCUM
;
137 error ("no vector class for class %s", mode_class_names
[cl
]);
142 /* Utility routines. */
143 static inline struct mode_data
*
144 find_mode (const char *name
)
146 struct mode_data key
;
149 return (struct mode_data
*) htab_find (modes_by_name
, &key
);
152 static struct mode_data
*
153 new_mode (enum mode_class cl
, const char *name
,
154 const char *file
, unsigned int line
)
157 static unsigned int count
= 0;
159 m
= find_mode (name
);
162 error ("%s:%d: duplicate definition of mode \"%s\"",
163 trim_filename (file
), line
, name
);
164 error ("%s:%d: previous definition here", m
->file
, m
->line
);
168 m
= XNEW (struct mode_data
);
169 memcpy (m
, &blank_mode
, sizeof (struct mode_data
));
173 m
->file
= trim_filename (file
);
175 m
->counter
= count
++;
181 *htab_find_slot (modes_by_name
, m
, INSERT
) = m
;
187 hash_mode (const void *p
)
189 const struct mode_data
*m
= (const struct mode_data
*)p
;
190 return htab_hash_string (m
->name
);
194 eq_mode (const void *p
, const void *q
)
196 const struct mode_data
*a
= (const struct mode_data
*)p
;
197 const struct mode_data
*b
= (const struct mode_data
*)q
;
199 return !strcmp (a
->name
, b
->name
);
202 #define for_all_modes(C, M) \
203 for (C = 0; C < MAX_MODE_CLASS; C++) \
204 for (M = modes[C]; M; M = M->next)
206 static void ATTRIBUTE_UNUSED
207 new_adjust (const char *name
,
208 struct mode_adjust
**category
, const char *catname
,
209 const char *adjustment
,
210 enum mode_class required_class_from
,
211 enum mode_class required_class_to
,
212 const char *file
, unsigned int line
)
214 struct mode_data
*mode
= find_mode (name
);
215 struct mode_adjust
*a
;
217 file
= trim_filename (file
);
221 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
225 if (required_class_from
!= MODE_RANDOM
226 && (mode
->cl
< required_class_from
|| mode
->cl
> required_class_to
))
228 error ("%s:%d: mode \"%s\" is not among class {%s, %s}",
229 file
, line
, name
, mode_class_names
[required_class_from
] + 5,
230 mode_class_names
[required_class_to
] + 5);
234 for (a
= *category
; a
; a
= a
->next
)
237 error ("%s:%d: mode \"%s\" already has a %s adjustment",
238 file
, line
, name
, catname
);
239 error ("%s:%d: previous adjustment here", a
->file
, a
->line
);
243 a
= XNEW (struct mode_adjust
);
245 a
->adjustment
= adjustment
;
253 /* Diagnose failure to meet expectations in a partially filled out
255 enum requirement
{ SET
, UNSET
, OPTIONAL
};
257 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
262 error ("%s:%d: (%s) field %s must be set", \
263 file, line, mname, fname); \
267 error ("%s:%d: (%s) field %s must not be set", \
268 file, line, mname, fname); \
274 #define validate_field(M, F) \
275 validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
278 validate_mode (struct mode_data
*m
,
279 enum requirement r_precision
,
280 enum requirement r_bytesize
,
281 enum requirement r_component
,
282 enum requirement r_ncomponents
,
283 enum requirement r_format
)
285 validate_field (m
, precision
);
286 validate_field (m
, bytesize
);
287 validate_field (m
, component
);
288 validate_field (m
, ncomponents
);
289 validate_field (m
, format
);
291 #undef validate_field
292 #undef validate_field_
294 /* Given a partially-filled-out mode structure, figure out what we can
295 and fill the rest of it in; die if it isn't enough. */
297 complete_mode (struct mode_data
*m
)
299 unsigned int alignment
;
303 error ("%s:%d: mode with no name", m
->file
, m
->line
);
306 if (m
->cl
== MAX_MODE_CLASS
)
308 error ("%s:%d: %smode has no mode class", m
->file
, m
->line
, m
->name
);
315 /* Nothing more need be said. */
316 if (!strcmp (m
->name
, "VOID"))
319 validate_mode (m
, UNSET
, UNSET
, UNSET
, UNSET
, UNSET
);
328 /* Again, nothing more need be said. For historical reasons,
329 the size of a CC mode is four units. */
330 validate_mode (m
, UNSET
, UNSET
, UNSET
, UNSET
, UNSET
);
338 case MODE_POINTER_BOUNDS
:
340 case MODE_DECIMAL_FLOAT
:
345 /* A scalar mode must have a byte size, may have a bit size,
346 and must not have components. A float mode must have a
348 validate_mode (m
, OPTIONAL
, SET
, UNSET
, UNSET
,
349 (m
->cl
== MODE_FLOAT
|| m
->cl
== MODE_DECIMAL_FLOAT
)
356 case MODE_PARTIAL_INT
:
357 /* A partial integer mode uses ->component to say what the
358 corresponding full-size integer mode is, and may also
359 specify a bit size. */
360 validate_mode (m
, OPTIONAL
, UNSET
, SET
, UNSET
, UNSET
);
362 m
->bytesize
= m
->component
->bytesize
;
367 case MODE_COMPLEX_INT
:
368 case MODE_COMPLEX_FLOAT
:
369 /* Complex modes should have a component indicated, but no more. */
370 validate_mode (m
, UNSET
, UNSET
, SET
, UNSET
, UNSET
);
372 if (m
->component
->precision
!= (unsigned int)-1)
373 m
->precision
= 2 * m
->component
->precision
;
374 m
->bytesize
= 2 * m
->component
->bytesize
;
377 case MODE_VECTOR_INT
:
378 case MODE_VECTOR_FLOAT
:
379 case MODE_VECTOR_FRACT
:
380 case MODE_VECTOR_UFRACT
:
381 case MODE_VECTOR_ACCUM
:
382 case MODE_VECTOR_UACCUM
:
383 /* Vector modes should have a component and a number of components. */
384 validate_mode (m
, UNSET
, UNSET
, SET
, SET
, UNSET
);
385 if (m
->component
->precision
!= (unsigned int)-1)
386 m
->precision
= m
->ncomponents
* m
->component
->precision
;
387 m
->bytesize
= m
->ncomponents
* m
->component
->bytesize
;
394 /* If not already specified, the mode alignment defaults to the largest
395 power of two that divides the size of the object. Complex types are
396 not more aligned than their contents. */
397 if (m
->cl
== MODE_COMPLEX_INT
|| m
->cl
== MODE_COMPLEX_FLOAT
)
398 alignment
= m
->component
->bytesize
;
400 alignment
= m
->bytesize
;
402 m
->alignment
= alignment
& (~alignment
+ 1);
404 /* If this mode has components, make the component mode point back
405 to this mode, for the sake of adjustments. */
408 m
->next_cont
= m
->component
->contained
;
409 m
->component
->contained
= m
;
414 complete_all_modes (void)
419 for_all_modes (cl
, m
)
423 /* For each mode in class CLASS, construct a corresponding complex mode. */
424 #define COMPLEX_MODES(C) make_complex_modes (MODE_##C, __FILE__, __LINE__)
426 make_complex_modes (enum mode_class cl
,
427 const char *file
, unsigned int line
)
431 enum mode_class cclass
= complex_class (cl
);
433 if (cclass
== MODE_RANDOM
)
436 for (m
= modes
[cl
]; m
; m
= m
->next
)
441 /* Skip BImode. FIXME: BImode probably shouldn't be MODE_INT. */
442 if (m
->precision
== 1)
445 m_len
= strlen (m
->name
);
446 /* The leading "1 +" is in case we prepend a "C" below. */
447 buf
= (char *) xmalloc (1 + m_len
+ 1);
449 /* Float complex modes are named SCmode, etc.
450 Int complex modes are named CSImode, etc.
451 This inconsistency should be eliminated. */
453 if (cl
== MODE_FLOAT
)
455 memcpy (buf
, m
->name
, m_len
+ 1);
456 p
= strchr (buf
, 'F');
457 if (p
== 0 && strchr (buf
, 'D') == 0)
459 error ("%s:%d: float mode \"%s\" has no 'F' or 'D'",
460 m
->file
, m
->line
, m
->name
);
470 memcpy (buf
+ 1, m
->name
, m_len
+ 1);
473 c
= new_mode (cclass
, buf
, file
, line
);
478 /* For all modes in class CL, construct vector modes of width
479 WIDTH, having as many components as necessary. */
480 #define VECTOR_MODES(C, W) make_vector_modes (MODE_##C, W, __FILE__, __LINE__)
481 static void ATTRIBUTE_UNUSED
482 make_vector_modes (enum mode_class cl
, unsigned int width
,
483 const char *file
, unsigned int line
)
488 unsigned int ncomponents
;
489 enum mode_class vclass
= vector_class (cl
);
491 if (vclass
== MODE_RANDOM
)
494 for (m
= modes
[cl
]; m
; m
= m
->next
)
496 /* Do not construct vector modes with only one element, or
497 vector modes where the element size doesn't divide the full
499 ncomponents
= width
/ m
->bytesize
;
502 if (width
% m
->bytesize
)
505 /* Skip QFmode and BImode. FIXME: this special case should
507 if (cl
== MODE_FLOAT
&& m
->bytesize
== 1)
509 if (cl
== MODE_INT
&& m
->precision
== 1)
512 if ((size_t)snprintf (buf
, sizeof buf
, "V%u%s", ncomponents
, m
->name
)
515 error ("%s:%d: mode name \"%s\" is too long",
516 m
->file
, m
->line
, m
->name
);
520 v
= new_mode (vclass
, xstrdup (buf
), file
, line
);
522 v
->ncomponents
= ncomponents
;
528 #define _SPECIAL_MODE(C, N) \
529 make_special_mode (MODE_##C, #N, __FILE__, __LINE__)
530 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
531 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
534 make_special_mode (enum mode_class cl
, const char *name
,
535 const char *file
, unsigned int line
)
537 new_mode (cl
, name
, file
, line
);
540 #define POINTER_BOUNDS_MODE(N, Y) \
541 make_pointer_bounds_mode (#N, Y, __FILE__, __LINE__)
543 static void ATTRIBUTE_UNUSED
544 make_pointer_bounds_mode (const char *name
,
545 unsigned int bytesize
,
546 const char *file
, unsigned int line
)
548 struct mode_data
*m
= new_mode (MODE_POINTER_BOUNDS
, name
, file
, line
);
549 m
->bytesize
= bytesize
;
553 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
554 #define FRACTIONAL_INT_MODE(N, B, Y) \
555 make_int_mode (#N, B, Y, __FILE__, __LINE__)
558 make_int_mode (const char *name
,
559 unsigned int precision
, unsigned int bytesize
,
560 const char *file
, unsigned int line
)
562 struct mode_data
*m
= new_mode (MODE_INT
, name
, file
, line
);
563 m
->bytesize
= bytesize
;
564 m
->precision
= precision
;
567 #define FRACT_MODE(N, Y, F) \
568 make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
570 #define UFRACT_MODE(N, Y, F) \
571 make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
573 #define ACCUM_MODE(N, Y, I, F) \
574 make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
576 #define UACCUM_MODE(N, Y, I, F) \
577 make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
579 /* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
583 make_fixed_point_mode (enum mode_class cl
,
585 unsigned int bytesize
,
588 const char *file
, unsigned int line
)
590 struct mode_data
*m
= new_mode (cl
, name
, file
, line
);
591 m
->bytesize
= bytesize
;
596 #define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
597 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
598 make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
601 make_float_mode (const char *name
,
602 unsigned int precision
, unsigned int bytesize
,
604 const char *file
, unsigned int line
)
606 struct mode_data
*m
= new_mode (MODE_FLOAT
, name
, file
, line
);
607 m
->bytesize
= bytesize
;
608 m
->precision
= precision
;
612 #define DECIMAL_FLOAT_MODE(N, Y, F) \
613 FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
614 #define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F) \
615 make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
618 make_decimal_float_mode (const char *name
,
619 unsigned int precision
, unsigned int bytesize
,
621 const char *file
, unsigned int line
)
623 struct mode_data
*m
= new_mode (MODE_DECIMAL_FLOAT
, name
, file
, line
);
624 m
->bytesize
= bytesize
;
625 m
->precision
= precision
;
629 #define RESET_FLOAT_FORMAT(N, F) \
630 reset_float_format (#N, #F, __FILE__, __LINE__)
631 static void ATTRIBUTE_UNUSED
632 reset_float_format (const char *name
, const char *format
,
633 const char *file
, unsigned int line
)
635 struct mode_data
*m
= find_mode (name
);
638 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
641 if (m
->cl
!= MODE_FLOAT
&& m
->cl
!= MODE_DECIMAL_FLOAT
)
643 error ("%s:%d: mode \"%s\" is not a FLOAT class", file
, line
, name
);
649 /* __intN support. */
650 #define INT_N(M,PREC) \
651 make_int_n (#M, PREC, __FILE__, __LINE__)
652 static void ATTRIBUTE_UNUSED
653 make_int_n (const char *m
, int bitsize
,
654 const char *file
, unsigned int line
)
656 struct mode_data
*component
= find_mode (m
);
659 error ("%s:%d: no mode \"%s\"", file
, line
, m
);
662 if (component
->cl
!= MODE_INT
663 && component
->cl
!= MODE_PARTIAL_INT
)
665 error ("%s:%d: mode \"%s\" is not class INT or PARTIAL_INT", file
, line
, m
);
668 if (component
->int_n
!= 0)
670 error ("%s:%d: mode \"%s\" already has an intN", file
, line
, m
);
674 component
->int_n
= bitsize
;
677 /* Partial integer modes are specified by relation to a full integer
679 #define PARTIAL_INT_MODE(M,PREC,NAME) \
680 make_partial_integer_mode (#M, #NAME, PREC, __FILE__, __LINE__)
681 static void ATTRIBUTE_UNUSED
682 make_partial_integer_mode (const char *base
, const char *name
,
683 unsigned int precision
,
684 const char *file
, unsigned int line
)
687 struct mode_data
*component
= find_mode (base
);
690 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
693 if (component
->cl
!= MODE_INT
)
695 error ("%s:%d: mode \"%s\" is not class INT", file
, line
, name
);
699 m
= new_mode (MODE_PARTIAL_INT
, name
, file
, line
);
700 m
->precision
= precision
;
701 m
->component
= component
;
704 /* A single vector mode can be specified by naming its component
705 mode and the number of components. */
706 #define VECTOR_MODE(C, M, N) \
707 make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
708 static void ATTRIBUTE_UNUSED
709 make_vector_mode (enum mode_class bclass
,
711 unsigned int ncomponents
,
712 const char *file
, unsigned int line
)
715 enum mode_class vclass
= vector_class (bclass
);
716 struct mode_data
*component
= find_mode (base
);
719 if (vclass
== MODE_RANDOM
)
723 error ("%s:%d: no mode \"%s\"", file
, line
, base
);
726 if (component
->cl
!= bclass
727 && (component
->cl
!= MODE_PARTIAL_INT
728 || bclass
!= MODE_INT
))
730 error ("%s:%d: mode \"%s\" is not class %s",
731 file
, line
, base
, mode_class_names
[bclass
] + 5);
735 if ((size_t)snprintf (namebuf
, sizeof namebuf
, "V%u%s",
736 ncomponents
, base
) >= sizeof namebuf
)
738 error ("%s:%d: mode name \"%s\" is too long",
743 v
= new_mode (vclass
, xstrdup (namebuf
), file
, line
);
744 v
->ncomponents
= ncomponents
;
745 v
->component
= component
;
749 #define _ADD_ADJUST(A, M, X, C1, C2) \
750 new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
752 #define ADJUST_BYTESIZE(M, X) _ADD_ADJUST (bytesize, M, X, RANDOM, RANDOM)
753 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST (alignment, M, X, RANDOM, RANDOM)
754 #define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST (format, M, X, FLOAT, FLOAT)
755 #define ADJUST_IBIT(M, X) _ADD_ADJUST (ibit, M, X, ACCUM, UACCUM)
756 #define ADJUST_FBIT(M, X) _ADD_ADJUST (fbit, M, X, FRACT, UACCUM)
758 static int bits_per_unit
;
759 static int max_bitsize_mode_any_int
;
764 #include "machmode.def"
766 /* So put the default value unless the target needs a non standard
769 bits_per_unit
= BITS_PER_UNIT
;
774 #ifdef MAX_BITSIZE_MODE_ANY_INT
775 max_bitsize_mode_any_int
= MAX_BITSIZE_MODE_ANY_INT
;
777 max_bitsize_mode_any_int
= 0;
783 /* Sort a list of modes into the order needed for the WIDER field:
784 major sort by precision, minor sort by component precision.
787 QI < HI < SI < DI < TI
788 V4QI < V2HI < V8QI < V4HI < V2SI.
790 If the precision is not set, sort by the bytesize. A mode with
791 precision set gets sorted before a mode without precision set, if
792 they have the same bytesize; this is the right thing because
793 the precision must always be smaller than the bytesize * BITS_PER_UNIT.
794 We don't have to do anything special to get this done -- an unset
795 precision shows up as (unsigned int)-1, i.e. UINT_MAX. */
797 cmp_modes (const void *a
, const void *b
)
799 const struct mode_data
*const m
= *(const struct mode_data
*const*)a
;
800 const struct mode_data
*const n
= *(const struct mode_data
*const*)b
;
802 if (m
->bytesize
> n
->bytesize
)
804 else if (m
->bytesize
< n
->bytesize
)
807 if (m
->precision
> n
->precision
)
809 else if (m
->precision
< n
->precision
)
812 if (!m
->component
&& !n
->component
)
814 if (m
->counter
< n
->counter
)
820 if (m
->component
->bytesize
> n
->component
->bytesize
)
822 else if (m
->component
->bytesize
< n
->component
->bytesize
)
825 if (m
->component
->precision
> n
->component
->precision
)
827 else if (m
->component
->precision
< n
->component
->precision
)
830 if (m
->counter
< n
->counter
)
837 calc_wider_mode (void)
841 struct mode_data
**sortbuf
;
842 unsigned int max_n_modes
= 0;
845 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
846 max_n_modes
= MAX (max_n_modes
, n_modes
[c
]);
848 /* Allocate max_n_modes + 1 entries to leave room for the extra null
849 pointer assigned after the qsort call below. */
850 sortbuf
= XALLOCAVEC (struct mode_data
*, max_n_modes
+ 1);
852 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
854 /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
855 However, we want these in textual order, and we have
856 precisely the reverse. */
857 if (c
== MODE_RANDOM
|| c
== MODE_CC
)
859 struct mode_data
*prev
, *next
;
861 for (prev
= 0, m
= modes
[c
]; m
; m
= next
)
863 m
->wider
= void_mode
;
865 /* this is nreverse */
877 for (i
= 0, m
= modes
[c
]; m
; i
++, m
= m
->next
)
880 qsort (sortbuf
, i
, sizeof (struct mode_data
*), cmp_modes
);
883 for (j
= 0; j
< i
; j
++)
885 sortbuf
[j
]->next
= sortbuf
[j
+ 1];
886 if (c
== MODE_PARTIAL_INT
)
887 sortbuf
[j
]->wider
= sortbuf
[j
]->component
;
889 sortbuf
[j
]->wider
= sortbuf
[j
]->next
;
892 modes
[c
] = sortbuf
[0];
897 /* Output routines. */
899 #define tagged_printf(FMT, ARG, TAG) do { \
900 int count_ = printf (" " FMT ",", ARG); \
901 printf ("%*s/* %s */\n", 27 - count_, "", TAG); \
904 #define print_decl(TYPE, NAME, ASIZE) \
905 puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
907 #define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY) \
908 printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n", \
909 adj_##CATEGORY ? "" : "const ")
911 #define print_closer() puts ("};")
913 /* Compute the max bitsize of some of the classes of integers. It may
914 be that there are needs for the other integer classes, and this
915 code is easy to extend. */
919 unsigned int max
, mmax
;
925 printf ("#define BITS_PER_UNIT (%d)\n", bits_per_unit
);
927 if (max_bitsize_mode_any_int
== 0)
929 for (max
= 1, i
= modes
[MODE_INT
]; i
; i
= i
->next
)
930 if (max
< i
->bytesize
)
933 for (max
= 1, i
= modes
[MODE_PARTIAL_INT
]; i
; i
= i
->next
)
934 if (max
< i
->bytesize
)
938 printf ("#define MAX_BITSIZE_MODE_ANY_INT (%d*BITS_PER_UNIT)\n", mmax
);
941 printf ("#define MAX_BITSIZE_MODE_ANY_INT %d\n", max_bitsize_mode_any_int
);
944 for (j
= 0; j
< MAX_MODE_CLASS
; j
++)
945 for (i
= modes
[j
]; i
; i
= i
->next
)
946 if (mmax
< i
->bytesize
)
948 printf ("#define MAX_BITSIZE_MODE_ANY_MODE (%d*BITS_PER_UNIT)\n", mmax
);
951 /* Emit mode_size_inline routine into insn-modes.h header. */
953 emit_mode_size_inline (void)
956 struct mode_adjust
*a
;
959 /* Size adjustments must be propagated to all containing modes. */
960 for (a
= adj_bytesize
; a
; a
= a
->next
)
962 a
->mode
->need_bytesize_adj
= true;
963 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
964 m
->need_bytesize_adj
= true;
968 #ifdef __cplusplus\n\
969 inline __attribute__((__always_inline__))\n\
971 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
974 mode_size_inline (machine_mode mode)\n\
976 extern %sunsigned char mode_size[NUM_MACHINE_MODES];\n\
978 {\n", adj_bytesize
? "" : "const ");
981 if (!m
->need_bytesize_adj
)
982 printf (" case %smode: return %u;\n", m
->name
, m
->bytesize
);
985 default: return mode_size[mode];\n\
990 /* Emit mode_nunits_inline routine into insn-modes.h header. */
992 emit_mode_nunits_inline (void)
998 #ifdef __cplusplus\n\
999 inline __attribute__((__always_inline__))\n\
1001 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1004 mode_nunits_inline (machine_mode mode)\n\
1006 extern const unsigned char mode_nunits[NUM_MACHINE_MODES];\n\
1010 for_all_modes (c
, m
)
1011 printf (" case %smode: return %u;\n", m
->name
, m
->ncomponents
);
1014 default: return mode_nunits[mode];\n\
1019 /* Emit mode_inner_inline routine into insn-modes.h header. */
1021 emit_mode_inner_inline (void)
1024 struct mode_data
*m
;
1027 #ifdef __cplusplus\n\
1028 inline __attribute__((__always_inline__))\n\
1030 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1033 mode_inner_inline (machine_mode mode)\n\
1035 extern const unsigned char mode_inner[NUM_MACHINE_MODES];\n\
1039 for_all_modes (c
, m
)
1040 printf (" case %smode: return %smode;\n", m
->name
,
1041 c
!= MODE_PARTIAL_INT
&& m
->component
1042 ? m
->component
->name
: m
->name
);
1045 default: return mode_inner[mode];\n\
1050 /* Emit mode_unit_size_inline routine into insn-modes.h header. */
1052 emit_mode_unit_size_inline (void)
1055 struct mode_data
*m
;
1058 #ifdef __cplusplus\n\
1059 inline __attribute__((__always_inline__))\n\
1061 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1064 mode_unit_size_inline (machine_mode mode)\n\
1066 extern unsigned char mode_unit_size[NUM_MACHINE_MODES];\n\
1070 for_all_modes (c
, m
)
1072 const char *name
= m
->name
;
1073 struct mode_data
*m2
= m
;
1074 if (c
!= MODE_PARTIAL_INT
&& m2
->component
)
1076 if (!m2
->need_bytesize_adj
)
1077 printf (" case %smode: return %u;\n", name
, m2
->bytesize
);
1081 default: return mode_unit_size[mode];\n\
1086 /* Emit mode_unit_precision_inline routine into insn-modes.h header. */
1088 emit_mode_unit_precision_inline (void)
1091 struct mode_data
*m
;
1094 #ifdef __cplusplus\n\
1095 inline __attribute__((__always_inline__))\n\
1097 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1100 mode_unit_precision_inline (machine_mode mode)\n\
1102 extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];\n\
1106 for_all_modes (c
, m
)
1108 struct mode_data
*m2
1109 = (c
!= MODE_PARTIAL_INT
&& m
->component
) ? m
->component
: m
;
1110 if (m2
->precision
!= (unsigned int)-1)
1111 printf (" case %smode: return %u;\n", m
->name
, m2
->precision
);
1113 printf (" case %smode: return %u*BITS_PER_UNIT;\n",
1114 m
->name
, m2
->bytesize
);
1118 default: return mode_unit_precision[mode];\n\
1124 emit_insn_modes_h (void)
1127 struct mode_data
*m
, *first
, *last
;
1128 int n_int_n_ents
= 0;
1130 printf ("/* Generated automatically from machmode.def%s%s\n",
1131 HAVE_EXTRA_MODES
? " and " : "",
1137 #ifndef GCC_INSN_MODES_H\n\
1138 #define GCC_INSN_MODES_H\n\
1140 enum machine_mode\n{");
1142 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
1143 for (m
= modes
[c
]; m
; m
= m
->next
)
1145 int count_
= printf (" %smode,", m
->name
);
1146 printf ("%*s/* %s:%d */\n", 27 - count_
, "",
1147 trim_filename (m
->file
), m
->line
);
1148 printf ("#define HAVE_%smode\n", m
->name
);
1151 puts (" MAX_MACHINE_MODE,\n");
1153 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
1157 for (m
= first
; m
; last
= m
, m
= m
->next
)
1160 /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
1161 end will try to use it for bitfields in structures and the
1162 like, which we do not want. Only the target md file should
1163 generate BImode widgets. */
1164 if (first
&& first
->precision
== 1 && c
== MODE_INT
)
1165 first
= first
->next
;
1168 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
1169 mode_class_names
[c
], first
->name
,
1170 mode_class_names
[c
], last
->name
);
1172 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
1173 mode_class_names
[c
], void_mode
->name
,
1174 mode_class_names
[c
], void_mode
->name
);
1178 NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
1181 /* I can't think of a better idea, can you? */
1182 printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize
? "" : " const");
1183 printf ("#define CONST_MODE_UNIT_SIZE%s\n", adj_bytesize
? "" : " const");
1184 printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment
? "" : " const");
1185 #if 0 /* disabled for backward compatibility, temporary */
1186 printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format
? "" :" const");
1188 printf ("#define CONST_MODE_IBIT%s\n", adj_ibit
? "" : " const");
1189 printf ("#define CONST_MODE_FBIT%s\n", adj_fbit
? "" : " const");
1192 for_all_modes (c
, m
)
1196 printf ("#define NUM_INT_N_ENTS %d\n", n_int_n_ents
);
1198 puts ("\n#if !defined (USED_FOR_TARGET) && GCC_VERSION >= 4001\n");
1199 emit_mode_size_inline ();
1200 emit_mode_nunits_inline ();
1201 emit_mode_inner_inline ();
1202 emit_mode_unit_size_inline ();
1203 emit_mode_unit_precision_inline ();
1204 puts ("#endif /* GCC_VERSION >= 4001 */");
1208 #endif /* insn-modes.h */");
1212 emit_insn_modes_c_header (void)
1214 printf ("/* Generated automatically from machmode.def%s%s\n",
1215 HAVE_EXTRA_MODES
? " and " : "",
1221 #include \"config.h\"\n\
1222 #include \"system.h\"\n\
1223 #include \"coretypes.h\"\n\
1224 #include \"tm.h\"\n\
1225 #include \"machmode.h\"\n\
1226 #include \"real.h\"");
1230 emit_min_insn_modes_c_header (void)
1232 printf ("/* Generated automatically from machmode.def%s%s\n",
1233 HAVE_EXTRA_MODES
? " and " : "",
1239 #include \"bconfig.h\"\n\
1240 #include \"system.h\"\n\
1241 #include \"machmode.h\"");
1245 emit_mode_name (void)
1248 struct mode_data
*m
;
1250 print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
1252 for_all_modes (c
, m
)
1253 printf (" \"%s\",\n", m
->name
);
1259 emit_mode_class (void)
1262 struct mode_data
*m
;
1264 print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
1266 for_all_modes (c
, m
)
1267 tagged_printf ("%s", mode_class_names
[m
->cl
], m
->name
);
1273 emit_mode_precision (void)
1276 struct mode_data
*m
;
1278 print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
1280 for_all_modes (c
, m
)
1281 if (m
->precision
!= (unsigned int)-1)
1282 tagged_printf ("%u", m
->precision
, m
->name
);
1284 tagged_printf ("%u*BITS_PER_UNIT", m
->bytesize
, m
->name
);
1290 emit_mode_size (void)
1293 struct mode_data
*m
;
1295 print_maybe_const_decl ("%sunsigned char", "mode_size",
1296 "NUM_MACHINE_MODES", bytesize
);
1298 for_all_modes (c
, m
)
1299 tagged_printf ("%u", m
->bytesize
, m
->name
);
1305 emit_mode_nunits (void)
1308 struct mode_data
*m
;
1310 print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1312 for_all_modes (c
, m
)
1313 tagged_printf ("%u", m
->ncomponents
, m
->name
);
1319 emit_mode_wider (void)
1322 struct mode_data
*m
;
1324 print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1326 for_all_modes (c
, m
)
1327 tagged_printf ("%smode",
1328 m
->wider
? m
->wider
->name
: void_mode
->name
,
1332 print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1334 for_all_modes (c
, m
)
1336 struct mode_data
* m2
;
1339 m2
&& m2
!= void_mode
;
1342 if (m2
->bytesize
< 2 * m
->bytesize
)
1344 if (m
->precision
!= (unsigned int) -1)
1346 if (m2
->precision
!= 2 * m
->precision
)
1351 if (m2
->precision
!= (unsigned int) -1)
1355 /* For vectors we want twice the number of components,
1356 with the same element type. */
1357 if (m
->cl
== MODE_VECTOR_INT
1358 || m
->cl
== MODE_VECTOR_FLOAT
1359 || m
->cl
== MODE_VECTOR_FRACT
1360 || m
->cl
== MODE_VECTOR_UFRACT
1361 || m
->cl
== MODE_VECTOR_ACCUM
1362 || m
->cl
== MODE_VECTOR_UACCUM
)
1364 if (m2
->ncomponents
!= 2 * m
->ncomponents
)
1366 if (m
->component
!= m2
->component
)
1372 if (m2
== void_mode
)
1374 tagged_printf ("%smode",
1375 m2
? m2
->name
: void_mode
->name
,
1383 emit_mode_mask (void)
1386 struct mode_data
*m
;
1388 print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1389 "NUM_MACHINE_MODES");
1391 #define MODE_MASK(m) \\\n\
1392 ((m) >= HOST_BITS_PER_WIDE_INT) \\\n\
1393 ? ~(unsigned HOST_WIDE_INT) 0 \\\n\
1394 : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
1396 for_all_modes (c
, m
)
1397 if (m
->precision
!= (unsigned int)-1)
1398 tagged_printf ("MODE_MASK (%u)", m
->precision
, m
->name
);
1400 tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m
->bytesize
, m
->name
);
1402 puts ("#undef MODE_MASK");
1407 emit_mode_inner (void)
1410 struct mode_data
*m
;
1412 print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1414 for_all_modes (c
, m
)
1415 tagged_printf ("%smode",
1416 c
!= MODE_PARTIAL_INT
&& m
->component
1417 ? m
->component
->name
: m
->name
,
1423 /* Emit mode_unit_size array into insn-modes.c file. */
1425 emit_mode_unit_size (void)
1428 struct mode_data
*m
;
1430 print_maybe_const_decl ("%sunsigned char", "mode_unit_size",
1431 "NUM_MACHINE_MODES", bytesize
);
1433 for_all_modes (c
, m
)
1434 tagged_printf ("%u",
1435 c
!= MODE_PARTIAL_INT
&& m
->component
1436 ? m
->component
->bytesize
: m
->bytesize
, m
->name
);
1441 /* Emit mode_unit_precision array into insn-modes.c file. */
1443 emit_mode_unit_precision (void)
1446 struct mode_data
*m
;
1448 print_decl ("unsigned short", "mode_unit_precision", "NUM_MACHINE_MODES");
1450 for_all_modes (c
, m
)
1452 struct mode_data
*m2
= (c
!= MODE_PARTIAL_INT
&& m
->component
) ?
1454 if (m2
->precision
!= (unsigned int)-1)
1455 tagged_printf ("%u", m2
->precision
, m
->name
);
1457 tagged_printf ("%u*BITS_PER_UNIT", m2
->bytesize
, m
->name
);
1465 emit_mode_base_align (void)
1468 struct mode_data
*m
;
1470 print_maybe_const_decl ("%sunsigned char",
1471 "mode_base_align", "NUM_MACHINE_MODES",
1474 for_all_modes (c
, m
)
1475 tagged_printf ("%u", m
->alignment
, m
->name
);
1481 emit_class_narrowest_mode (void)
1485 print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1487 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
1488 /* Bleah, all this to get the comment right for MIN_MODE_INT. */
1489 tagged_printf ("MIN_%s", mode_class_names
[c
],
1491 ? ((c
!= MODE_INT
|| modes
[c
]->precision
!= 1)
1494 ? modes
[c
]->next
->name
1502 emit_real_format_for_mode (void)
1504 struct mode_data
*m
;
1506 /* The entities pointed to by this table are constant, whether
1507 or not the table itself is constant.
1509 For backward compatibility this table is always writable
1510 (several targets modify it in TARGET_OPTION_OVERRIDE). FIXME:
1511 convert all said targets to use ADJUST_FORMAT instead. */
1513 print_maybe_const_decl ("const struct real_format *%s",
1514 "real_format_for_mode",
1515 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1518 print_decl ("struct real_format *\n", "real_format_for_mode",
1519 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1520 "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1523 /* The beginning of the table is entries for float modes. */
1524 for (m
= modes
[MODE_FLOAT
]; m
; m
= m
->next
)
1525 if (!strcmp (m
->format
, "0"))
1526 tagged_printf ("%s", m
->format
, m
->name
);
1528 tagged_printf ("&%s", m
->format
, m
->name
);
1530 /* The end of the table is entries for decimal float modes. */
1531 for (m
= modes
[MODE_DECIMAL_FLOAT
]; m
; m
= m
->next
)
1532 if (!strcmp (m
->format
, "0"))
1533 tagged_printf ("%s", m
->format
, m
->name
);
1535 tagged_printf ("&%s", m
->format
, m
->name
);
1541 emit_mode_adjustments (void)
1543 struct mode_adjust
*a
;
1544 struct mode_data
*m
;
1548 \ninit_adjust_machine_modes (void)\
1550 \n size_t s ATTRIBUTE_UNUSED;");
1552 /* Size adjustments must be propagated to all containing modes.
1553 A size adjustment forces us to recalculate the alignment too. */
1554 for (a
= adj_bytesize
; a
; a
= a
->next
)
1556 printf ("\n /* %s:%d */\n s = %s;\n",
1557 a
->file
, a
->line
, a
->adjustment
);
1558 printf (" mode_size[%smode] = s;\n", a
->mode
->name
);
1559 printf (" mode_unit_size[%smode] = s;\n", a
->mode
->name
);
1560 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1563 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1567 case MODE_COMPLEX_INT
:
1568 case MODE_COMPLEX_FLOAT
:
1569 printf (" mode_size[%smode] = 2*s;\n", m
->name
);
1570 printf (" mode_unit_size[%smode] = s;\n", m
->name
);
1571 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1575 case MODE_VECTOR_INT
:
1576 case MODE_VECTOR_FLOAT
:
1577 case MODE_VECTOR_FRACT
:
1578 case MODE_VECTOR_UFRACT
:
1579 case MODE_VECTOR_ACCUM
:
1580 case MODE_VECTOR_UACCUM
:
1581 printf (" mode_size[%smode] = %d*s;\n",
1582 m
->name
, m
->ncomponents
);
1583 printf (" mode_unit_size[%smode] = s;\n", m
->name
);
1584 printf (" mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1585 m
->name
, m
->ncomponents
, m
->ncomponents
);
1590 "mode %s is neither vector nor complex but contains %s",
1591 m
->name
, a
->mode
->name
);
1597 /* Alignment adjustments propagate too.
1598 ??? This may not be the right thing for vector modes. */
1599 for (a
= adj_alignment
; a
; a
= a
->next
)
1601 printf ("\n /* %s:%d */\n s = %s;\n",
1602 a
->file
, a
->line
, a
->adjustment
);
1603 printf (" mode_base_align[%smode] = s;\n", a
->mode
->name
);
1605 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1609 case MODE_COMPLEX_INT
:
1610 case MODE_COMPLEX_FLOAT
:
1611 printf (" mode_base_align[%smode] = s;\n", m
->name
);
1614 case MODE_VECTOR_INT
:
1615 case MODE_VECTOR_FLOAT
:
1616 case MODE_VECTOR_FRACT
:
1617 case MODE_VECTOR_UFRACT
:
1618 case MODE_VECTOR_ACCUM
:
1619 case MODE_VECTOR_UACCUM
:
1620 printf (" mode_base_align[%smode] = %d*s;\n",
1621 m
->name
, m
->ncomponents
);
1626 "mode %s is neither vector nor complex but contains %s",
1627 m
->name
, a
->mode
->name
);
1633 /* Ibit adjustments don't have to propagate. */
1634 for (a
= adj_ibit
; a
; a
= a
->next
)
1636 printf ("\n /* %s:%d */\n s = %s;\n",
1637 a
->file
, a
->line
, a
->adjustment
);
1638 printf (" mode_ibit[%smode] = s;\n", a
->mode
->name
);
1641 /* Fbit adjustments don't have to propagate. */
1642 for (a
= adj_fbit
; a
; a
= a
->next
)
1644 printf ("\n /* %s:%d */\n s = %s;\n",
1645 a
->file
, a
->line
, a
->adjustment
);
1646 printf (" mode_fbit[%smode] = s;\n", a
->mode
->name
);
1649 /* Real mode formats don't have to propagate anywhere. */
1650 for (a
= adj_format
; a
; a
= a
->next
)
1651 printf ("\n /* %s:%d */\n REAL_MODE_FORMAT (%smode) = %s;\n",
1652 a
->file
, a
->line
, a
->mode
->name
, a
->adjustment
);
1657 /* Emit ibit for all modes. */
1660 emit_mode_ibit (void)
1663 struct mode_data
*m
;
1665 print_maybe_const_decl ("%sunsigned char",
1666 "mode_ibit", "NUM_MACHINE_MODES",
1669 for_all_modes (c
, m
)
1670 tagged_printf ("%u", m
->ibit
, m
->name
);
1675 /* Emit fbit for all modes. */
1678 emit_mode_fbit (void)
1681 struct mode_data
*m
;
1683 print_maybe_const_decl ("%sunsigned char",
1684 "mode_fbit", "NUM_MACHINE_MODES",
1687 for_all_modes (c
, m
)
1688 tagged_printf ("%u", m
->fbit
, m
->name
);
1693 /* Emit __intN for all modes. */
1696 emit_mode_int_n (void)
1699 struct mode_data
*m
;
1700 struct mode_data
**mode_sort
;
1704 print_decl ("int_n_data_t", "int_n_data", "");
1707 for_all_modes (c
, m
)
1710 mode_sort
= XALLOCAVEC (struct mode_data
*, n_modes
);
1713 for_all_modes (c
, m
)
1715 mode_sort
[n_modes
++] = m
;
1717 /* Yes, this is a bubblesort, but there are at most four (and
1718 usually only 1-2) entries to sort. */
1719 for (i
= 0; i
<n_modes
- 1; i
++)
1720 for (j
= i
+ 1; j
< n_modes
; j
++)
1721 if (mode_sort
[i
]->int_n
> mode_sort
[j
]->int_n
)
1722 std::swap (mode_sort
[i
], mode_sort
[j
]);
1724 for (i
= 0; i
< n_modes
; i
++)
1728 tagged_printf ("%u", m
->int_n
, m
->name
);
1729 printf ("%smode,", m
->name
);
1738 emit_insn_modes_c (void)
1740 emit_insn_modes_c_header ();
1743 emit_mode_precision ();
1745 emit_mode_nunits ();
1749 emit_mode_unit_size ();
1750 emit_mode_unit_precision ();
1751 emit_mode_base_align ();
1752 emit_class_narrowest_mode ();
1753 emit_real_format_for_mode ();
1754 emit_mode_adjustments ();
1761 emit_min_insn_modes_c (void)
1763 emit_min_insn_modes_c_header ();
1767 emit_class_narrowest_mode ();
1770 /* Master control. */
1772 main (int argc
, char **argv
)
1774 bool gen_header
= false, gen_min
= false;
1779 else if (argc
== 2 && !strcmp (argv
[1], "-h"))
1781 else if (argc
== 2 && !strcmp (argv
[1], "-m"))
1785 error ("usage: %s [-h|-m] > file", progname
);
1786 return FATAL_EXIT_CODE
;
1789 modes_by_name
= htab_create_alloc (64, hash_mode
, eq_mode
, 0, xcalloc
, free
);
1792 complete_all_modes ();
1795 return FATAL_EXIT_CODE
;
1800 emit_insn_modes_h ();
1802 emit_min_insn_modes_c ();
1804 emit_insn_modes_c ();
1806 if (fflush (stdout
) || fclose (stdout
))
1807 return FATAL_EXIT_CODE
;
1808 return SUCCESS_EXIT_CODE
;