1 /* Generate the machine mode enumeration and associated tables.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2010
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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
26 /* enum mode_class is normally defined by machmode.h but we can't
27 include that header here. */
28 #include "mode-classes.def"
30 #define DEF_MODE_CLASS(M) M
31 enum mode_class
{ MODE_CLASSES
, MAX_MODE_CLASS
};
34 /* Text names of mode classes, for output. */
35 #define DEF_MODE_CLASS(M) #M
36 static const char *const mode_class_names
[MAX_MODE_CLASS
] =
43 #ifdef EXTRA_MODES_FILE
44 # define HAVE_EXTRA_MODES 1
46 # define HAVE_EXTRA_MODES 0
47 # define EXTRA_MODES_FILE ""
50 /* Data structure for building up what we know about a mode.
51 They're clustered by mode class. */
54 struct mode_data
*next
; /* next this class - arbitrary order */
56 const char *name
; /* printable mode name -- SI, not SImode */
57 enum mode_class cl
; /* this mode class */
58 unsigned int precision
; /* size in bits, equiv to TYPE_PRECISION */
59 unsigned int bytesize
; /* storage size in addressable units */
60 unsigned int ncomponents
; /* number of subunits */
61 unsigned int alignment
; /* mode alignment */
62 const char *format
; /* floating point format - float modes only */
64 struct mode_data
*component
; /* mode of components */
65 struct mode_data
*wider
; /* next wider mode */
67 struct mode_data
*contained
; /* Pointer to list of modes that have
68 this mode as a component. */
69 struct mode_data
*next_cont
; /* Next mode in that list. */
71 const char *file
; /* file and line of definition, */
72 unsigned int line
; /* for error reporting */
73 unsigned int counter
; /* Rank ordering of modes */
74 unsigned int ibit
; /* the number of integral bits */
75 unsigned int fbit
; /* the number of fractional bits */
78 static struct mode_data
*modes
[MAX_MODE_CLASS
];
79 static unsigned int n_modes
[MAX_MODE_CLASS
];
80 static struct mode_data
*void_mode
;
82 static const struct mode_data blank_mode
= {
83 0, "<unknown>", MAX_MODE_CLASS
,
86 "<unknown>", 0, 0, 0, 0
89 static htab_t modes_by_name
;
91 /* Data structure for recording target-specified runtime adjustments
92 to a particular mode. We support varying the byte size, the
93 alignment, and the floating point format. */
96 struct mode_adjust
*next
;
97 struct mode_data
*mode
;
98 const char *adjustment
;
104 static struct mode_adjust
*adj_bytesize
;
105 static struct mode_adjust
*adj_alignment
;
106 static struct mode_adjust
*adj_format
;
107 static struct mode_adjust
*adj_ibit
;
108 static struct mode_adjust
*adj_fbit
;
110 /* Mode class operations. */
111 static enum mode_class
112 complex_class (enum mode_class c
)
116 case MODE_INT
: return MODE_COMPLEX_INT
;
117 case MODE_FLOAT
: return MODE_COMPLEX_FLOAT
;
119 error ("no complex class for class %s", mode_class_names
[c
]);
124 static enum mode_class
125 vector_class (enum mode_class cl
)
129 case MODE_INT
: return MODE_VECTOR_INT
;
130 case MODE_FLOAT
: return MODE_VECTOR_FLOAT
;
131 case MODE_FRACT
: return MODE_VECTOR_FRACT
;
132 case MODE_UFRACT
: return MODE_VECTOR_UFRACT
;
133 case MODE_ACCUM
: return MODE_VECTOR_ACCUM
;
134 case MODE_UACCUM
: return MODE_VECTOR_UACCUM
;
136 error ("no vector class for class %s", mode_class_names
[cl
]);
141 /* Utility routines. */
142 static inline struct mode_data
*
143 find_mode (const char *name
)
145 struct mode_data key
;
148 return (struct mode_data
*) htab_find (modes_by_name
, &key
);
151 static struct mode_data
*
152 new_mode (enum mode_class cl
, const char *name
,
153 const char *file
, unsigned int line
)
156 static unsigned int count
= 0;
158 m
= find_mode (name
);
161 error ("%s:%d: duplicate definition of mode \"%s\"",
162 trim_filename (file
), line
, name
);
163 error ("%s:%d: previous definition here", m
->file
, m
->line
);
167 m
= XNEW (struct mode_data
);
168 memcpy (m
, &blank_mode
, sizeof (struct mode_data
));
172 m
->file
= trim_filename (file
);
174 m
->counter
= count
++;
180 *htab_find_slot (modes_by_name
, m
, INSERT
) = m
;
186 hash_mode (const void *p
)
188 const struct mode_data
*m
= (const struct mode_data
*)p
;
189 return htab_hash_string (m
->name
);
193 eq_mode (const void *p
, const void *q
)
195 const struct mode_data
*a
= (const struct mode_data
*)p
;
196 const struct mode_data
*b
= (const struct mode_data
*)q
;
198 return !strcmp (a
->name
, b
->name
);
201 #define for_all_modes(C, M) \
202 for (C = 0; C < MAX_MODE_CLASS; C++) \
203 for (M = modes[C]; M; M = M->next)
205 static void ATTRIBUTE_UNUSED
206 new_adjust (const char *name
,
207 struct mode_adjust
**category
, const char *catname
,
208 const char *adjustment
,
209 enum mode_class required_class_from
,
210 enum mode_class required_class_to
,
211 const char *file
, unsigned int line
)
213 struct mode_data
*mode
= find_mode (name
);
214 struct mode_adjust
*a
;
216 file
= trim_filename (file
);
220 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
224 if (required_class_from
!= MODE_RANDOM
225 && (mode
->cl
< required_class_from
|| mode
->cl
> required_class_to
))
227 error ("%s:%d: mode \"%s\" is not among class {%s, %s}",
228 file
, line
, name
, mode_class_names
[required_class_from
] + 5,
229 mode_class_names
[required_class_to
] + 5);
233 for (a
= *category
; a
; a
= a
->next
)
236 error ("%s:%d: mode \"%s\" already has a %s adjustment",
237 file
, line
, name
, catname
);
238 error ("%s:%d: previous adjustment here", a
->file
, a
->line
);
242 a
= XNEW (struct mode_adjust
);
244 a
->adjustment
= adjustment
;
252 /* Diagnose failure to meet expectations in a partially filled out
254 enum requirement
{ SET
, UNSET
, OPTIONAL
};
256 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
261 error ("%s:%d: (%s) field %s must be set", \
262 file, line, mname, fname); \
266 error ("%s:%d: (%s) field %s must not be set", \
267 file, line, mname, fname); \
273 #define validate_field(M, F) \
274 validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
277 validate_mode (struct mode_data
*m
,
278 enum requirement r_precision
,
279 enum requirement r_bytesize
,
280 enum requirement r_component
,
281 enum requirement r_ncomponents
,
282 enum requirement r_format
)
284 validate_field (m
, precision
);
285 validate_field (m
, bytesize
);
286 validate_field (m
, component
);
287 validate_field (m
, ncomponents
);
288 validate_field (m
, format
);
290 #undef validate_field
291 #undef validate_field_
293 /* Given a partially-filled-out mode structure, figure out what we can
294 and fill the rest of it in; die if it isn't enough. */
296 complete_mode (struct mode_data
*m
)
298 unsigned int alignment
;
302 error ("%s:%d: mode with no name", m
->file
, m
->line
);
305 if (m
->cl
== MAX_MODE_CLASS
)
307 error ("%s:%d: %smode has no mode class", m
->file
, m
->line
, m
->name
);
314 /* Nothing more need be said. */
315 if (!strcmp (m
->name
, "VOID"))
318 validate_mode (m
, UNSET
, UNSET
, UNSET
, UNSET
, UNSET
);
327 /* Again, nothing more need be said. For historical reasons,
328 the size of a CC mode is four units. */
329 validate_mode (m
, UNSET
, UNSET
, UNSET
, UNSET
, UNSET
);
338 case MODE_DECIMAL_FLOAT
:
343 /* A scalar mode must have a byte size, may have a bit size,
344 and must not have components. A float mode must have a
346 validate_mode (m
, OPTIONAL
, SET
, UNSET
, UNSET
,
347 (m
->cl
== MODE_FLOAT
|| m
->cl
== MODE_DECIMAL_FLOAT
)
354 case MODE_PARTIAL_INT
:
355 /* A partial integer mode uses ->component to say what the
356 corresponding full-size integer mode is, and may also
357 specify a bit size. */
358 validate_mode (m
, OPTIONAL
, UNSET
, SET
, UNSET
, UNSET
);
360 m
->bytesize
= m
->component
->bytesize
;
363 m
->component
= 0; /* ??? preserve this */
366 case MODE_COMPLEX_INT
:
367 case MODE_COMPLEX_FLOAT
:
368 /* Complex modes should have a component indicated, but no more. */
369 validate_mode (m
, UNSET
, UNSET
, SET
, UNSET
, UNSET
);
371 if (m
->component
->precision
!= (unsigned int)-1)
372 m
->precision
= 2 * m
->component
->precision
;
373 m
->bytesize
= 2 * m
->component
->bytesize
;
376 case MODE_VECTOR_INT
:
377 case MODE_VECTOR_FLOAT
:
378 case MODE_VECTOR_FRACT
:
379 case MODE_VECTOR_UFRACT
:
380 case MODE_VECTOR_ACCUM
:
381 case MODE_VECTOR_UACCUM
:
382 /* Vector modes should have a component and a number of components. */
383 validate_mode (m
, UNSET
, UNSET
, SET
, SET
, UNSET
);
384 if (m
->component
->precision
!= (unsigned int)-1)
385 m
->precision
= m
->ncomponents
* m
->component
->precision
;
386 m
->bytesize
= m
->ncomponents
* m
->component
->bytesize
;
393 /* If not already specified, the mode alignment defaults to the largest
394 power of two that divides the size of the object. Complex types are
395 not more aligned than their contents. */
396 if (m
->cl
== MODE_COMPLEX_INT
|| m
->cl
== MODE_COMPLEX_FLOAT
)
397 alignment
= m
->component
->bytesize
;
399 alignment
= m
->bytesize
;
401 m
->alignment
= alignment
& (~alignment
+ 1);
403 /* If this mode has components, make the component mode point back
404 to this mode, for the sake of adjustments. */
407 m
->next_cont
= m
->component
->contained
;
408 m
->component
->contained
= m
;
413 complete_all_modes (void)
418 for_all_modes (cl
, m
)
422 /* For each mode in class CLASS, construct a corresponding complex mode. */
423 #define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
425 make_complex_modes (enum mode_class cl
,
426 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
)
438 /* Skip BImode. FIXME: BImode probably shouldn't be MODE_INT. */
439 if (m
->precision
== 1)
442 if (strlen (m
->name
) >= sizeof buf
)
444 error ("%s:%d:mode name \"%s\" is too long",
445 m
->file
, m
->line
, m
->name
);
449 /* Float complex modes are named SCmode, etc.
450 Int complex modes are named CSImode, etc.
451 This inconsistency should be eliminated. */
452 if (cl
== MODE_FLOAT
)
455 strncpy (buf
, m
->name
, sizeof buf
);
456 p
= strchr (buf
, 'F');
458 q
= strchr (buf
, 'D');
459 if (p
== 0 && q
== 0)
461 error ("%s:%d: float mode \"%s\" has no 'F' or 'D'",
462 m
->file
, m
->line
, m
->name
);
469 snprintf (buf
, sizeof buf
, "C%s", m
->name
);
472 snprintf (buf
, sizeof buf
, "C%s", m
->name
);
474 c
= new_mode (cclass
, xstrdup (buf
), file
, line
);
479 /* For all modes in class CL, construct vector modes of width
480 WIDTH, having as many components as necessary. */
481 #define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
482 static void ATTRIBUTE_UNUSED
483 make_vector_modes (enum mode_class cl
, unsigned int width
,
484 const char *file
, unsigned int line
)
489 unsigned int ncomponents
;
490 enum mode_class vclass
= vector_class (cl
);
492 if (vclass
== MODE_RANDOM
)
495 for (m
= modes
[cl
]; m
; m
= m
->next
)
497 /* Do not construct vector modes with only one element, or
498 vector modes where the element size doesn't divide the full
500 ncomponents
= width
/ m
->bytesize
;
503 if (width
% m
->bytesize
)
506 /* Skip QFmode and BImode. FIXME: this special case should
508 if (cl
== MODE_FLOAT
&& m
->bytesize
== 1)
510 if (cl
== MODE_INT
&& m
->precision
== 1)
513 if ((size_t)snprintf (buf
, sizeof buf
, "V%u%s", ncomponents
, m
->name
)
516 error ("%s:%d: mode name \"%s\" is too long",
517 m
->file
, m
->line
, m
->name
);
521 v
= new_mode (vclass
, xstrdup (buf
), file
, line
);
523 v
->ncomponents
= ncomponents
;
529 #define _SPECIAL_MODE(C, N) 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 INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
541 #define FRACTIONAL_INT_MODE(N, B, Y) \
542 make_int_mode (#N, B, Y, __FILE__, __LINE__)
545 make_int_mode (const char *name
,
546 unsigned int precision
, unsigned int bytesize
,
547 const char *file
, unsigned int line
)
549 struct mode_data
*m
= new_mode (MODE_INT
, name
, file
, line
);
550 m
->bytesize
= bytesize
;
551 m
->precision
= precision
;
554 #define FRACT_MODE(N, Y, F) \
555 make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
557 #define UFRACT_MODE(N, Y, F) \
558 make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
560 #define ACCUM_MODE(N, Y, I, F) \
561 make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
563 #define UACCUM_MODE(N, Y, I, F) \
564 make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
566 /* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
570 make_fixed_point_mode (enum mode_class cl
,
572 unsigned int bytesize
,
575 const char *file
, unsigned int line
)
577 struct mode_data
*m
= new_mode (cl
, name
, file
, line
);
578 m
->bytesize
= bytesize
;
583 #define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
584 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
585 make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
588 make_float_mode (const char *name
,
589 unsigned int precision
, unsigned int bytesize
,
591 const char *file
, unsigned int line
)
593 struct mode_data
*m
= new_mode (MODE_FLOAT
, name
, file
, line
);
594 m
->bytesize
= bytesize
;
595 m
->precision
= precision
;
599 #define DECIMAL_FLOAT_MODE(N, Y, F) \
600 FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
601 #define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F) \
602 make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
605 make_decimal_float_mode (const char *name
,
606 unsigned int precision
, unsigned int bytesize
,
608 const char *file
, unsigned int line
)
610 struct mode_data
*m
= new_mode (MODE_DECIMAL_FLOAT
, name
, file
, line
);
611 m
->bytesize
= bytesize
;
612 m
->precision
= precision
;
616 #define RESET_FLOAT_FORMAT(N, F) \
617 reset_float_format (#N, #F, __FILE__, __LINE__)
618 static void ATTRIBUTE_UNUSED
619 reset_float_format (const char *name
, const char *format
,
620 const char *file
, unsigned int line
)
622 struct mode_data
*m
= find_mode (name
);
625 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
628 if (m
->cl
!= MODE_FLOAT
&& m
->cl
!= MODE_DECIMAL_FLOAT
)
630 error ("%s:%d: mode \"%s\" is not a FLOAT class", file
, line
, name
);
636 /* Partial integer modes are specified by relation to a full integer mode.
637 For now, we do not attempt to narrow down their bit sizes. */
638 #define PARTIAL_INT_MODE(M) \
639 make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__)
640 static void ATTRIBUTE_UNUSED
641 make_partial_integer_mode (const char *base
, const char *name
,
642 unsigned int precision
,
643 const char *file
, unsigned int line
)
646 struct mode_data
*component
= find_mode (base
);
649 error ("%s:%d: no mode \"%s\"", file
, line
, name
);
652 if (component
->cl
!= MODE_INT
)
654 error ("%s:%d: mode \"%s\" is not class INT", file
, line
, name
);
658 m
= new_mode (MODE_PARTIAL_INT
, name
, file
, line
);
659 m
->precision
= precision
;
660 m
->component
= component
;
663 /* A single vector mode can be specified by naming its component
664 mode and the number of components. */
665 #define VECTOR_MODE(C, M, N) \
666 make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
667 static void ATTRIBUTE_UNUSED
668 make_vector_mode (enum mode_class bclass
,
670 unsigned int ncomponents
,
671 const char *file
, unsigned int line
)
674 enum mode_class vclass
= vector_class (bclass
);
675 struct mode_data
*component
= find_mode (base
);
678 if (vclass
== MODE_RANDOM
)
682 error ("%s:%d: no mode \"%s\"", file
, line
, base
);
685 if (component
->cl
!= bclass
686 && (component
->cl
!= MODE_PARTIAL_INT
687 || bclass
!= MODE_INT
))
689 error ("%s:%d: mode \"%s\" is not class %s",
690 file
, line
, base
, mode_class_names
[bclass
] + 5);
694 if ((size_t)snprintf (namebuf
, sizeof namebuf
, "V%u%s",
695 ncomponents
, base
) >= sizeof namebuf
)
697 error ("%s:%d: mode name \"%s\" is too long",
702 v
= new_mode (vclass
, xstrdup (namebuf
), file
, line
);
703 v
->ncomponents
= ncomponents
;
704 v
->component
= component
;
708 #define _ADD_ADJUST(A, M, X, C1, C2) \
709 new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
711 #define ADJUST_BYTESIZE(M, X) _ADD_ADJUST(bytesize, M, X, RANDOM, RANDOM)
712 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST(alignment, M, X, RANDOM, RANDOM)
713 #define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST(format, M, X, FLOAT, FLOAT)
714 #define ADJUST_IBIT(M, X) _ADD_ADJUST(ibit, M, X, ACCUM, UACCUM)
715 #define ADJUST_FBIT(M, X) _ADD_ADJUST(fbit, M, X, FRACT, UACCUM)
720 #include "machmode.def"
725 /* Sort a list of modes into the order needed for the WIDER field:
726 major sort by precision, minor sort by component precision.
729 QI < HI < SI < DI < TI
730 V4QI < V2HI < V8QI < V4HI < V2SI.
732 If the precision is not set, sort by the bytesize. A mode with
733 precision set gets sorted before a mode without precision set, if
734 they have the same bytesize; this is the right thing because
735 the precision must always be smaller than the bytesize * BITS_PER_UNIT.
736 We don't have to do anything special to get this done -- an unset
737 precision shows up as (unsigned int)-1, i.e. UINT_MAX. */
739 cmp_modes (const void *a
, const void *b
)
741 const struct mode_data
*const m
= *(const struct mode_data
*const*)a
;
742 const struct mode_data
*const n
= *(const struct mode_data
*const*)b
;
744 if (m
->bytesize
> n
->bytesize
)
746 else if (m
->bytesize
< n
->bytesize
)
749 if (m
->precision
> n
->precision
)
751 else if (m
->precision
< n
->precision
)
754 if (!m
->component
&& !n
->component
)
756 if (m
->counter
< n
->counter
)
762 if (m
->component
->bytesize
> n
->component
->bytesize
)
764 else if (m
->component
->bytesize
< n
->component
->bytesize
)
767 if (m
->component
->precision
> n
->component
->precision
)
769 else if (m
->component
->precision
< n
->component
->precision
)
772 if (m
->counter
< n
->counter
)
779 calc_wider_mode (void)
783 struct mode_data
**sortbuf
;
784 unsigned int max_n_modes
= 0;
787 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
788 max_n_modes
= MAX (max_n_modes
, n_modes
[c
]);
790 /* Allocate max_n_modes + 1 entries to leave room for the extra null
791 pointer assigned after the qsort call below. */
792 sortbuf
= XALLOCAVEC (struct mode_data
*, max_n_modes
+ 1);
794 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
796 /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
797 However, we want these in textual order, and we have
798 precisely the reverse. */
799 if (c
== MODE_RANDOM
|| c
== MODE_CC
)
801 struct mode_data
*prev
, *next
;
803 for (prev
= 0, m
= modes
[c
]; m
; m
= next
)
805 m
->wider
= void_mode
;
807 /* this is nreverse */
819 for (i
= 0, m
= modes
[c
]; m
; i
++, m
= m
->next
)
822 qsort (sortbuf
, i
, sizeof (struct mode_data
*), cmp_modes
);
825 for (j
= 0; j
< i
; j
++)
826 sortbuf
[j
]->next
= sortbuf
[j
]->wider
= sortbuf
[j
+ 1];
828 modes
[c
] = sortbuf
[0];
833 /* Output routines. */
835 #define tagged_printf(FMT, ARG, TAG) do { \
836 int count_ = printf (" " FMT ",", ARG); \
837 printf ("%*s/* %s */\n", 27 - count_, "", TAG); \
840 #define print_decl(TYPE, NAME, ASIZE) \
841 puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
843 #define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY) \
844 printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n", \
845 adj_##CATEGORY ? "" : "const ")
847 #define print_closer() puts ("};")
850 emit_insn_modes_h (void)
853 struct mode_data
*m
, *first
, *last
;
855 printf ("/* Generated automatically from machmode.def%s%s\n",
856 HAVE_EXTRA_MODES
? " and " : "",
862 #ifndef GCC_INSN_MODES_H\n\
863 #define GCC_INSN_MODES_H\n\
865 enum machine_mode\n{");
867 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
868 for (m
= modes
[c
]; m
; m
= m
->next
)
870 int count_
= printf (" %smode,", m
->name
);
871 printf ("%*s/* %s:%d */\n", 27 - count_
, "",
872 trim_filename (m
->file
), m
->line
);
875 puts (" MAX_MACHINE_MODE,\n");
877 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
881 for (m
= first
; m
; last
= m
, m
= m
->next
)
884 /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
885 end will try to use it for bitfields in structures and the
886 like, which we do not want. Only the target md file should
887 generate BImode widgets. */
888 if (first
&& first
->precision
== 1)
892 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
893 mode_class_names
[c
], first
->name
,
894 mode_class_names
[c
], last
->name
);
896 printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
897 mode_class_names
[c
], void_mode
->name
,
898 mode_class_names
[c
], void_mode
->name
);
902 NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
905 /* I can't think of a better idea, can you? */
906 printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize
? "" : " const");
907 printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment
? "" : " const");
908 #if 0 /* disabled for backward compatibility, temporary */
909 printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format
? "" :" const");
911 printf ("#define CONST_MODE_IBIT%s\n", adj_ibit
? "" : " const");
912 printf ("#define CONST_MODE_FBIT%s\n", adj_fbit
? "" : " const");
915 #endif /* insn-modes.h */");
919 emit_insn_modes_c_header (void)
921 printf ("/* Generated automatically from machmode.def%s%s\n",
922 HAVE_EXTRA_MODES
? " and " : "",
928 #include \"config.h\"\n\
929 #include \"system.h\"\n\
930 #include \"coretypes.h\"\n\
932 #include \"machmode.h\"\n\
933 #include \"real.h\"");
937 emit_min_insn_modes_c_header (void)
939 printf ("/* Generated automatically from machmode.def%s%s\n",
940 HAVE_EXTRA_MODES
? " and " : "",
946 #include \"bconfig.h\"\n\
947 #include \"system.h\"\n\
948 #include \"machmode.h\"");
952 emit_mode_name (void)
957 print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
960 printf (" \"%s\",\n", m
->name
);
966 emit_mode_class (void)
971 print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
974 tagged_printf ("%s", mode_class_names
[m
->cl
], m
->name
);
980 emit_mode_precision (void)
985 print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
988 if (m
->precision
!= (unsigned int)-1)
989 tagged_printf ("%u", m
->precision
, m
->name
);
991 tagged_printf ("%u*BITS_PER_UNIT", m
->bytesize
, m
->name
);
997 emit_mode_size (void)
1000 struct mode_data
*m
;
1002 print_maybe_const_decl ("%sunsigned char", "mode_size",
1003 "NUM_MACHINE_MODES", bytesize
);
1005 for_all_modes (c
, m
)
1006 tagged_printf ("%u", m
->bytesize
, m
->name
);
1012 emit_mode_nunits (void)
1015 struct mode_data
*m
;
1017 print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1019 for_all_modes (c
, m
)
1020 tagged_printf ("%u", m
->ncomponents
, m
->name
);
1026 emit_mode_wider (void)
1029 struct mode_data
*m
;
1031 print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1033 for_all_modes (c
, m
)
1034 tagged_printf ("%smode",
1035 m
->wider
? m
->wider
->name
: void_mode
->name
,
1039 print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1041 for_all_modes (c
, m
)
1043 struct mode_data
* m2
;
1046 m2
&& m2
!= void_mode
;
1049 if (m2
->bytesize
< 2 * m
->bytesize
)
1051 if (m
->precision
!= (unsigned int) -1)
1053 if (m2
->precision
!= 2 * m
->precision
)
1058 if (m2
->precision
!= (unsigned int) -1)
1062 /* For vectors we want twice the number of components,
1063 with the same element type. */
1064 if (m
->cl
== MODE_VECTOR_INT
1065 || m
->cl
== MODE_VECTOR_FLOAT
1066 || m
->cl
== MODE_VECTOR_FRACT
1067 || m
->cl
== MODE_VECTOR_UFRACT
1068 || m
->cl
== MODE_VECTOR_ACCUM
1069 || m
->cl
== MODE_VECTOR_UACCUM
)
1071 if (m2
->ncomponents
!= 2 * m
->ncomponents
)
1073 if (m
->component
!= m2
->component
)
1079 if (m2
== void_mode
)
1081 tagged_printf ("%smode",
1082 m2
? m2
->name
: void_mode
->name
,
1090 emit_mode_mask (void)
1093 struct mode_data
*m
;
1095 print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1096 "NUM_MACHINE_MODES");
1098 #define MODE_MASK(m) \\\n\
1099 ((m) >= HOST_BITS_PER_WIDE_INT) \\\n\
1100 ? ~(unsigned HOST_WIDE_INT) 0 \\\n\
1101 : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
1103 for_all_modes (c
, m
)
1104 if (m
->precision
!= (unsigned int)-1)
1105 tagged_printf ("MODE_MASK (%u)", m
->precision
, m
->name
);
1107 tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m
->bytesize
, m
->name
);
1109 puts ("#undef MODE_MASK");
1114 emit_mode_inner (void)
1117 struct mode_data
*m
;
1119 print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1121 for_all_modes (c
, m
)
1122 tagged_printf ("%smode",
1123 m
->component
? m
->component
->name
: void_mode
->name
,
1130 emit_mode_base_align (void)
1133 struct mode_data
*m
;
1135 print_maybe_const_decl ("%sunsigned char",
1136 "mode_base_align", "NUM_MACHINE_MODES",
1139 for_all_modes (c
, m
)
1140 tagged_printf ("%u", m
->alignment
, m
->name
);
1146 emit_class_narrowest_mode (void)
1150 print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1152 for (c
= 0; c
< MAX_MODE_CLASS
; c
++)
1153 /* Bleah, all this to get the comment right for MIN_MODE_INT. */
1154 tagged_printf ("MIN_%s", mode_class_names
[c
],
1156 ? (modes
[c
]->precision
!= 1
1159 ? modes
[c
]->next
->name
1167 emit_real_format_for_mode (void)
1169 struct mode_data
*m
;
1171 /* The entities pointed to by this table are constant, whether
1172 or not the table itself is constant.
1174 For backward compatibility this table is always writable
1175 (several targets modify it in TARGET_OPTION_OVERRIDE). FIXME:
1176 convert all said targets to use ADJUST_FORMAT instead. */
1178 print_maybe_const_decl ("const struct real_format *%s",
1179 "real_format_for_mode",
1180 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1183 print_decl ("struct real_format *\n", "real_format_for_mode",
1184 "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1185 "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1188 /* The beginning of the table is entries for float modes. */
1189 for (m
= modes
[MODE_FLOAT
]; m
; m
= m
->next
)
1190 if (!strcmp (m
->format
, "0"))
1191 tagged_printf ("%s", m
->format
, m
->name
);
1193 tagged_printf ("&%s", m
->format
, m
->name
);
1195 /* The end of the table is entries for decimal float modes. */
1196 for (m
= modes
[MODE_DECIMAL_FLOAT
]; m
; m
= m
->next
)
1197 if (!strcmp (m
->format
, "0"))
1198 tagged_printf ("%s", m
->format
, m
->name
);
1200 tagged_printf ("&%s", m
->format
, m
->name
);
1206 emit_mode_adjustments (void)
1208 struct mode_adjust
*a
;
1209 struct mode_data
*m
;
1213 \ninit_adjust_machine_modes (void)\
1215 \n size_t s ATTRIBUTE_UNUSED;");
1217 /* Size adjustments must be propagated to all containing modes.
1218 A size adjustment forces us to recalculate the alignment too. */
1219 for (a
= adj_bytesize
; a
; a
= a
->next
)
1221 printf ("\n /* %s:%d */\n s = %s;\n",
1222 a
->file
, a
->line
, a
->adjustment
);
1223 printf (" mode_size[%smode] = s;\n", a
->mode
->name
);
1224 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1227 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1231 case MODE_COMPLEX_INT
:
1232 case MODE_COMPLEX_FLOAT
:
1233 printf (" mode_size[%smode] = 2*s;\n", m
->name
);
1234 printf (" mode_base_align[%smode] = s & (~s + 1);\n",
1238 case MODE_VECTOR_INT
:
1239 case MODE_VECTOR_FLOAT
:
1240 case MODE_VECTOR_FRACT
:
1241 case MODE_VECTOR_UFRACT
:
1242 case MODE_VECTOR_ACCUM
:
1243 case MODE_VECTOR_UACCUM
:
1244 printf (" mode_size[%smode] = %d*s;\n",
1245 m
->name
, m
->ncomponents
);
1246 printf (" mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1247 m
->name
, m
->ncomponents
, m
->ncomponents
);
1252 "mode %s is neither vector nor complex but contains %s",
1253 m
->name
, a
->mode
->name
);
1259 /* Alignment adjustments propagate too.
1260 ??? This may not be the right thing for vector modes. */
1261 for (a
= adj_alignment
; a
; a
= a
->next
)
1263 printf ("\n /* %s:%d */\n s = %s;\n",
1264 a
->file
, a
->line
, a
->adjustment
);
1265 printf (" mode_base_align[%smode] = s;\n", a
->mode
->name
);
1267 for (m
= a
->mode
->contained
; m
; m
= m
->next_cont
)
1271 case MODE_COMPLEX_INT
:
1272 case MODE_COMPLEX_FLOAT
:
1273 printf (" mode_base_align[%smode] = s;\n", m
->name
);
1276 case MODE_VECTOR_INT
:
1277 case MODE_VECTOR_FLOAT
:
1278 case MODE_VECTOR_FRACT
:
1279 case MODE_VECTOR_UFRACT
:
1280 case MODE_VECTOR_ACCUM
:
1281 case MODE_VECTOR_UACCUM
:
1282 printf (" mode_base_align[%smode] = %d*s;\n",
1283 m
->name
, m
->ncomponents
);
1288 "mode %s is neither vector nor complex but contains %s",
1289 m
->name
, a
->mode
->name
);
1295 /* Ibit adjustments don't have to propagate. */
1296 for (a
= adj_ibit
; a
; a
= a
->next
)
1298 printf ("\n /* %s:%d */\n s = %s;\n",
1299 a
->file
, a
->line
, a
->adjustment
);
1300 printf (" mode_ibit[%smode] = s;\n", a
->mode
->name
);
1303 /* Fbit adjustments don't have to propagate. */
1304 for (a
= adj_fbit
; a
; a
= a
->next
)
1306 printf ("\n /* %s:%d */\n s = %s;\n",
1307 a
->file
, a
->line
, a
->adjustment
);
1308 printf (" mode_fbit[%smode] = s;\n", a
->mode
->name
);
1311 /* Real mode formats don't have to propagate anywhere. */
1312 for (a
= adj_format
; a
; a
= a
->next
)
1313 printf ("\n /* %s:%d */\n REAL_MODE_FORMAT (%smode) = %s;\n",
1314 a
->file
, a
->line
, a
->mode
->name
, a
->adjustment
);
1319 /* Emit ibit for all modes. */
1322 emit_mode_ibit (void)
1325 struct mode_data
*m
;
1327 print_maybe_const_decl ("%sunsigned char",
1328 "mode_ibit", "NUM_MACHINE_MODES",
1331 for_all_modes (c
, m
)
1332 tagged_printf ("%u", m
->ibit
, m
->name
);
1337 /* Emit fbit for all modes. */
1340 emit_mode_fbit (void)
1343 struct mode_data
*m
;
1345 print_maybe_const_decl ("%sunsigned char",
1346 "mode_fbit", "NUM_MACHINE_MODES",
1349 for_all_modes (c
, m
)
1350 tagged_printf ("%u", m
->fbit
, m
->name
);
1357 emit_insn_modes_c (void)
1359 emit_insn_modes_c_header ();
1362 emit_mode_precision ();
1364 emit_mode_nunits ();
1368 emit_mode_base_align ();
1369 emit_class_narrowest_mode ();
1370 emit_real_format_for_mode ();
1371 emit_mode_adjustments ();
1377 emit_min_insn_modes_c (void)
1379 emit_min_insn_modes_c_header ();
1383 emit_class_narrowest_mode ();
1386 /* Master control. */
1388 main (int argc
, char **argv
)
1390 bool gen_header
= false, gen_min
= false;
1395 else if (argc
== 2 && !strcmp (argv
[1], "-h"))
1397 else if (argc
== 2 && !strcmp (argv
[1], "-m"))
1401 error ("usage: %s [-h|-m] > file", progname
);
1402 return FATAL_EXIT_CODE
;
1405 modes_by_name
= htab_create_alloc (64, hash_mode
, eq_mode
, 0, xcalloc
, free
);
1408 complete_all_modes ();
1411 return FATAL_EXIT_CODE
;
1416 emit_insn_modes_h ();
1418 emit_min_insn_modes_c ();
1420 emit_insn_modes_c ();
1422 if (fflush (stdout
) || fclose (stdout
))
1423 return FATAL_EXIT_CODE
;
1424 return SUCCESS_EXIT_CODE
;