1 /* Generate the machine mode enumeration and associated tables.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
27 /* enum mode_class is normally defined by machmode.h but we can't
28 include that header here. */
29 #include "mode-classes.def"
31 #define DEF_MODE_CLASS(M) M
32 enum mode_class
{ MODE_CLASSES
, MAX_MODE_CLASS
};
35 /* Text names of mode classes, for output. */
36 #define DEF_MODE_CLASS(M) #M
37 static const char *const mode_class_names
[MAX_MODE_CLASS
] =
44 #ifdef EXTRA_MODES_FILE
45 # define HAVE_EXTRA_MODES 1
47 # define HAVE_EXTRA_MODES 0
48 # define EXTRA_MODES_FILE ""
51 /* Data structure for building up what we know about a mode.
52 They're clustered by mode class. */
55 struct mode_data
*next
; /* next this class - arbitrary order */
57 const char *name
; /* printable mode name -- SI, not SImode */
58 enum mode_class cl
; /* this mode class */
59 unsigned int precision
; /* size in bits, equiv to TYPE_PRECISION */
60 unsigned int bytesize
; /* storage size in addressable units */
61 unsigned int ncomponents
; /* number of subunits */
62 unsigned int alignment
; /* mode alignment */
63 const char *format
; /* floating point format - float modes only */
65 struct mode_data
*component
; /* mode of components */
66 struct mode_data
*wider
; /* next wider mode */
67 struct mode_data
*wider_2x
; /* 2x wider mode */
69 struct mode_data
*contained
; /* Pointer to list of modes that have
70 this mode as a component. */
71 struct mode_data
*next_cont
; /* Next mode in that list. */
73 const char *file
; /* file and line of definition, */
74 unsigned int line
; /* for error reporting */
75 unsigned int counter
; /* Rank ordering of modes */
76 unsigned int ibit
; /* the number of integral bits */
77 unsigned int fbit
; /* the number of fractional bits */
80 static struct mode_data
*modes
[MAX_MODE_CLASS
];
81 static unsigned int n_modes
[MAX_MODE_CLASS
];
82 static struct mode_data
*void_mode
;
84 static const struct mode_data blank_mode
= {
85 0, "<unknown>", MAX_MODE_CLASS
,
88 "<unknown>", 0, 0, 0, 0
91 static htab_t modes_by_name
;
93 /* Data structure for recording target-specified runtime adjustments
94 to a particular mode. We support varying the byte size, the
95 alignment, and the floating point format. */
98 struct mode_adjust
*next
;
99 struct mode_data
*mode
;
100 const char *adjustment
;
106 static struct mode_adjust
*adj_bytesize
;
107 static struct mode_adjust
*adj_alignment
;
108 static struct mode_adjust
*adj_format
;
109 static struct mode_adjust
*adj_ibit
;
110 static struct mode_adjust
*adj_fbit
;
112 /* Mode class operations. */
113 static enum mode_class
114 complex_class (enum mode_class c
)
118 case MODE_INT
: return MODE_COMPLEX_INT
;
119 case MODE_FLOAT
: return MODE_COMPLEX_FLOAT
;
121 error ("no complex class for class %s", mode_class_names
[c
]);
126 static enum mode_class
127 vector_class (enum mode_class cl
)
131 case MODE_INT
: return MODE_VECTOR_INT
;
132 case MODE_FLOAT
: return MODE_VECTOR_FLOAT
;
133 case MODE_FRACT
: return MODE_VECTOR_FRACT
;
134 case MODE_UFRACT
: return MODE_VECTOR_UFRACT
;
135 case MODE_ACCUM
: return MODE_VECTOR_ACCUM
;
136 case MODE_UACCUM
: return MODE_VECTOR_UACCUM
;
138 error ("no vector class for class %s", mode_class_names
[cl
]);
143 /* Utility routines. */
144 static inline struct mode_data
*
145 find_mode (const char *name
)
147 struct mode_data key
;
150 return (struct mode_data
*) htab_find (modes_by_name
, &key
);
153 static struct mode_data
*
154 new_mode (enum mode_class cl
, const char *name
,
155 const char *file
, unsigned int line
)
158 static unsigned int count
= 0;
160 m
= find_mode (name
);
163 error ("%s:%d: duplicate definition of mode \"%s\"",
164 trim_filename (file
), line
, name
);
165 error ("%s:%d: previous definition here", m
->file
, m
->line
);
169 m
= XNEW (struct mode_data
);
170 memcpy (m
, &blank_mode
, sizeof (struct mode_data
));
174 m
->file
= trim_filename (file
);
176 m
->counter
= count
++;
182 *htab_find_slot (modes_by_name
, m
, INSERT
) = m
;
188 hash_mode (const void *p
)
190 const struct mode_data
*m
= (const struct mode_data
*)p
;
191 return htab_hash_string (m
->name
);
195 eq_mode (const void *p
, const void *q
)
197 const struct mode_data
*a
= (const struct mode_data
*)p
;
198 const struct mode_data
*b
= (const struct mode_data
*)q
;
200 return !strcmp (a
->name
, b
->name
);
203 #define for_all_modes(C, M) \
204 for (C = 0; C < MAX_MODE_CLASS; C++) \
205 for (M = modes[C]; M; M = M->next)
207 static void ATTRIBUTE_UNUSED
208 new_adjust (const char *name
,
209 struct mode_adjust
**category
, const char *catname
,
210 const char *adjustment
,
211 enum mode_class required_class_from
,
212 enum mode_class required_class_to
,
213 const char *file
, unsigned int line
)
215 struct mode_data
*mode
= find_mode (name
);
216 struct mode_adjust
*a
;
218 file
= trim_filename (file
);
222 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
226 if (required_class_from
!= MODE_RANDOM
227 && (mode
->cl
< required_class_from
|| mode
->cl
> required_class_to
))
229 error ("%s:%d: mode \"%s\" is not among class {%s, %s}",
230 file
, line
, name
, mode_class_names
[required_class_from
] + 5,
231 mode_class_names
[required_class_to
] + 5);
235 for (a
= *category
; a
; a
= a
->next
)
238 error ("%s:%d: mode \"%s\" already has a %s adjustment",
239 file
, line
, name
, catname
);
240 error ("%s:%d: previous adjustment here", a
->file
, a
->line
);
244 a
= XNEW (struct mode_adjust
);
246 a
->adjustment
= adjustment
;
254 /* Diagnose failure to meet expectations in a partially filled out
256 enum requirement
{ SET
, UNSET
, OPTIONAL
};
258 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
263 error ("%s:%d: (%s) field %s must be set", \
264 file, line, mname, fname); \
268 error ("%s:%d: (%s) field %s must not be set", \
269 file, line, mname, fname); \
275 #define validate_field(M, F) \
276 validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
279 validate_mode (struct mode_data
*m
,
280 enum requirement r_precision
,
281 enum requirement r_bytesize
,
282 enum requirement r_component
,
283 enum requirement r_ncomponents
,
284 enum requirement r_format
)
286 validate_field (m
, precision
);
287 validate_field (m
, bytesize
);
288 validate_field (m
, component
);
289 validate_field (m
, ncomponents
);
290 validate_field (m
, format
);
292 #undef validate_field
293 #undef validate_field_
295 /* Given a partially-filled-out mode structure, figure out what we can
296 and fill the rest of it in; die if it isn't enough. */
298 complete_mode (struct mode_data
*m
)
300 unsigned int alignment
;
304 error ("%s:%d: mode with no name", m
->file
, m
->line
);
307 if (m
->cl
== MAX_MODE_CLASS
)
309 error ("%s:%d: %smode has no mode class", m
->file
, m
->line
, m
->name
);
316 /* Nothing more need be said. */
317 if (!strcmp (m
->name
, "VOID"))
320 validate_mode (m
, UNSET
, UNSET
, UNSET
, UNSET
, UNSET
);
329 /* Again, nothing more need be said. For historical reasons,
330 the size of a CC mode is four units. */
331 validate_mode (m
, UNSET
, UNSET
, UNSET
, UNSET
, UNSET
);
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
;
365 m
->component
= 0; /* ??? preserve this */
368 case MODE_COMPLEX_INT
:
369 case MODE_COMPLEX_FLOAT
:
370 /* Complex modes should have a component indicated, but no more. */
371 validate_mode (m
, UNSET
, UNSET
, SET
, UNSET
, UNSET
);
373 if (m
->component
->precision
!= (unsigned int)-1)
374 m
->precision
= 2 * m
->component
->precision
;
375 m
->bytesize
= 2 * m
->component
->bytesize
;
378 case MODE_VECTOR_INT
:
379 case MODE_VECTOR_FLOAT
:
380 case MODE_VECTOR_FRACT
:
381 case MODE_VECTOR_UFRACT
:
382 case MODE_VECTOR_ACCUM
:
383 case MODE_VECTOR_UACCUM
:
384 /* Vector modes should have a component and a number of components. */
385 validate_mode (m
, UNSET
, UNSET
, SET
, SET
, UNSET
);
386 if (m
->component
->precision
!= (unsigned int)-1)
387 m
->precision
= m
->ncomponents
* m
->component
->precision
;
388 m
->bytesize
= m
->ncomponents
* m
->component
->bytesize
;
395 /* If not already specified, the mode alignment defaults to the largest
396 power of two that divides the size of the object. Complex types are
397 not more aligned than their contents. */
398 if (m
->cl
== MODE_COMPLEX_INT
|| m
->cl
== MODE_COMPLEX_FLOAT
)
399 alignment
= m
->component
->bytesize
;
401 alignment
= m
->bytesize
;
403 m
->alignment
= alignment
& (~alignment
+ 1);
405 /* If this mode has components, make the component mode point back
406 to this mode, for the sake of adjustments. */
409 m
->next_cont
= m
->component
->contained
;
410 m
->component
->contained
= m
;
415 complete_all_modes (void)
420 for_all_modes (cl
, m
)
424 /* For each mode in class CLASS, construct a corresponding complex mode. */
425 #define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
427 make_complex_modes (enum mode_class cl
,
428 const char *file
, unsigned int line
)
433 enum mode_class cclass
= complex_class (cl
);
435 if (cclass
== MODE_RANDOM
)
438 for (m
= modes
[cl
]; m
; m
= m
->next
)
440 /* Skip BImode. FIXME: BImode probably shouldn't be MODE_INT. */
441 if (m
->precision
== 1)
444 if (strlen (m
->name
) >= sizeof buf
)
446 error ("%s:%d:mode name \"%s\" is too long",
447 m
->file
, m
->line
, m
->name
);
451 /* Float complex modes are named SCmode, etc.
452 Int complex modes are named CSImode, etc.
453 This inconsistency should be eliminated. */
454 if (cl
== MODE_FLOAT
)
457 strncpy (buf
, m
->name
, sizeof buf
);
458 p
= strchr (buf
, 'F');
460 q
= strchr (buf
, 'D');
461 if (p
== 0 && q
== 0)
463 error ("%s:%d: float mode \"%s\" has no 'F' or 'D'",
464 m
->file
, m
->line
, m
->name
);
471 snprintf (buf
, sizeof buf
, "C%s", m
->name
);
474 snprintf (buf
, sizeof buf
, "C%s", m
->name
);
476 c
= new_mode (cclass
, xstrdup (buf
), file
, line
);
481 /* For all modes in class CL, construct vector modes of width
482 WIDTH, having as many components as necessary. */
483 #define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
484 static void ATTRIBUTE_UNUSED
485 make_vector_modes (enum mode_class cl
, unsigned int width
,
486 const char *file
, unsigned int line
)
491 unsigned int ncomponents
;
492 enum mode_class vclass
= vector_class (cl
);
494 if (vclass
== MODE_RANDOM
)
497 for (m
= modes
[cl
]; m
; m
= m
->next
)
499 /* Do not construct vector modes with only one element, or
500 vector modes where the element size doesn't divide the full
502 ncomponents
= width
/ m
->bytesize
;
505 if (width
% m
->bytesize
)
508 /* Skip QFmode and BImode. FIXME: this special case should
510 if (cl
== MODE_FLOAT
&& m
->bytesize
== 1)
512 if (cl
== MODE_INT
&& m
->precision
== 1)
515 if ((size_t)snprintf (buf
, sizeof buf
, "V%u%s", ncomponents
, m
->name
)
518 error ("%s:%d: mode name \"%s\" is too long",
519 m
->file
, m
->line
, m
->name
);
523 v
= new_mode (vclass
, xstrdup (buf
), file
, line
);
525 v
->ncomponents
= ncomponents
;
531 #define _SPECIAL_MODE(C, N) make_special_mode(MODE_##C, #N, __FILE__, __LINE__)
532 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
533 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
536 make_special_mode (enum mode_class cl
, const char *name
,
537 const char *file
, unsigned int line
)
539 new_mode (cl
, name
, file
, line
);
542 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
543 #define FRACTIONAL_INT_MODE(N, B, Y) \
544 make_int_mode (#N, B, Y, __FILE__, __LINE__)
547 make_int_mode (const char *name
,
548 unsigned int precision
, unsigned int bytesize
,
549 const char *file
, unsigned int line
)
551 struct mode_data
*m
= new_mode (MODE_INT
, name
, file
, line
);
552 m
->bytesize
= bytesize
;
553 m
->precision
= precision
;
556 #define FRACT_MODE(N, Y, F) \
557 make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
559 #define UFRACT_MODE(N, Y, F) \
560 make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
562 #define ACCUM_MODE(N, Y, I, F) \
563 make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
565 #define UACCUM_MODE(N, Y, I, F) \
566 make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
568 /* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
572 make_fixed_point_mode (enum mode_class cl
,
574 unsigned int bytesize
,
577 const char *file
, unsigned int line
)
579 struct mode_data
*m
= new_mode (cl
, name
, file
, line
);
580 m
->bytesize
= bytesize
;
585 #define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
586 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
587 make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
590 make_float_mode (const char *name
,
591 unsigned int precision
, unsigned int bytesize
,
593 const char *file
, unsigned int line
)
595 struct mode_data
*m
= new_mode (MODE_FLOAT
, name
, file
, line
);
596 m
->bytesize
= bytesize
;
597 m
->precision
= precision
;
601 #define DECIMAL_FLOAT_MODE(N, Y, F) \
602 FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
603 #define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F) \
604 make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
607 make_decimal_float_mode (const char *name
,
608 unsigned int precision
, unsigned int bytesize
,
610 const char *file
, unsigned int line
)
612 struct mode_data
*m
= new_mode (MODE_DECIMAL_FLOAT
, name
, file
, line
);
613 m
->bytesize
= bytesize
;
614 m
->precision
= precision
;
618 #define RESET_FLOAT_FORMAT(N, F) \
619 reset_float_format (#N, #F, __FILE__, __LINE__)
620 static void ATTRIBUTE_UNUSED
621 reset_float_format (const char *name
, const char *format
,
622 const char *file
, unsigned int line
)
624 struct mode_data
*m
= find_mode (name
);
627 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
630 if (m
->cl
!= MODE_FLOAT
&& m
->cl
!= MODE_DECIMAL_FLOAT
)
632 error ("%s:%d: mode \"%s\" is not a FLOAT class", file
, line
, name
);
638 /* Partial integer modes are specified by relation to a full integer mode.
639 For now, we do not attempt to narrow down their bit sizes. */
640 #define PARTIAL_INT_MODE(M) \
641 make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__)
642 static void ATTRIBUTE_UNUSED
643 make_partial_integer_mode (const char *base
, const char *name
,
644 unsigned int precision
,
645 const char *file
, unsigned int line
)
648 struct mode_data
*component
= find_mode (base
);
651 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
654 if (component
->cl
!= MODE_INT
)
656 error ("%s:%d: mode \"%s\" is not class INT", file
, line
, name
);
660 m
= new_mode (MODE_PARTIAL_INT
, name
, file
, line
);
661 m
->precision
= precision
;
662 m
->component
= component
;
665 /* A single vector mode can be specified by naming its component
666 mode and the number of components. */
667 #define VECTOR_MODE(C, M, N) \
668 make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
669 static void ATTRIBUTE_UNUSED
670 make_vector_mode (enum mode_class bclass
,
672 unsigned int ncomponents
,
673 const char *file
, unsigned int line
)
676 enum mode_class vclass
= vector_class (bclass
);
677 struct mode_data
*component
= find_mode (base
);
680 if (vclass
== MODE_RANDOM
)
684 error ("%s:%d: no mode \"%s\"", file
, line
, base
);
687 if (component
->cl
!= bclass
688 && (component
->cl
!= MODE_PARTIAL_INT
689 || bclass
!= MODE_INT
))
691 error ("%s:%d: mode \"%s\" is not class %s",
692 file
, line
, base
, mode_class_names
[bclass
] + 5);
696 if ((size_t)snprintf (namebuf
, sizeof namebuf
, "V%u%s",
697 ncomponents
, base
) >= sizeof namebuf
)
699 error ("%s:%d: mode name \"%s\" is too long",
704 v
= new_mode (vclass
, xstrdup (namebuf
), file
, line
);
705 v
->ncomponents
= ncomponents
;
706 v
->component
= component
;
710 #define _ADD_ADJUST(A, M, X, C1, C2) \
711 new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
713 #define ADJUST_BYTESIZE(M, X) _ADD_ADJUST(bytesize, M, X, RANDOM, RANDOM)
714 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST(alignment, M, X, RANDOM, RANDOM)
715 #define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST(format, M, X, FLOAT, FLOAT)
716 #define ADJUST_IBIT(M, X) _ADD_ADJUST(ibit, M, X, ACCUM, UACCUM)
717 #define ADJUST_FBIT(M, X) _ADD_ADJUST(fbit, M, X, FRACT, UACCUM)
722 #include "machmode.def"
727 /* Sort a list of modes into the order needed for the WIDER field:
728 major sort by precision, minor sort by component precision.
731 QI < HI < SI < DI < TI
732 V4QI < V2HI < V8QI < V4HI < V2SI.
734 If the precision is not set, sort by the bytesize. A mode with
735 precision set gets sorted before a mode without precision set, if
736 they have the same bytesize; this is the right thing because
737 the precision must always be smaller than the bytesize * BITS_PER_UNIT.
738 We don't have to do anything special to get this done -- an unset
739 precision shows up as (unsigned int)-1, i.e. UINT_MAX. */
741 cmp_modes (const void *a
, const void *b
)
743 struct mode_data
*m
= *(struct mode_data
**)a
;
744 struct mode_data
*n
= *(struct mode_data
**)b
;
746 if (m
->bytesize
> n
->bytesize
)
748 else if (m
->bytesize
< n
->bytesize
)
751 if (m
->precision
> n
->precision
)
753 else if (m
->precision
< n
->precision
)
756 if (!m
->component
&& !n
->component
)
758 if (m
->counter
< n
->counter
)
764 if (m
->component
->bytesize
> n
->component
->bytesize
)
766 else if (m
->component
->bytesize
< n
->component
->bytesize
)
769 if (m
->component
->precision
> n
->component
->precision
)
771 else if (m
->component
->precision
< n
->component
->precision
)
774 if (m
->counter
< n
->counter
)
781 calc_wider_mode (void)
785 struct mode_data
**sortbuf
;
786 unsigned int max_n_modes
= 0;
789 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
790 max_n_modes
= MAX (max_n_modes
, n_modes
[c
]);
792 /* Allocate max_n_modes + 1 entries to leave room for the extra null
793 pointer assigned after the qsort call below. */
794 sortbuf
= (struct mode_data
**) alloca ((max_n_modes
+ 1) * sizeof (struct mode_data
*));
796 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
798 /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
799 However, we want these in textual order, and we have
800 precisely the reverse. */
801 if (c
== MODE_RANDOM
|| c
== MODE_CC
)
803 struct mode_data
*prev
, *next
;
805 for (prev
= 0, m
= modes
[c
]; m
; m
= next
)
807 m
->wider
= void_mode
;
808 m
->wider_2x
= void_mode
;
810 /* this is nreverse */
822 for (i
= 0, m
= modes
[c
]; m
; i
++, m
= m
->next
)
825 qsort (sortbuf
, i
, sizeof (struct mode_data
*), cmp_modes
);
828 for (j
= 0; j
< i
; j
++)
829 sortbuf
[j
]->next
= sortbuf
[j
]->wider
= sortbuf
[j
+ 1];
832 modes
[c
] = sortbuf
[0];
837 /* Output routines. */
839 #define tagged_printf(FMT, ARG, TAG) do { \
840 int count_ = printf (" " FMT ",", ARG); \
841 printf ("%*s/* %s */\n", 27 - count_, "", TAG); \
844 #define print_decl(TYPE, NAME, ASIZE) \
845 puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
847 #define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY) \
848 printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n", \
849 adj_##CATEGORY ? "" : "const ")
851 #define print_closer() puts ("};")
854 emit_insn_modes_h (void)
857 struct mode_data
*m
, *first
, *last
;
859 printf ("/* Generated automatically from machmode.def%s%s\n",
860 HAVE_EXTRA_MODES
? " and " : "",
866 #ifndef GCC_INSN_MODES_H\n\
867 #define GCC_INSN_MODES_H\n\
869 enum machine_mode\n{");
871 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
872 for (m
= modes
[c
]; m
; m
= m
->next
)
874 int count_
= printf (" %smode,", m
->name
);
875 printf ("%*s/* %s:%d */\n", 27 - count_
, "",
876 trim_filename (m
->file
), m
->line
);
879 puts (" MAX_MACHINE_MODE,\n");
881 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
885 for (m
= first
; m
; last
= m
, m
= m
->next
)
888 /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
889 end will try to use it for bitfields in structures and the
890 like, which we do not want. Only the target md file should
891 generate BImode widgets. */
892 if (first
&& first
->precision
== 1)
896 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
897 mode_class_names
[c
], first
->name
,
898 mode_class_names
[c
], last
->name
);
900 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
901 mode_class_names
[c
], void_mode
->name
,
902 mode_class_names
[c
], void_mode
->name
);
906 NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
909 /* I can't think of a better idea, can you? */
910 printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize
? "" : " const");
911 printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment
? "" : " const");
912 #if 0 /* disabled for backward compatibility, temporary */
913 printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format
? "" :" const");
915 printf ("#define CONST_MODE_IBIT%s\n", adj_ibit
? "" : " const");
916 printf ("#define CONST_MODE_FBIT%s\n", adj_fbit
? "" : " const");
919 #endif /* insn-modes.h */");
923 emit_insn_modes_c_header (void)
925 printf ("/* Generated automatically from machmode.def%s%s\n",
926 HAVE_EXTRA_MODES
? " and " : "",
932 #include \"config.h\"\n\
933 #include \"system.h\"\n\
934 #include \"coretypes.h\"\n\
936 #include \"machmode.h\"\n\
937 #include \"real.h\"");
941 emit_min_insn_modes_c_header (void)
943 printf ("/* Generated automatically from machmode.def%s%s\n",
944 HAVE_EXTRA_MODES
? " and " : "",
950 #include \"bconfig.h\"\n\
951 #include \"system.h\"\n\
952 #include \"machmode.h\"");
956 emit_mode_name (void)
961 print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
964 printf (" \"%s\",\n", m
->name
);
970 emit_mode_class (void)
975 print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
978 tagged_printf ("%s", mode_class_names
[m
->cl
], m
->name
);
984 emit_mode_precision (void)
989 print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
992 if (m
->precision
!= (unsigned int)-1)
993 tagged_printf ("%u", m
->precision
, m
->name
);
995 tagged_printf ("%u*BITS_PER_UNIT", m
->bytesize
, m
->name
);
1001 emit_mode_size (void)
1004 struct mode_data
*m
;
1006 print_maybe_const_decl ("%sunsigned char", "mode_size",
1007 "NUM_MACHINE_MODES", bytesize
);
1009 for_all_modes (c
, m
)
1010 tagged_printf ("%u", m
->bytesize
, m
->name
);
1016 emit_mode_nunits (void)
1019 struct mode_data
*m
;
1021 print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1023 for_all_modes (c
, m
)
1024 tagged_printf ("%u", m
->ncomponents
, m
->name
);
1030 emit_mode_wider (void)
1033 struct mode_data
*m
;
1035 print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1037 for_all_modes (c
, m
)
1038 tagged_printf ("%smode",
1039 m
->wider
? m
->wider
->name
: void_mode
->name
,
1043 print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1045 for_all_modes (c
, m
)
1047 struct mode_data
* m2
;
1050 m2
&& m2
!= void_mode
;
1053 if (m2
->bytesize
< 2 * m
->bytesize
)
1055 if (m
->precision
!= (unsigned int) -1)
1057 if (m2
->precision
!= 2 * m
->precision
)
1062 if (m2
->precision
!= (unsigned int) -1)
1068 if (m2
== void_mode
)
1070 tagged_printf ("%smode",
1071 m2
? m2
->name
: void_mode
->name
,
1079 emit_mode_mask (void)
1082 struct mode_data
*m
;
1084 print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1085 "NUM_MACHINE_MODES");
1087 #define MODE_MASK(m) \\\n\
1088 ((m) >= HOST_BITS_PER_WIDE_INT) \\\n\
1089 ? ~(unsigned HOST_WIDE_INT) 0 \\\n\
1090 : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
1092 for_all_modes (c
, m
)
1093 if (m
->precision
!= (unsigned int)-1)
1094 tagged_printf ("MODE_MASK (%u)", m
->precision
, m
->name
);
1096 tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m
->bytesize
, m
->name
);
1098 puts ("#undef MODE_MASK");
1103 emit_mode_inner (void)
1106 struct mode_data
*m
;
1108 print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1110 for_all_modes (c
, m
)
1111 tagged_printf ("%smode",
1112 m
->component
? m
->component
->name
: void_mode
->name
,
1119 emit_mode_base_align (void)
1122 struct mode_data
*m
;
1124 print_maybe_const_decl ("%sunsigned char",
1125 "mode_base_align", "NUM_MACHINE_MODES",
1128 for_all_modes (c
, m
)
1129 tagged_printf ("%u", m
->alignment
, m
->name
);
1135 emit_class_narrowest_mode (void)
1139 print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1141 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
1142 /* Bleah, all this to get the comment right for MIN_MODE_INT. */
1143 tagged_printf ("MIN_%s", mode_class_names
[c
],
1145 ? (modes
[c
]->precision
!= 1
1148 ? modes
[c
]->next
->name
1156 emit_real_format_for_mode (void)
1158 struct mode_data
*m
;
1160 /* The entities pointed to by this table are constant, whether
1161 or not the table itself is constant.
1163 For backward compatibility this table is always writable
1164 (several targets modify it in OVERRIDE_OPTIONS). FIXME:
1165 convert all said targets to use ADJUST_FORMAT instead. */
1167 print_maybe_const_decl ("const struct real_format *%s",
1168 "real_format_for_mode",
1169 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1172 print_decl ("struct real_format *\n", "real_format_for_mode",
1173 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1174 "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1177 /* The beginning of the table is entries for float modes. */
1178 for (m
= modes
[MODE_FLOAT
]; m
; m
= m
->next
)
1179 if (!strcmp (m
->format
, "0"))
1180 tagged_printf ("%s", m
->format
, m
->name
);
1182 tagged_printf ("&%s", m
->format
, m
->name
);
1184 /* The end of the table is entries for decimal float modes. */
1185 for (m
= modes
[MODE_DECIMAL_FLOAT
]; m
; m
= m
->next
)
1186 if (!strcmp (m
->format
, "0"))
1187 tagged_printf ("%s", m
->format
, m
->name
);
1189 tagged_printf ("&%s", m
->format
, m
->name
);
1195 emit_mode_adjustments (void)
1197 struct mode_adjust
*a
;
1198 struct mode_data
*m
;
1202 \ninit_adjust_machine_modes (void)\
1204 \n size_t s ATTRIBUTE_UNUSED;");
1206 /* Size adjustments must be propagated to all containing modes.
1207 A size adjustment forces us to recalculate the alignment too. */
1208 for (a
= adj_bytesize
; a
; a
= a
->next
)
1210 printf ("\n /* %s:%d */\n s = %s;\n",
1211 a
->file
, a
->line
, a
->adjustment
);
1212 printf (" mode_size[%smode] = s;\n", a
->mode
->name
);
1213 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1216 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1220 case MODE_COMPLEX_INT
:
1221 case MODE_COMPLEX_FLOAT
:
1222 printf (" mode_size[%smode] = 2*s;\n", m
->name
);
1223 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1227 case MODE_VECTOR_INT
:
1228 case MODE_VECTOR_FLOAT
:
1229 case MODE_VECTOR_FRACT
:
1230 case MODE_VECTOR_UFRACT
:
1231 case MODE_VECTOR_ACCUM
:
1232 case MODE_VECTOR_UACCUM
:
1233 printf (" mode_size[%smode] = %d*s;\n",
1234 m
->name
, m
->ncomponents
);
1235 printf (" mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1236 m
->name
, m
->ncomponents
, m
->ncomponents
);
1241 "mode %s is neither vector nor complex but contains %s",
1242 m
->name
, a
->mode
->name
);
1248 /* Alignment adjustments propagate too.
1249 ??? This may not be the right thing for vector modes. */
1250 for (a
= adj_alignment
; a
; a
= a
->next
)
1252 printf ("\n /* %s:%d */\n s = %s;\n",
1253 a
->file
, a
->line
, a
->adjustment
);
1254 printf (" mode_base_align[%smode] = s;\n", a
->mode
->name
);
1256 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1260 case MODE_COMPLEX_INT
:
1261 case MODE_COMPLEX_FLOAT
:
1262 printf (" mode_base_align[%smode] = s;\n", m
->name
);
1265 case MODE_VECTOR_INT
:
1266 case MODE_VECTOR_FLOAT
:
1267 case MODE_VECTOR_FRACT
:
1268 case MODE_VECTOR_UFRACT
:
1269 case MODE_VECTOR_ACCUM
:
1270 case MODE_VECTOR_UACCUM
:
1271 printf (" mode_base_align[%smode] = %d*s;\n",
1272 m
->name
, m
->ncomponents
);
1277 "mode %s is neither vector nor complex but contains %s",
1278 m
->name
, a
->mode
->name
);
1284 /* Ibit adjustments don't have to propagate. */
1285 for (a
= adj_ibit
; a
; a
= a
->next
)
1287 printf ("\n /* %s:%d */\n s = %s;\n",
1288 a
->file
, a
->line
, a
->adjustment
);
1289 printf (" mode_ibit[%smode] = s;\n", a
->mode
->name
);
1292 /* Fbit adjustments don't have to propagate. */
1293 for (a
= adj_fbit
; a
; a
= a
->next
)
1295 printf ("\n /* %s:%d */\n s = %s;\n",
1296 a
->file
, a
->line
, a
->adjustment
);
1297 printf (" mode_fbit[%smode] = s;\n", a
->mode
->name
);
1300 /* Real mode formats don't have to propagate anywhere. */
1301 for (a
= adj_format
; a
; a
= a
->next
)
1302 printf ("\n /* %s:%d */\n REAL_MODE_FORMAT (%smode) = %s;\n",
1303 a
->file
, a
->line
, a
->mode
->name
, a
->adjustment
);
1308 /* Emit ibit for all modes. */
1311 emit_mode_ibit (void)
1314 struct mode_data
*m
;
1316 print_maybe_const_decl ("%sunsigned char",
1317 "mode_ibit", "NUM_MACHINE_MODES",
1320 for_all_modes (c
, m
)
1321 tagged_printf ("%u", m
->ibit
, m
->name
);
1326 /* Emit fbit for all modes. */
1329 emit_mode_fbit (void)
1332 struct mode_data
*m
;
1334 print_maybe_const_decl ("%sunsigned char",
1335 "mode_fbit", "NUM_MACHINE_MODES",
1338 for_all_modes (c
, m
)
1339 tagged_printf ("%u", m
->fbit
, m
->name
);
1346 emit_insn_modes_c (void)
1348 emit_insn_modes_c_header ();
1351 emit_mode_precision ();
1353 emit_mode_nunits ();
1357 emit_mode_base_align ();
1358 emit_class_narrowest_mode ();
1359 emit_real_format_for_mode ();
1360 emit_mode_adjustments ();
1366 emit_min_insn_modes_c (void)
1368 emit_min_insn_modes_c_header ();
1372 emit_class_narrowest_mode ();
1375 /* Master control. */
1377 main (int argc
, char **argv
)
1379 bool gen_header
= false, gen_min
= false;
1384 else if (argc
== 2 && !strcmp (argv
[1], "-h"))
1386 else if (argc
== 2 && !strcmp (argv
[1], "-m"))
1390 error ("usage: %s [-h|-m] > file", progname
);
1391 return FATAL_EXIT_CODE
;
1394 modes_by_name
= htab_create_alloc (64, hash_mode
, eq_mode
, 0, xcalloc
, free
);
1397 complete_all_modes ();
1400 return FATAL_EXIT_CODE
;
1405 emit_insn_modes_h ();
1407 emit_min_insn_modes_c ();
1409 emit_insn_modes_c ();
1411 if (fflush (stdout
) || fclose (stdout
))
1412 return FATAL_EXIT_CODE
;
1413 return SUCCESS_EXIT_CODE
;