1 /* Generate the machine mode enumeration and associated tables.
2 Copyright (C) 2003-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
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 */
77 static struct mode_data
*modes
[MAX_MODE_CLASS
];
78 static unsigned int n_modes
[MAX_MODE_CLASS
];
79 static struct mode_data
*void_mode
;
81 static const struct mode_data blank_mode
= {
82 0, "<unknown>", MAX_MODE_CLASS
,
85 "<unknown>", 0, 0, 0, 0
88 static htab_t modes_by_name
;
90 /* Data structure for recording target-specified runtime adjustments
91 to a particular mode. We support varying the byte size, the
92 alignment, and the floating point format. */
95 struct mode_adjust
*next
;
96 struct mode_data
*mode
;
97 const char *adjustment
;
103 static struct mode_adjust
*adj_bytesize
;
104 static struct mode_adjust
*adj_alignment
;
105 static struct mode_adjust
*adj_format
;
106 static struct mode_adjust
*adj_ibit
;
107 static struct mode_adjust
*adj_fbit
;
109 /* Mode class operations. */
110 static enum mode_class
111 complex_class (enum mode_class c
)
115 case MODE_INT
: return MODE_COMPLEX_INT
;
116 case MODE_FLOAT
: return MODE_COMPLEX_FLOAT
;
118 error ("no complex class for class %s", mode_class_names
[c
]);
123 static enum mode_class
124 vector_class (enum mode_class cl
)
128 case MODE_INT
: return MODE_VECTOR_INT
;
129 case MODE_FLOAT
: return MODE_VECTOR_FLOAT
;
130 case MODE_FRACT
: return MODE_VECTOR_FRACT
;
131 case MODE_UFRACT
: return MODE_VECTOR_UFRACT
;
132 case MODE_ACCUM
: return MODE_VECTOR_ACCUM
;
133 case MODE_UACCUM
: return MODE_VECTOR_UACCUM
;
135 error ("no vector class for class %s", mode_class_names
[cl
]);
140 /* Utility routines. */
141 static inline struct mode_data
*
142 find_mode (const char *name
)
144 struct mode_data key
;
147 return (struct mode_data
*) htab_find (modes_by_name
, &key
);
150 static struct mode_data
*
151 new_mode (enum mode_class cl
, const char *name
,
152 const char *file
, unsigned int line
)
155 static unsigned int count
= 0;
157 m
= find_mode (name
);
160 error ("%s:%d: duplicate definition of mode \"%s\"",
161 trim_filename (file
), line
, name
);
162 error ("%s:%d: previous definition here", m
->file
, m
->line
);
166 m
= XNEW (struct mode_data
);
167 memcpy (m
, &blank_mode
, sizeof (struct mode_data
));
171 m
->file
= trim_filename (file
);
173 m
->counter
= count
++;
179 *htab_find_slot (modes_by_name
, m
, INSERT
) = m
;
185 hash_mode (const void *p
)
187 const struct mode_data
*m
= (const struct mode_data
*)p
;
188 return htab_hash_string (m
->name
);
192 eq_mode (const void *p
, const void *q
)
194 const struct mode_data
*a
= (const struct mode_data
*)p
;
195 const struct mode_data
*b
= (const struct mode_data
*)q
;
197 return !strcmp (a
->name
, b
->name
);
200 #define for_all_modes(C, M) \
201 for (C = 0; C < MAX_MODE_CLASS; C++) \
202 for (M = modes[C]; M; M = M->next)
204 static void ATTRIBUTE_UNUSED
205 new_adjust (const char *name
,
206 struct mode_adjust
**category
, const char *catname
,
207 const char *adjustment
,
208 enum mode_class required_class_from
,
209 enum mode_class required_class_to
,
210 const char *file
, unsigned int line
)
212 struct mode_data
*mode
= find_mode (name
);
213 struct mode_adjust
*a
;
215 file
= trim_filename (file
);
219 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
223 if (required_class_from
!= MODE_RANDOM
224 && (mode
->cl
< required_class_from
|| mode
->cl
> required_class_to
))
226 error ("%s:%d: mode \"%s\" is not among class {%s, %s}",
227 file
, line
, name
, mode_class_names
[required_class_from
] + 5,
228 mode_class_names
[required_class_to
] + 5);
232 for (a
= *category
; a
; a
= a
->next
)
235 error ("%s:%d: mode \"%s\" already has a %s adjustment",
236 file
, line
, name
, catname
);
237 error ("%s:%d: previous adjustment here", a
->file
, a
->line
);
241 a
= XNEW (struct mode_adjust
);
243 a
->adjustment
= adjustment
;
251 /* Diagnose failure to meet expectations in a partially filled out
253 enum requirement
{ SET
, UNSET
, OPTIONAL
};
255 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
260 error ("%s:%d: (%s) field %s must be set", \
261 file, line, mname, fname); \
265 error ("%s:%d: (%s) field %s must not be set", \
266 file, line, mname, fname); \
272 #define validate_field(M, F) \
273 validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
276 validate_mode (struct mode_data
*m
,
277 enum requirement r_precision
,
278 enum requirement r_bytesize
,
279 enum requirement r_component
,
280 enum requirement r_ncomponents
,
281 enum requirement r_format
)
283 validate_field (m
, precision
);
284 validate_field (m
, bytesize
);
285 validate_field (m
, component
);
286 validate_field (m
, ncomponents
);
287 validate_field (m
, format
);
289 #undef validate_field
290 #undef validate_field_
292 /* Given a partially-filled-out mode structure, figure out what we can
293 and fill the rest of it in; die if it isn't enough. */
295 complete_mode (struct mode_data
*m
)
297 unsigned int alignment
;
301 error ("%s:%d: mode with no name", m
->file
, m
->line
);
304 if (m
->cl
== MAX_MODE_CLASS
)
306 error ("%s:%d: %smode has no mode class", m
->file
, m
->line
, m
->name
);
313 /* Nothing more need be said. */
314 if (!strcmp (m
->name
, "VOID"))
317 validate_mode (m
, UNSET
, UNSET
, UNSET
, UNSET
, UNSET
);
326 /* Again, nothing more need be said. For historical reasons,
327 the size of a CC mode is four units. */
328 validate_mode (m
, UNSET
, UNSET
, UNSET
, UNSET
, UNSET
);
337 case MODE_DECIMAL_FLOAT
:
342 /* A scalar mode must have a byte size, may have a bit size,
343 and must not have components. A float mode must have a
345 validate_mode (m
, OPTIONAL
, SET
, UNSET
, UNSET
,
346 (m
->cl
== MODE_FLOAT
|| m
->cl
== MODE_DECIMAL_FLOAT
)
353 case MODE_PARTIAL_INT
:
354 /* A partial integer mode uses ->component to say what the
355 corresponding full-size integer mode is, and may also
356 specify a bit size. */
357 validate_mode (m
, OPTIONAL
, UNSET
, SET
, UNSET
, UNSET
);
359 m
->bytesize
= m
->component
->bytesize
;
364 case MODE_COMPLEX_INT
:
365 case MODE_COMPLEX_FLOAT
:
366 /* Complex modes should have a component indicated, but no more. */
367 validate_mode (m
, UNSET
, UNSET
, SET
, UNSET
, UNSET
);
369 if (m
->component
->precision
!= (unsigned int)-1)
370 m
->precision
= 2 * m
->component
->precision
;
371 m
->bytesize
= 2 * m
->component
->bytesize
;
374 case MODE_VECTOR_INT
:
375 case MODE_VECTOR_FLOAT
:
376 case MODE_VECTOR_FRACT
:
377 case MODE_VECTOR_UFRACT
:
378 case MODE_VECTOR_ACCUM
:
379 case MODE_VECTOR_UACCUM
:
380 /* Vector modes should have a component and a number of components. */
381 validate_mode (m
, UNSET
, UNSET
, SET
, SET
, UNSET
);
382 if (m
->component
->precision
!= (unsigned int)-1)
383 m
->precision
= m
->ncomponents
* m
->component
->precision
;
384 m
->bytesize
= m
->ncomponents
* m
->component
->bytesize
;
391 /* If not already specified, the mode alignment defaults to the largest
392 power of two that divides the size of the object. Complex types are
393 not more aligned than their contents. */
394 if (m
->cl
== MODE_COMPLEX_INT
|| m
->cl
== MODE_COMPLEX_FLOAT
)
395 alignment
= m
->component
->bytesize
;
397 alignment
= m
->bytesize
;
399 m
->alignment
= alignment
& (~alignment
+ 1);
401 /* If this mode has components, make the component mode point back
402 to this mode, for the sake of adjustments. */
405 m
->next_cont
= m
->component
->contained
;
406 m
->component
->contained
= m
;
411 complete_all_modes (void)
416 for_all_modes (cl
, m
)
420 /* For each mode in class CLASS, construct a corresponding complex mode. */
421 #define COMPLEX_MODES(C) make_complex_modes (MODE_##C, __FILE__, __LINE__)
423 make_complex_modes (enum mode_class cl
,
424 const char *file
, unsigned int line
)
428 enum mode_class cclass
= complex_class (cl
);
430 if (cclass
== MODE_RANDOM
)
433 for (m
= modes
[cl
]; m
; m
= m
->next
)
438 /* Skip BImode. FIXME: BImode probably shouldn't be MODE_INT. */
439 if (m
->precision
== 1)
442 m_len
= strlen (m
->name
);
443 /* The leading "1 +" is in case we prepend a "C" below. */
444 buf
= (char *) xmalloc (1 + m_len
+ 1);
446 /* Float complex modes are named SCmode, etc.
447 Int complex modes are named CSImode, etc.
448 This inconsistency should be eliminated. */
450 if (cl
== MODE_FLOAT
)
452 memcpy (buf
, m
->name
, m_len
+ 1);
453 p
= strchr (buf
, 'F');
454 if (p
== 0 && strchr (buf
, 'D') == 0)
456 error ("%s:%d: float mode \"%s\" has no 'F' or 'D'",
457 m
->file
, m
->line
, m
->name
);
467 memcpy (buf
+ 1, m
->name
, m_len
+ 1);
470 c
= new_mode (cclass
, buf
, file
, line
);
475 /* For all modes in class CL, construct vector modes of width
476 WIDTH, having as many components as necessary. */
477 #define VECTOR_MODES(C, W) make_vector_modes (MODE_##C, W, __FILE__, __LINE__)
478 static void ATTRIBUTE_UNUSED
479 make_vector_modes (enum mode_class cl
, unsigned int width
,
480 const char *file
, unsigned int line
)
485 unsigned int ncomponents
;
486 enum mode_class vclass
= vector_class (cl
);
488 if (vclass
== MODE_RANDOM
)
491 for (m
= modes
[cl
]; m
; m
= m
->next
)
493 /* Do not construct vector modes with only one element, or
494 vector modes where the element size doesn't divide the full
496 ncomponents
= width
/ m
->bytesize
;
499 if (width
% m
->bytesize
)
502 /* Skip QFmode and BImode. FIXME: this special case should
504 if (cl
== MODE_FLOAT
&& m
->bytesize
== 1)
506 if (cl
== MODE_INT
&& m
->precision
== 1)
509 if ((size_t)snprintf (buf
, sizeof buf
, "V%u%s", ncomponents
, m
->name
)
512 error ("%s:%d: mode name \"%s\" is too long",
513 m
->file
, m
->line
, m
->name
);
517 v
= new_mode (vclass
, xstrdup (buf
), file
, line
);
519 v
->ncomponents
= ncomponents
;
525 #define _SPECIAL_MODE(C, N) \
526 make_special_mode (MODE_##C, #N, __FILE__, __LINE__)
527 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
528 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
531 make_special_mode (enum mode_class cl
, const char *name
,
532 const char *file
, unsigned int line
)
534 new_mode (cl
, name
, file
, line
);
537 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
538 #define FRACTIONAL_INT_MODE(N, B, Y) \
539 make_int_mode (#N, B, Y, __FILE__, __LINE__)
542 make_int_mode (const char *name
,
543 unsigned int precision
, unsigned int bytesize
,
544 const char *file
, unsigned int line
)
546 struct mode_data
*m
= new_mode (MODE_INT
, name
, file
, line
);
547 m
->bytesize
= bytesize
;
548 m
->precision
= precision
;
551 #define FRACT_MODE(N, Y, F) \
552 make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
554 #define UFRACT_MODE(N, Y, F) \
555 make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
557 #define ACCUM_MODE(N, Y, I, F) \
558 make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
560 #define UACCUM_MODE(N, Y, I, F) \
561 make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
563 /* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
567 make_fixed_point_mode (enum mode_class cl
,
569 unsigned int bytesize
,
572 const char *file
, unsigned int line
)
574 struct mode_data
*m
= new_mode (cl
, name
, file
, line
);
575 m
->bytesize
= bytesize
;
580 #define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
581 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
582 make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
585 make_float_mode (const char *name
,
586 unsigned int precision
, unsigned int bytesize
,
588 const char *file
, unsigned int line
)
590 struct mode_data
*m
= new_mode (MODE_FLOAT
, name
, file
, line
);
591 m
->bytesize
= bytesize
;
592 m
->precision
= precision
;
596 #define DECIMAL_FLOAT_MODE(N, Y, F) \
597 FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
598 #define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F) \
599 make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
602 make_decimal_float_mode (const char *name
,
603 unsigned int precision
, unsigned int bytesize
,
605 const char *file
, unsigned int line
)
607 struct mode_data
*m
= new_mode (MODE_DECIMAL_FLOAT
, name
, file
, line
);
608 m
->bytesize
= bytesize
;
609 m
->precision
= precision
;
613 #define RESET_FLOAT_FORMAT(N, F) \
614 reset_float_format (#N, #F, __FILE__, __LINE__)
615 static void ATTRIBUTE_UNUSED
616 reset_float_format (const char *name
, const char *format
,
617 const char *file
, unsigned int line
)
619 struct mode_data
*m
= find_mode (name
);
622 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
625 if (m
->cl
!= MODE_FLOAT
&& m
->cl
!= MODE_DECIMAL_FLOAT
)
627 error ("%s:%d: mode \"%s\" is not a FLOAT class", file
, line
, name
);
633 /* Partial integer modes are specified by relation to a full integer mode.
634 For now, we do not attempt to narrow down their bit sizes. */
635 #define PARTIAL_INT_MODE(M) \
636 make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__)
637 static void ATTRIBUTE_UNUSED
638 make_partial_integer_mode (const char *base
, const char *name
,
639 unsigned int precision
,
640 const char *file
, unsigned int line
)
643 struct mode_data
*component
= find_mode (base
);
646 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
649 if (component
->cl
!= MODE_INT
)
651 error ("%s:%d: mode \"%s\" is not class INT", file
, line
, name
);
655 m
= new_mode (MODE_PARTIAL_INT
, name
, file
, line
);
656 m
->precision
= precision
;
657 m
->component
= component
;
660 /* A single vector mode can be specified by naming its component
661 mode and the number of components. */
662 #define VECTOR_MODE(C, M, N) \
663 make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
664 static void ATTRIBUTE_UNUSED
665 make_vector_mode (enum mode_class bclass
,
667 unsigned int ncomponents
,
668 const char *file
, unsigned int line
)
671 enum mode_class vclass
= vector_class (bclass
);
672 struct mode_data
*component
= find_mode (base
);
675 if (vclass
== MODE_RANDOM
)
679 error ("%s:%d: no mode \"%s\"", file
, line
, base
);
682 if (component
->cl
!= bclass
683 && (component
->cl
!= MODE_PARTIAL_INT
684 || bclass
!= MODE_INT
))
686 error ("%s:%d: mode \"%s\" is not class %s",
687 file
, line
, base
, mode_class_names
[bclass
] + 5);
691 if ((size_t)snprintf (namebuf
, sizeof namebuf
, "V%u%s",
692 ncomponents
, base
) >= sizeof namebuf
)
694 error ("%s:%d: mode name \"%s\" is too long",
699 v
= new_mode (vclass
, xstrdup (namebuf
), file
, line
);
700 v
->ncomponents
= ncomponents
;
701 v
->component
= component
;
705 #define _ADD_ADJUST(A, M, X, C1, C2) \
706 new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
708 #define ADJUST_BYTESIZE(M, X) _ADD_ADJUST (bytesize, M, X, RANDOM, RANDOM)
709 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST (alignment, M, X, RANDOM, RANDOM)
710 #define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST (format, M, X, FLOAT, FLOAT)
711 #define ADJUST_IBIT(M, X) _ADD_ADJUST (ibit, M, X, ACCUM, UACCUM)
712 #define ADJUST_FBIT(M, X) _ADD_ADJUST (fbit, M, X, FRACT, UACCUM)
717 #include "machmode.def"
722 /* Sort a list of modes into the order needed for the WIDER field:
723 major sort by precision, minor sort by component precision.
726 QI < HI < SI < DI < TI
727 V4QI < V2HI < V8QI < V4HI < V2SI.
729 If the precision is not set, sort by the bytesize. A mode with
730 precision set gets sorted before a mode without precision set, if
731 they have the same bytesize; this is the right thing because
732 the precision must always be smaller than the bytesize * BITS_PER_UNIT.
733 We don't have to do anything special to get this done -- an unset
734 precision shows up as (unsigned int)-1, i.e. UINT_MAX. */
736 cmp_modes (const void *a
, const void *b
)
738 const struct mode_data
*const m
= *(const struct mode_data
*const*)a
;
739 const struct mode_data
*const n
= *(const struct mode_data
*const*)b
;
741 if (m
->bytesize
> n
->bytesize
)
743 else if (m
->bytesize
< n
->bytesize
)
746 if (m
->precision
> n
->precision
)
748 else if (m
->precision
< n
->precision
)
751 if (!m
->component
&& !n
->component
)
753 if (m
->counter
< n
->counter
)
759 if (m
->component
->bytesize
> n
->component
->bytesize
)
761 else if (m
->component
->bytesize
< n
->component
->bytesize
)
764 if (m
->component
->precision
> n
->component
->precision
)
766 else if (m
->component
->precision
< n
->component
->precision
)
769 if (m
->counter
< n
->counter
)
776 calc_wider_mode (void)
780 struct mode_data
**sortbuf
;
781 unsigned int max_n_modes
= 0;
784 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
785 max_n_modes
= MAX (max_n_modes
, n_modes
[c
]);
787 /* Allocate max_n_modes + 1 entries to leave room for the extra null
788 pointer assigned after the qsort call below. */
789 sortbuf
= XALLOCAVEC (struct mode_data
*, max_n_modes
+ 1);
791 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
793 /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
794 However, we want these in textual order, and we have
795 precisely the reverse. */
796 if (c
== MODE_RANDOM
|| c
== MODE_CC
)
798 struct mode_data
*prev
, *next
;
800 for (prev
= 0, m
= modes
[c
]; m
; m
= next
)
802 m
->wider
= void_mode
;
804 /* this is nreverse */
816 for (i
= 0, m
= modes
[c
]; m
; i
++, m
= m
->next
)
819 qsort (sortbuf
, i
, sizeof (struct mode_data
*), cmp_modes
);
822 for (j
= 0; j
< i
; j
++)
824 sortbuf
[j
]->next
= sortbuf
[j
+ 1];
825 if (c
== MODE_PARTIAL_INT
)
826 sortbuf
[j
]->wider
= sortbuf
[j
]->component
;
828 sortbuf
[j
]->wider
= sortbuf
[j
]->next
;
831 modes
[c
] = sortbuf
[0];
836 /* Output routines. */
838 #define tagged_printf(FMT, ARG, TAG) do { \
839 int count_ = printf (" " FMT ",", ARG); \
840 printf ("%*s/* %s */\n", 27 - count_, "", TAG); \
843 #define print_decl(TYPE, NAME, ASIZE) \
844 puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
846 #define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY) \
847 printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n", \
848 adj_##CATEGORY ? "" : "const ")
850 #define print_closer() puts ("};")
852 /* Compute the max bitsize of some of the classes of integers. It may
853 be that there are needs for the other integer classes, and this
854 code is easy to extend. */
858 unsigned int max
, mmax
;
863 for (max
= 1, i
= modes
[MODE_INT
]; i
; i
= i
->next
)
864 if (max
< i
->bytesize
)
867 for (max
= 1, i
= modes
[MODE_PARTIAL_INT
]; i
; i
= i
->next
)
868 if (max
< i
->bytesize
)
872 printf ("#define MAX_BITSIZE_MODE_ANY_INT %d*BITS_PER_UNIT\n", mmax
);
875 for (j
= 0; j
< MAX_MODE_CLASS
; j
++)
876 for (i
= modes
[j
]; i
; i
= i
->next
)
877 if (mmax
< i
->bytesize
)
879 printf ("#define MAX_BITSIZE_MODE_ANY_MODE %d*BITS_PER_UNIT\n", mmax
);
883 emit_insn_modes_h (void)
886 struct mode_data
*m
, *first
, *last
;
888 printf ("/* Generated automatically from machmode.def%s%s\n",
889 HAVE_EXTRA_MODES
? " and " : "",
895 #ifndef GCC_INSN_MODES_H\n\
896 #define GCC_INSN_MODES_H\n\
898 enum machine_mode\n{");
900 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
901 for (m
= modes
[c
]; m
; m
= m
->next
)
903 int count_
= printf (" %smode,", m
->name
);
904 printf ("%*s/* %s:%d */\n", 27 - count_
, "",
905 trim_filename (m
->file
), m
->line
);
908 puts (" MAX_MACHINE_MODE,\n");
910 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
914 for (m
= first
; m
; last
= m
, m
= m
->next
)
917 /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
918 end will try to use it for bitfields in structures and the
919 like, which we do not want. Only the target md file should
920 generate BImode widgets. */
921 if (first
&& first
->precision
== 1)
925 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
926 mode_class_names
[c
], first
->name
,
927 mode_class_names
[c
], last
->name
);
929 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
930 mode_class_names
[c
], void_mode
->name
,
931 mode_class_names
[c
], void_mode
->name
);
935 NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
938 /* I can't think of a better idea, can you? */
939 printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize
? "" : " const");
940 printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment
? "" : " const");
941 #if 0 /* disabled for backward compatibility, temporary */
942 printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format
? "" :" const");
944 printf ("#define CONST_MODE_IBIT%s\n", adj_ibit
? "" : " const");
945 printf ("#define CONST_MODE_FBIT%s\n", adj_fbit
? "" : " const");
949 #endif /* insn-modes.h */");
953 emit_insn_modes_c_header (void)
955 printf ("/* Generated automatically from machmode.def%s%s\n",
956 HAVE_EXTRA_MODES
? " and " : "",
962 #include \"config.h\"\n\
963 #include \"system.h\"\n\
964 #include \"coretypes.h\"\n\
966 #include \"machmode.h\"\n\
967 #include \"real.h\"");
971 emit_min_insn_modes_c_header (void)
973 printf ("/* Generated automatically from machmode.def%s%s\n",
974 HAVE_EXTRA_MODES
? " and " : "",
980 #include \"bconfig.h\"\n\
981 #include \"system.h\"\n\
982 #include \"machmode.h\"");
986 emit_mode_name (void)
991 print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
994 printf (" \"%s\",\n", m
->name
);
1000 emit_mode_class (void)
1003 struct mode_data
*m
;
1005 print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
1007 for_all_modes (c
, m
)
1008 tagged_printf ("%s", mode_class_names
[m
->cl
], m
->name
);
1014 emit_mode_precision (void)
1017 struct mode_data
*m
;
1019 print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
1021 for_all_modes (c
, m
)
1022 if (m
->precision
!= (unsigned int)-1)
1023 tagged_printf ("%u", m
->precision
, m
->name
);
1025 tagged_printf ("%u*BITS_PER_UNIT", m
->bytesize
, m
->name
);
1031 emit_mode_size (void)
1034 struct mode_data
*m
;
1036 print_maybe_const_decl ("%sunsigned char", "mode_size",
1037 "NUM_MACHINE_MODES", bytesize
);
1039 for_all_modes (c
, m
)
1040 tagged_printf ("%u", m
->bytesize
, m
->name
);
1046 emit_mode_nunits (void)
1049 struct mode_data
*m
;
1051 print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1053 for_all_modes (c
, m
)
1054 tagged_printf ("%u", m
->ncomponents
, m
->name
);
1060 emit_mode_wider (void)
1063 struct mode_data
*m
;
1065 print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1067 for_all_modes (c
, m
)
1068 tagged_printf ("%smode",
1069 m
->wider
? m
->wider
->name
: void_mode
->name
,
1073 print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1075 for_all_modes (c
, m
)
1077 struct mode_data
* m2
;
1080 m2
&& m2
!= void_mode
;
1083 if (m2
->bytesize
< 2 * m
->bytesize
)
1085 if (m
->precision
!= (unsigned int) -1)
1087 if (m2
->precision
!= 2 * m
->precision
)
1092 if (m2
->precision
!= (unsigned int) -1)
1096 /* For vectors we want twice the number of components,
1097 with the same element type. */
1098 if (m
->cl
== MODE_VECTOR_INT
1099 || m
->cl
== MODE_VECTOR_FLOAT
1100 || m
->cl
== MODE_VECTOR_FRACT
1101 || m
->cl
== MODE_VECTOR_UFRACT
1102 || m
->cl
== MODE_VECTOR_ACCUM
1103 || m
->cl
== MODE_VECTOR_UACCUM
)
1105 if (m2
->ncomponents
!= 2 * m
->ncomponents
)
1107 if (m
->component
!= m2
->component
)
1113 if (m2
== void_mode
)
1115 tagged_printf ("%smode",
1116 m2
? m2
->name
: void_mode
->name
,
1124 emit_mode_mask (void)
1127 struct mode_data
*m
;
1129 print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1130 "NUM_MACHINE_MODES");
1132 #define MODE_MASK(m) \\\n\
1133 ((m) >= HOST_BITS_PER_WIDE_INT) \\\n\
1134 ? ~(unsigned HOST_WIDE_INT) 0 \\\n\
1135 : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
1137 for_all_modes (c
, m
)
1138 if (m
->precision
!= (unsigned int)-1)
1139 tagged_printf ("MODE_MASK (%u)", m
->precision
, m
->name
);
1141 tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m
->bytesize
, m
->name
);
1143 puts ("#undef MODE_MASK");
1148 emit_mode_inner (void)
1151 struct mode_data
*m
;
1153 print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1155 for_all_modes (c
, m
)
1156 tagged_printf ("%smode",
1157 c
!= MODE_PARTIAL_INT
&& m
->component
1158 ? m
->component
->name
: void_mode
->name
,
1165 emit_mode_base_align (void)
1168 struct mode_data
*m
;
1170 print_maybe_const_decl ("%sunsigned char",
1171 "mode_base_align", "NUM_MACHINE_MODES",
1174 for_all_modes (c
, m
)
1175 tagged_printf ("%u", m
->alignment
, m
->name
);
1181 emit_class_narrowest_mode (void)
1185 print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1187 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
1188 /* Bleah, all this to get the comment right for MIN_MODE_INT. */
1189 tagged_printf ("MIN_%s", mode_class_names
[c
],
1191 ? (modes
[c
]->precision
!= 1
1194 ? modes
[c
]->next
->name
1202 emit_real_format_for_mode (void)
1204 struct mode_data
*m
;
1206 /* The entities pointed to by this table are constant, whether
1207 or not the table itself is constant.
1209 For backward compatibility this table is always writable
1210 (several targets modify it in TARGET_OPTION_OVERRIDE). FIXME:
1211 convert all said targets to use ADJUST_FORMAT instead. */
1213 print_maybe_const_decl ("const struct real_format *%s",
1214 "real_format_for_mode",
1215 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1218 print_decl ("struct real_format *\n", "real_format_for_mode",
1219 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1220 "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1223 /* The beginning of the table is entries for float modes. */
1224 for (m
= modes
[MODE_FLOAT
]; m
; m
= m
->next
)
1225 if (!strcmp (m
->format
, "0"))
1226 tagged_printf ("%s", m
->format
, m
->name
);
1228 tagged_printf ("&%s", m
->format
, m
->name
);
1230 /* The end of the table is entries for decimal float modes. */
1231 for (m
= modes
[MODE_DECIMAL_FLOAT
]; m
; m
= m
->next
)
1232 if (!strcmp (m
->format
, "0"))
1233 tagged_printf ("%s", m
->format
, m
->name
);
1235 tagged_printf ("&%s", m
->format
, m
->name
);
1241 emit_mode_adjustments (void)
1243 struct mode_adjust
*a
;
1244 struct mode_data
*m
;
1248 \ninit_adjust_machine_modes (void)\
1250 \n size_t s ATTRIBUTE_UNUSED;");
1252 /* Size adjustments must be propagated to all containing modes.
1253 A size adjustment forces us to recalculate the alignment too. */
1254 for (a
= adj_bytesize
; a
; a
= a
->next
)
1256 printf ("\n /* %s:%d */\n s = %s;\n",
1257 a
->file
, a
->line
, a
->adjustment
);
1258 printf (" mode_size[%smode] = s;\n", a
->mode
->name
);
1259 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1262 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1266 case MODE_COMPLEX_INT
:
1267 case MODE_COMPLEX_FLOAT
:
1268 printf (" mode_size[%smode] = 2*s;\n", m
->name
);
1269 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1273 case MODE_VECTOR_INT
:
1274 case MODE_VECTOR_FLOAT
:
1275 case MODE_VECTOR_FRACT
:
1276 case MODE_VECTOR_UFRACT
:
1277 case MODE_VECTOR_ACCUM
:
1278 case MODE_VECTOR_UACCUM
:
1279 printf (" mode_size[%smode] = %d*s;\n",
1280 m
->name
, m
->ncomponents
);
1281 printf (" mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1282 m
->name
, m
->ncomponents
, m
->ncomponents
);
1287 "mode %s is neither vector nor complex but contains %s",
1288 m
->name
, a
->mode
->name
);
1294 /* Alignment adjustments propagate too.
1295 ??? This may not be the right thing for vector modes. */
1296 for (a
= adj_alignment
; a
; a
= a
->next
)
1298 printf ("\n /* %s:%d */\n s = %s;\n",
1299 a
->file
, a
->line
, a
->adjustment
);
1300 printf (" mode_base_align[%smode] = s;\n", a
->mode
->name
);
1302 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1306 case MODE_COMPLEX_INT
:
1307 case MODE_COMPLEX_FLOAT
:
1308 printf (" mode_base_align[%smode] = s;\n", m
->name
);
1311 case MODE_VECTOR_INT
:
1312 case MODE_VECTOR_FLOAT
:
1313 case MODE_VECTOR_FRACT
:
1314 case MODE_VECTOR_UFRACT
:
1315 case MODE_VECTOR_ACCUM
:
1316 case MODE_VECTOR_UACCUM
:
1317 printf (" mode_base_align[%smode] = %d*s;\n",
1318 m
->name
, m
->ncomponents
);
1323 "mode %s is neither vector nor complex but contains %s",
1324 m
->name
, a
->mode
->name
);
1330 /* Ibit adjustments don't have to propagate. */
1331 for (a
= adj_ibit
; a
; a
= a
->next
)
1333 printf ("\n /* %s:%d */\n s = %s;\n",
1334 a
->file
, a
->line
, a
->adjustment
);
1335 printf (" mode_ibit[%smode] = s;\n", a
->mode
->name
);
1338 /* Fbit adjustments don't have to propagate. */
1339 for (a
= adj_fbit
; a
; a
= a
->next
)
1341 printf ("\n /* %s:%d */\n s = %s;\n",
1342 a
->file
, a
->line
, a
->adjustment
);
1343 printf (" mode_fbit[%smode] = s;\n", a
->mode
->name
);
1346 /* Real mode formats don't have to propagate anywhere. */
1347 for (a
= adj_format
; a
; a
= a
->next
)
1348 printf ("\n /* %s:%d */\n REAL_MODE_FORMAT (%smode) = %s;\n",
1349 a
->file
, a
->line
, a
->mode
->name
, a
->adjustment
);
1354 /* Emit ibit for all modes. */
1357 emit_mode_ibit (void)
1360 struct mode_data
*m
;
1362 print_maybe_const_decl ("%sunsigned char",
1363 "mode_ibit", "NUM_MACHINE_MODES",
1366 for_all_modes (c
, m
)
1367 tagged_printf ("%u", m
->ibit
, m
->name
);
1372 /* Emit fbit for all modes. */
1375 emit_mode_fbit (void)
1378 struct mode_data
*m
;
1380 print_maybe_const_decl ("%sunsigned char",
1381 "mode_fbit", "NUM_MACHINE_MODES",
1384 for_all_modes (c
, m
)
1385 tagged_printf ("%u", m
->fbit
, m
->name
);
1392 emit_insn_modes_c (void)
1394 emit_insn_modes_c_header ();
1397 emit_mode_precision ();
1399 emit_mode_nunits ();
1403 emit_mode_base_align ();
1404 emit_class_narrowest_mode ();
1405 emit_real_format_for_mode ();
1406 emit_mode_adjustments ();
1412 emit_min_insn_modes_c (void)
1414 emit_min_insn_modes_c_header ();
1418 emit_class_narrowest_mode ();
1421 /* Master control. */
1423 main (int argc
, char **argv
)
1425 bool gen_header
= false, gen_min
= false;
1430 else if (argc
== 2 && !strcmp (argv
[1], "-h"))
1432 else if (argc
== 2 && !strcmp (argv
[1], "-m"))
1436 error ("usage: %s [-h|-m] > file", progname
);
1437 return FATAL_EXIT_CODE
;
1440 modes_by_name
= htab_create_alloc (64, hash_mode
, eq_mode
, 0, xcalloc
, free
);
1443 complete_all_modes ();
1446 return FATAL_EXIT_CODE
;
1451 emit_insn_modes_h ();
1453 emit_min_insn_modes_c ();
1455 emit_insn_modes_c ();
1457 if (fflush (stdout
) || fclose (stdout
))
1458 return FATAL_EXIT_CODE
;
1459 return SUCCESS_EXIT_CODE
;