1 /* Generate the machine mode enumeration and associated tables.
2 Copyright (C) 2003-2014 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/>. */
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
};
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
] =
42 #ifdef EXTRA_MODES_FILE
43 # define HAVE_EXTRA_MODES 1
45 # define HAVE_EXTRA_MODES 0
46 # define EXTRA_MODES_FILE ""
49 /* Data structure for building up what we know about a mode.
50 They're clustered by mode class. */
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 */
75 bool need_bytesize_adj
; /* true if this mode need dynamic size
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
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 /* Partial integer modes are specified by relation to a full integer
651 #define PARTIAL_INT_MODE(M,PREC,NAME) \
652 make_partial_integer_mode (#M, #NAME, PREC, __FILE__, __LINE__)
653 static void ATTRIBUTE_UNUSED
654 make_partial_integer_mode (const char *base
, const char *name
,
655 unsigned int precision
,
656 const char *file
, unsigned int line
)
659 struct mode_data
*component
= find_mode (base
);
662 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
665 if (component
->cl
!= MODE_INT
)
667 error ("%s:%d: mode \"%s\" is not class INT", file
, line
, name
);
671 m
= new_mode (MODE_PARTIAL_INT
, name
, file
, line
);
672 m
->precision
= precision
;
673 m
->component
= component
;
676 /* A single vector mode can be specified by naming its component
677 mode and the number of components. */
678 #define VECTOR_MODE(C, M, N) \
679 make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
680 static void ATTRIBUTE_UNUSED
681 make_vector_mode (enum mode_class bclass
,
683 unsigned int ncomponents
,
684 const char *file
, unsigned int line
)
687 enum mode_class vclass
= vector_class (bclass
);
688 struct mode_data
*component
= find_mode (base
);
691 if (vclass
== MODE_RANDOM
)
695 error ("%s:%d: no mode \"%s\"", file
, line
, base
);
698 if (component
->cl
!= bclass
699 && (component
->cl
!= MODE_PARTIAL_INT
700 || bclass
!= MODE_INT
))
702 error ("%s:%d: mode \"%s\" is not class %s",
703 file
, line
, base
, mode_class_names
[bclass
] + 5);
707 if ((size_t)snprintf (namebuf
, sizeof namebuf
, "V%u%s",
708 ncomponents
, base
) >= sizeof namebuf
)
710 error ("%s:%d: mode name \"%s\" is too long",
715 v
= new_mode (vclass
, xstrdup (namebuf
), file
, line
);
716 v
->ncomponents
= ncomponents
;
717 v
->component
= component
;
721 #define _ADD_ADJUST(A, M, X, C1, C2) \
722 new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
724 #define ADJUST_BYTESIZE(M, X) _ADD_ADJUST (bytesize, M, X, RANDOM, RANDOM)
725 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST (alignment, M, X, RANDOM, RANDOM)
726 #define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST (format, M, X, FLOAT, FLOAT)
727 #define ADJUST_IBIT(M, X) _ADD_ADJUST (ibit, M, X, ACCUM, UACCUM)
728 #define ADJUST_FBIT(M, X) _ADD_ADJUST (fbit, M, X, FRACT, UACCUM)
730 static int bits_per_unit
;
731 static int max_bitsize_mode_any_int
;
736 #include "machmode.def"
738 /* So put the default value unless the target needs a non standard
741 bits_per_unit
= BITS_PER_UNIT
;
746 #ifdef MAX_BITSIZE_MODE_ANY_INT
747 max_bitsize_mode_any_int
= MAX_BITSIZE_MODE_ANY_INT
;
749 max_bitsize_mode_any_int
= 0;
755 /* Sort a list of modes into the order needed for the WIDER field:
756 major sort by precision, minor sort by component precision.
759 QI < HI < SI < DI < TI
760 V4QI < V2HI < V8QI < V4HI < V2SI.
762 If the precision is not set, sort by the bytesize. A mode with
763 precision set gets sorted before a mode without precision set, if
764 they have the same bytesize; this is the right thing because
765 the precision must always be smaller than the bytesize * BITS_PER_UNIT.
766 We don't have to do anything special to get this done -- an unset
767 precision shows up as (unsigned int)-1, i.e. UINT_MAX. */
769 cmp_modes (const void *a
, const void *b
)
771 const struct mode_data
*const m
= *(const struct mode_data
*const*)a
;
772 const struct mode_data
*const n
= *(const struct mode_data
*const*)b
;
774 if (m
->bytesize
> n
->bytesize
)
776 else if (m
->bytesize
< n
->bytesize
)
779 if (m
->precision
> n
->precision
)
781 else if (m
->precision
< n
->precision
)
784 if (!m
->component
&& !n
->component
)
786 if (m
->counter
< n
->counter
)
792 if (m
->component
->bytesize
> n
->component
->bytesize
)
794 else if (m
->component
->bytesize
< n
->component
->bytesize
)
797 if (m
->component
->precision
> n
->component
->precision
)
799 else if (m
->component
->precision
< n
->component
->precision
)
802 if (m
->counter
< n
->counter
)
809 calc_wider_mode (void)
813 struct mode_data
**sortbuf
;
814 unsigned int max_n_modes
= 0;
817 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
818 max_n_modes
= MAX (max_n_modes
, n_modes
[c
]);
820 /* Allocate max_n_modes + 1 entries to leave room for the extra null
821 pointer assigned after the qsort call below. */
822 sortbuf
= XALLOCAVEC (struct mode_data
*, max_n_modes
+ 1);
824 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
826 /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
827 However, we want these in textual order, and we have
828 precisely the reverse. */
829 if (c
== MODE_RANDOM
|| c
== MODE_CC
)
831 struct mode_data
*prev
, *next
;
833 for (prev
= 0, m
= modes
[c
]; m
; m
= next
)
835 m
->wider
= void_mode
;
837 /* this is nreverse */
849 for (i
= 0, m
= modes
[c
]; m
; i
++, m
= m
->next
)
852 qsort (sortbuf
, i
, sizeof (struct mode_data
*), cmp_modes
);
855 for (j
= 0; j
< i
; j
++)
857 sortbuf
[j
]->next
= sortbuf
[j
+ 1];
858 if (c
== MODE_PARTIAL_INT
)
859 sortbuf
[j
]->wider
= sortbuf
[j
]->component
;
861 sortbuf
[j
]->wider
= sortbuf
[j
]->next
;
864 modes
[c
] = sortbuf
[0];
869 /* Output routines. */
871 #define tagged_printf(FMT, ARG, TAG) do { \
872 int count_ = printf (" " FMT ",", ARG); \
873 printf ("%*s/* %s */\n", 27 - count_, "", TAG); \
876 #define print_decl(TYPE, NAME, ASIZE) \
877 puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
879 #define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY) \
880 printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n", \
881 adj_##CATEGORY ? "" : "const ")
883 #define print_closer() puts ("};")
885 /* Compute the max bitsize of some of the classes of integers. It may
886 be that there are needs for the other integer classes, and this
887 code is easy to extend. */
891 unsigned int max
, mmax
;
897 printf ("#define BITS_PER_UNIT (%d)\n", bits_per_unit
);
899 if (max_bitsize_mode_any_int
== 0)
901 for (max
= 1, i
= modes
[MODE_INT
]; i
; i
= i
->next
)
902 if (max
< i
->bytesize
)
905 for (max
= 1, i
= modes
[MODE_PARTIAL_INT
]; i
; i
= i
->next
)
906 if (max
< i
->bytesize
)
910 printf ("#define MAX_BITSIZE_MODE_ANY_INT (%d*BITS_PER_UNIT)\n", mmax
);
913 printf ("#define MAX_BITSIZE_MODE_ANY_INT %d\n", max_bitsize_mode_any_int
);
916 for (j
= 0; j
< MAX_MODE_CLASS
; j
++)
917 for (i
= modes
[j
]; i
; i
= i
->next
)
918 if (mmax
< i
->bytesize
)
920 printf ("#define MAX_BITSIZE_MODE_ANY_MODE (%d*BITS_PER_UNIT)\n", mmax
);
923 /* Emit mode_size_inline routine into insn-modes.h header. */
925 emit_mode_size_inline (void)
928 struct mode_adjust
*a
;
931 /* Size adjustments must be propagated to all containing modes. */
932 for (a
= adj_bytesize
; a
; a
= a
->next
)
934 a
->mode
->need_bytesize_adj
= true;
935 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
936 m
->need_bytesize_adj
= true;
940 #ifdef __cplusplus\n\
941 inline __attribute__((__always_inline__))\n\
943 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
946 mode_size_inline (enum machine_mode mode)\n\
948 extern %sunsigned char mode_size[NUM_MACHINE_MODES];\n\
950 {\n", adj_bytesize
? "" : "const ");
953 if (!m
->need_bytesize_adj
)
954 printf (" case %smode: return %u;\n", m
->name
, m
->bytesize
);
957 default: return mode_size[mode];\n\
962 /* Emit mode_nunits_inline routine into insn-modes.h header. */
964 emit_mode_nunits_inline (void)
970 #ifdef __cplusplus\n\
971 inline __attribute__((__always_inline__))\n\
973 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
976 mode_nunits_inline (enum machine_mode mode)\n\
978 extern const unsigned char mode_nunits[NUM_MACHINE_MODES];\n\
983 printf (" case %smode: return %u;\n", m
->name
, m
->ncomponents
);
986 default: return mode_nunits[mode];\n\
991 /* Emit mode_inner_inline routine into insn-modes.h header. */
993 emit_mode_inner_inline (void)
999 #ifdef __cplusplus\n\
1000 inline __attribute__((__always_inline__))\n\
1002 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1005 mode_inner_inline (enum machine_mode mode)\n\
1007 extern const unsigned char mode_inner[NUM_MACHINE_MODES];\n\
1011 for_all_modes (c
, m
)
1012 printf (" case %smode: return %smode;\n", m
->name
,
1013 c
!= MODE_PARTIAL_INT
&& m
->component
1014 ? m
->component
->name
: void_mode
->name
);
1017 default: return mode_inner[mode];\n\
1023 emit_insn_modes_h (void)
1026 struct mode_data
*m
, *first
, *last
;
1028 printf ("/* Generated automatically from machmode.def%s%s\n",
1029 HAVE_EXTRA_MODES
? " and " : "",
1035 #ifndef GCC_INSN_MODES_H\n\
1036 #define GCC_INSN_MODES_H\n\
1038 enum machine_mode\n{");
1040 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
1041 for (m
= modes
[c
]; m
; m
= m
->next
)
1043 int count_
= printf (" %smode,", m
->name
);
1044 printf ("%*s/* %s:%d */\n", 27 - count_
, "",
1045 trim_filename (m
->file
), m
->line
);
1048 puts (" MAX_MACHINE_MODE,\n");
1050 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
1054 for (m
= first
; m
; last
= m
, m
= m
->next
)
1057 /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
1058 end will try to use it for bitfields in structures and the
1059 like, which we do not want. Only the target md file should
1060 generate BImode widgets. */
1061 if (first
&& first
->precision
== 1 && c
== MODE_INT
)
1062 first
= first
->next
;
1065 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
1066 mode_class_names
[c
], first
->name
,
1067 mode_class_names
[c
], last
->name
);
1069 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
1070 mode_class_names
[c
], void_mode
->name
,
1071 mode_class_names
[c
], void_mode
->name
);
1075 NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
1078 /* I can't think of a better idea, can you? */
1079 printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize
? "" : " const");
1080 printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment
? "" : " const");
1081 #if 0 /* disabled for backward compatibility, temporary */
1082 printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format
? "" :" const");
1084 printf ("#define CONST_MODE_IBIT%s\n", adj_ibit
? "" : " const");
1085 printf ("#define CONST_MODE_FBIT%s\n", adj_fbit
? "" : " const");
1087 puts ("\n#if GCC_VERSION >= 4001\n");
1088 emit_mode_size_inline ();
1089 emit_mode_nunits_inline ();
1090 emit_mode_inner_inline ();
1091 puts ("#endif /* GCC_VERSION >= 4001 */");
1095 #endif /* insn-modes.h */");
1099 emit_insn_modes_c_header (void)
1101 printf ("/* Generated automatically from machmode.def%s%s\n",
1102 HAVE_EXTRA_MODES
? " and " : "",
1108 #include \"config.h\"\n\
1109 #include \"system.h\"\n\
1110 #include \"coretypes.h\"\n\
1111 #include \"tm.h\"\n\
1112 #include \"machmode.h\"\n\
1113 #include \"real.h\"");
1117 emit_min_insn_modes_c_header (void)
1119 printf ("/* Generated automatically from machmode.def%s%s\n",
1120 HAVE_EXTRA_MODES
? " and " : "",
1126 #include \"bconfig.h\"\n\
1127 #include \"system.h\"\n\
1128 #include \"machmode.h\"");
1132 emit_mode_name (void)
1135 struct mode_data
*m
;
1137 print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
1139 for_all_modes (c
, m
)
1140 printf (" \"%s\",\n", m
->name
);
1146 emit_mode_class (void)
1149 struct mode_data
*m
;
1151 print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
1153 for_all_modes (c
, m
)
1154 tagged_printf ("%s", mode_class_names
[m
->cl
], m
->name
);
1160 emit_mode_precision (void)
1163 struct mode_data
*m
;
1165 print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
1167 for_all_modes (c
, m
)
1168 if (m
->precision
!= (unsigned int)-1)
1169 tagged_printf ("%u", m
->precision
, m
->name
);
1171 tagged_printf ("%u*BITS_PER_UNIT", m
->bytesize
, m
->name
);
1177 emit_mode_size (void)
1180 struct mode_data
*m
;
1182 print_maybe_const_decl ("%sunsigned char", "mode_size",
1183 "NUM_MACHINE_MODES", bytesize
);
1185 for_all_modes (c
, m
)
1186 tagged_printf ("%u", m
->bytesize
, m
->name
);
1192 emit_mode_nunits (void)
1195 struct mode_data
*m
;
1197 print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1199 for_all_modes (c
, m
)
1200 tagged_printf ("%u", m
->ncomponents
, m
->name
);
1206 emit_mode_wider (void)
1209 struct mode_data
*m
;
1211 print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1213 for_all_modes (c
, m
)
1214 tagged_printf ("%smode",
1215 m
->wider
? m
->wider
->name
: void_mode
->name
,
1219 print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1221 for_all_modes (c
, m
)
1223 struct mode_data
* m2
;
1226 m2
&& m2
!= void_mode
;
1229 if (m2
->bytesize
< 2 * m
->bytesize
)
1231 if (m
->precision
!= (unsigned int) -1)
1233 if (m2
->precision
!= 2 * m
->precision
)
1238 if (m2
->precision
!= (unsigned int) -1)
1242 /* For vectors we want twice the number of components,
1243 with the same element type. */
1244 if (m
->cl
== MODE_VECTOR_INT
1245 || m
->cl
== MODE_VECTOR_FLOAT
1246 || m
->cl
== MODE_VECTOR_FRACT
1247 || m
->cl
== MODE_VECTOR_UFRACT
1248 || m
->cl
== MODE_VECTOR_ACCUM
1249 || m
->cl
== MODE_VECTOR_UACCUM
)
1251 if (m2
->ncomponents
!= 2 * m
->ncomponents
)
1253 if (m
->component
!= m2
->component
)
1259 if (m2
== void_mode
)
1261 tagged_printf ("%smode",
1262 m2
? m2
->name
: void_mode
->name
,
1270 emit_mode_mask (void)
1273 struct mode_data
*m
;
1275 print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1276 "NUM_MACHINE_MODES");
1278 #define MODE_MASK(m) \\\n\
1279 ((m) >= HOST_BITS_PER_WIDE_INT) \\\n\
1280 ? ~(unsigned HOST_WIDE_INT) 0 \\\n\
1281 : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
1283 for_all_modes (c
, m
)
1284 if (m
->precision
!= (unsigned int)-1)
1285 tagged_printf ("MODE_MASK (%u)", m
->precision
, m
->name
);
1287 tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m
->bytesize
, m
->name
);
1289 puts ("#undef MODE_MASK");
1294 emit_mode_inner (void)
1297 struct mode_data
*m
;
1299 print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1301 for_all_modes (c
, m
)
1302 tagged_printf ("%smode",
1303 c
!= MODE_PARTIAL_INT
&& m
->component
1304 ? m
->component
->name
: void_mode
->name
,
1311 emit_mode_base_align (void)
1314 struct mode_data
*m
;
1316 print_maybe_const_decl ("%sunsigned char",
1317 "mode_base_align", "NUM_MACHINE_MODES",
1320 for_all_modes (c
, m
)
1321 tagged_printf ("%u", m
->alignment
, m
->name
);
1327 emit_class_narrowest_mode (void)
1331 print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1333 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
1334 /* Bleah, all this to get the comment right for MIN_MODE_INT. */
1335 tagged_printf ("MIN_%s", mode_class_names
[c
],
1337 ? ((c
!= MODE_INT
|| modes
[c
]->precision
!= 1)
1340 ? modes
[c
]->next
->name
1348 emit_real_format_for_mode (void)
1350 struct mode_data
*m
;
1352 /* The entities pointed to by this table are constant, whether
1353 or not the table itself is constant.
1355 For backward compatibility this table is always writable
1356 (several targets modify it in TARGET_OPTION_OVERRIDE). FIXME:
1357 convert all said targets to use ADJUST_FORMAT instead. */
1359 print_maybe_const_decl ("const struct real_format *%s",
1360 "real_format_for_mode",
1361 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1364 print_decl ("struct real_format *\n", "real_format_for_mode",
1365 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1366 "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1369 /* The beginning of the table is entries for float modes. */
1370 for (m
= modes
[MODE_FLOAT
]; m
; m
= m
->next
)
1371 if (!strcmp (m
->format
, "0"))
1372 tagged_printf ("%s", m
->format
, m
->name
);
1374 tagged_printf ("&%s", m
->format
, m
->name
);
1376 /* The end of the table is entries for decimal float modes. */
1377 for (m
= modes
[MODE_DECIMAL_FLOAT
]; m
; m
= m
->next
)
1378 if (!strcmp (m
->format
, "0"))
1379 tagged_printf ("%s", m
->format
, m
->name
);
1381 tagged_printf ("&%s", m
->format
, m
->name
);
1387 emit_mode_adjustments (void)
1389 struct mode_adjust
*a
;
1390 struct mode_data
*m
;
1394 \ninit_adjust_machine_modes (void)\
1396 \n size_t s ATTRIBUTE_UNUSED;");
1398 /* Size adjustments must be propagated to all containing modes.
1399 A size adjustment forces us to recalculate the alignment too. */
1400 for (a
= adj_bytesize
; a
; a
= a
->next
)
1402 printf ("\n /* %s:%d */\n s = %s;\n",
1403 a
->file
, a
->line
, a
->adjustment
);
1404 printf (" mode_size[%smode] = s;\n", a
->mode
->name
);
1405 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1408 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1412 case MODE_COMPLEX_INT
:
1413 case MODE_COMPLEX_FLOAT
:
1414 printf (" mode_size[%smode] = 2*s;\n", m
->name
);
1415 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1419 case MODE_VECTOR_INT
:
1420 case MODE_VECTOR_FLOAT
:
1421 case MODE_VECTOR_FRACT
:
1422 case MODE_VECTOR_UFRACT
:
1423 case MODE_VECTOR_ACCUM
:
1424 case MODE_VECTOR_UACCUM
:
1425 printf (" mode_size[%smode] = %d*s;\n",
1426 m
->name
, m
->ncomponents
);
1427 printf (" mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1428 m
->name
, m
->ncomponents
, m
->ncomponents
);
1433 "mode %s is neither vector nor complex but contains %s",
1434 m
->name
, a
->mode
->name
);
1440 /* Alignment adjustments propagate too.
1441 ??? This may not be the right thing for vector modes. */
1442 for (a
= adj_alignment
; a
; a
= a
->next
)
1444 printf ("\n /* %s:%d */\n s = %s;\n",
1445 a
->file
, a
->line
, a
->adjustment
);
1446 printf (" mode_base_align[%smode] = s;\n", a
->mode
->name
);
1448 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1452 case MODE_COMPLEX_INT
:
1453 case MODE_COMPLEX_FLOAT
:
1454 printf (" mode_base_align[%smode] = s;\n", m
->name
);
1457 case MODE_VECTOR_INT
:
1458 case MODE_VECTOR_FLOAT
:
1459 case MODE_VECTOR_FRACT
:
1460 case MODE_VECTOR_UFRACT
:
1461 case MODE_VECTOR_ACCUM
:
1462 case MODE_VECTOR_UACCUM
:
1463 printf (" mode_base_align[%smode] = %d*s;\n",
1464 m
->name
, m
->ncomponents
);
1469 "mode %s is neither vector nor complex but contains %s",
1470 m
->name
, a
->mode
->name
);
1476 /* Ibit adjustments don't have to propagate. */
1477 for (a
= adj_ibit
; a
; a
= a
->next
)
1479 printf ("\n /* %s:%d */\n s = %s;\n",
1480 a
->file
, a
->line
, a
->adjustment
);
1481 printf (" mode_ibit[%smode] = s;\n", a
->mode
->name
);
1484 /* Fbit adjustments don't have to propagate. */
1485 for (a
= adj_fbit
; a
; a
= a
->next
)
1487 printf ("\n /* %s:%d */\n s = %s;\n",
1488 a
->file
, a
->line
, a
->adjustment
);
1489 printf (" mode_fbit[%smode] = s;\n", a
->mode
->name
);
1492 /* Real mode formats don't have to propagate anywhere. */
1493 for (a
= adj_format
; a
; a
= a
->next
)
1494 printf ("\n /* %s:%d */\n REAL_MODE_FORMAT (%smode) = %s;\n",
1495 a
->file
, a
->line
, a
->mode
->name
, a
->adjustment
);
1500 /* Emit ibit for all modes. */
1503 emit_mode_ibit (void)
1506 struct mode_data
*m
;
1508 print_maybe_const_decl ("%sunsigned char",
1509 "mode_ibit", "NUM_MACHINE_MODES",
1512 for_all_modes (c
, m
)
1513 tagged_printf ("%u", m
->ibit
, m
->name
);
1518 /* Emit fbit for all modes. */
1521 emit_mode_fbit (void)
1524 struct mode_data
*m
;
1526 print_maybe_const_decl ("%sunsigned char",
1527 "mode_fbit", "NUM_MACHINE_MODES",
1530 for_all_modes (c
, m
)
1531 tagged_printf ("%u", m
->fbit
, m
->name
);
1538 emit_insn_modes_c (void)
1540 emit_insn_modes_c_header ();
1543 emit_mode_precision ();
1545 emit_mode_nunits ();
1549 emit_mode_base_align ();
1550 emit_class_narrowest_mode ();
1551 emit_real_format_for_mode ();
1552 emit_mode_adjustments ();
1558 emit_min_insn_modes_c (void)
1560 emit_min_insn_modes_c_header ();
1564 emit_class_narrowest_mode ();
1567 /* Master control. */
1569 main (int argc
, char **argv
)
1571 bool gen_header
= false, gen_min
= false;
1576 else if (argc
== 2 && !strcmp (argv
[1], "-h"))
1578 else if (argc
== 2 && !strcmp (argv
[1], "-m"))
1582 error ("usage: %s [-h|-m] > file", progname
);
1583 return FATAL_EXIT_CODE
;
1586 modes_by_name
= htab_create_alloc (64, hash_mode
, eq_mode
, 0, xcalloc
, free
);
1589 complete_all_modes ();
1592 return FATAL_EXIT_CODE
;
1597 emit_insn_modes_h ();
1599 emit_min_insn_modes_c ();
1601 emit_insn_modes_c ();
1603 if (fflush (stdout
) || fclose (stdout
))
1604 return FATAL_EXIT_CODE
;
1605 return SUCCESS_EXIT_CODE
;