GCC_THREAD_FILE=@thread_file@
OBJC_BOEHM_GC=@objc_boehm_gc@
GTHREAD_FLAGS=@gthread_flags@
+extra_modes_file=@extra_modes_file@
host_hook_obj=@out_host_hook_obj@
# Be prepared for gcc2 merges.
gcc_version=@gcc_version@
HOOKS_H = hooks.h
LANGHOOKS_DEF_H = langhooks-def.h $(HOOKS_H)
TARGET_DEF_H = target-def.h $(HOOKS_H)
-MACHMODE_H = machmode.h machmode.def @extra_modes_file@
+MACHMODE_H = machmode.h mode-classes.def insn-modes.h
RTL_BASE_H = rtl.h rtl.def $(MACHMODE_H)
RTL_H = $(RTL_BASE_H) genrtl.h input.h
PARAMS_H = params.h params.def
BUILD_LIBS = $(BUILD_LIBIBERTY)
BUILD_RTL = $(BUILD_PREFIX)rtl.o read-rtl.o $(BUILD_PREFIX)bitmap.o \
- $(BUILD_PREFIX)ggc-none.o
+ $(BUILD_PREFIX)ggc-none.o $(BUILD_PREFIX)insn-modes.o
BUILD_SUPPORT = gensupport.o insn-conditions.o
BUILD_EARLY_SUPPORT = gensupport.o dummy-conditions.o
dwarf2asm.o dwarf2out.o dwarfout.o emit-rtl.o except.o explow.o \
expmed.o expr.o final.o flow.o fold-const.o function.o gcse.o \
genrtl.o ggc-common.o global.o graph.o gtype-desc.o \
- haifa-sched.o hooks.o ifcvt.o insn-attrtab.o insn-emit.o \
+ haifa-sched.o hooks.o ifcvt.o insn-attrtab.o insn-emit.o insn-modes.o \
insn-extract.o insn-opinit.o insn-output.o insn-peep.o insn-recog.o \
integrate.o intl.o jump.o langhooks.o lcm.o lists.o local-alloc.o \
loop.o optabs.o options.o opts.o params.o postreload.o predict.o \
STAGESTUFF = *$(objext) insn-flags.h insn-config.h insn-codes.h \
insn-output.c insn-recog.c insn-emit.c insn-extract.c insn-peep.c \
insn-attr.h insn-attrtab.c insn-opinit.c insn-constants.h tm-preds.h \
- tree-check.h insn-conditions.c \
- s-flags s-config s-codes s-mlib s-genrtl s-gtype gtyp-gen.h \
+ tree-check.h insn-conditions.c insn-modes.c insn-modes.h \
+ s-flags s-config s-codes s-mlib s-genrtl s-modes s-gtype gtyp-gen.h \
s-output s-recog s-emit s-extract s-peep s-check s-conditions \
s-attr s-attrtab s-opinit s-preds s-constants s-crt0 \
genemit$(build_exeext) genoutput$(build_exeext) genrecog$(build_exeext) \
genconfig$(build_exeext) genpeep$(build_exeext) genattrtab$(build_exeext) \
genattr$(build_exeext) genopinit$(build_exeext) gengenrtl$(build_exeext) \
gencheck$(build_exeext) genpreds$(build_exeext) genconstants$(build_exeext) \
- gengtype$(build_exeext) genconditions$(build_exeext) \
+ gengtype$(build_exeext) genconditions$(build_exeext) genmodes$(build_exeext) \
genrtl.c genrtl.h gt-*.h gtype-*.h gtype-desc.c \
xgcc$(exeext) cpp$(exeext) cc1$(exeext) $(EXTRA_PASSES) \
$(EXTRA_PARTS) $(EXTRA_PROGRAMS) gcc-cross$(exeext) \
genrtl.c genrtl.h : s-genrtl
@true # force gnu make to recheck modification times.
-s-genrtl: gengenrtl$(build_exeext) $(srcdir)/move-if-change $(RTL_BASE_H)
+s-genrtl: gengenrtl$(build_exeext) $(srcdir)/move-if-change
$(RUN_GEN) ./gengenrtl$(build_exeext) -h > tmp-genrtl.h
$(SHELL) $(srcdir)/move-if-change tmp-genrtl.h genrtl.h
$(RUN_GEN) ./gengenrtl$(build_exeext) > tmp-genrtl.c
$(SHELL) $(srcdir)/move-if-change tmp-genrtl.c genrtl.c
$(STAMP) s-genrtl
+insn-modes.o : insn-modes.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(GTM_H) \
+ $(MACHMODE_H)
+insn-modes.c insn-modes.h : s-modes ; @true
+
+s-modes: genmodes$(build_exeext) $(srcdir)/move-if-change
+ $(RUN_GEN) ./genmodes$(build_exeext) -h > tmp-modes.h
+ $(SHELL) $(srcdir)/move-if-change tmp-modes.h insn-modes.h
+ $(RUN_GEN) ./genmodes$(build_exeext) > tmp-modes.c
+ $(SHELL) $(srcdir)/move-if-change tmp-modes.c insn-modes.c
+ $(STAMP) s-modes
+
tm-preds.h: s-preds; @true
s-preds: genpreds$(build_exeext) $(srcdir)/move-if-change
$(CC_FOR_BUILD) $(BUILD_CFLAGS) $(BUILD_LDFLAGS) -o $@ \
gengenrtl.o $(BUILD_LIBS)
-gengenrtl.o : gengenrtl.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) coretypes.h \
- $(GTM_H) real.h
+gengenrtl.o : gengenrtl.c $(BCONFIG_H) $(SYSTEM_H) rtl.def
+
+genmodes$(build_exeext) : genmodes.o $(BUILD_ERRORS) $(BUILD_LIBDEPS)
+ $(CC_FOR_BUILD) $(BUILD_CFLAGS) $(BUILD_LDFLAGS) -o $@ \
+ genmodes.o $(BUILD_ERRORS) $(BUILD_LIBS)
+
+genmodes.o : genmodes.c $(BCONFIG_H) $(SYSTEM_H) errors.h machmode.def \
+ $(extra_modes_file)
genpreds$(build_exeext) : genpreds.o $(BUILD_LIBDEPS)
$(CC_FOR_BUILD) $(BUILD_CFLAGS) $(BUILD_LDFLAGS) -o $@ \
sed -e 's/config[.]h/bconfig.h/' $(srcdir)/ggc-none.c > $(BUILD_PREFIX)ggc-none.c
$(CC_FOR_BUILD) -c $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) $(INCLUDES) $(BUILD_PREFIX)ggc-none.c $(OUTPUT_OPTION)
+$(BUILD_PREFIX_1)insn-modes.o: insn-modes.c $(BCONFIG_H) $(SYSTEM_H) \
+ coretypes.h $(GTM_H) $(MACHMODE_H)
+ rm -f $(BUILD_PREFIX)insn-modes.c
+ sed -e 's/config[.]h/bconfig.h/' $(srcdir)/insn-modes.c > $(BUILD_PREFIX)insn-modes.c
+ $(CC_FOR_BUILD) -c $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) $(INCLUDES) $(BUILD_PREFIX)insn-modes.c $(OUTPUT_OPTION)
+
#\f
# Remake internationalization support.
intl.o: intl.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) intl.h Makefile
#define BITS_BIG_ENDIAN 0
#define BYTES_BIG_ENDIAN 1
#define WORDS_BIG_ENDIAN 1
-#define BITS_PER_UNIT 8
#define BITS_PER_WORD 8
#define UNITS_PER_WORD (BITS_PER_WORD / BITS_PER_UNIT)
#define LIBGCC2_WORDS_BIG_ENDIAN 1
-#define BITS_PER_UNIT 8
-
#define BITS_PER_WORD 32
#define MAX_BITS_PER_WORD 64
#include "bconfig.h"
#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
-
-#define NO_GENRTL_H
-#include "rtl.h"
-#undef abort
-
-#include "real.h"
struct rtx_definition
{
const char *const enumname, *const name, *const format;
};
+/* rtl.def needs CONST_DOUBLE_FORMAT, but we don't care what
+ CONST_DOUBLE_FORMAT is because we're not going to be generating
+ anything for CONST_DOUBLE anyway. */
+#define CONST_DOUBLE_FORMAT ""
+
#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) { #ENUM, NAME, FORMAT },
static const struct rtx_definition defs[] =
{
#include "rtl.def" /* rtl expressions are documented here */
};
+#define NUM_RTX_CODE ARRAY_SIZE(defs)
static const char *formats[NUM_RTX_CODE];
{
int i;
- for (i = 0; i < NUM_RTX_CODE; i++)
+ for (i = 0; i < (int)NUM_RTX_CODE; i++)
{
const char **f;
putchar ('\n');
- for (i = 0; i < NUM_RTX_CODE; i++)
+ for (i = 0; i < (int) NUM_RTX_CODE; i++)
if (! special_format (defs[i].format))
genmacro (i);
--- /dev/null
+/* Generate the machine mode enumeration and associated tables.
+ Copyright (C) 2003
+ Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
+
+#include "bconfig.h"
+#include "system.h"
+#include "errors.h"
+
+/* enum mode_class is normally defined by machmode.h but we can't
+ include that header here. */
+#include "mode-classes.def"
+
+#define DEF_MODE_CLASS(M) M
+enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
+#undef DEF_MODE_CLASS
+
+/* Text names of mode classes, for output. */
+#define DEF_MODE_CLASS(M) #M
+static const char *const mode_class_names[MAX_MODE_CLASS] =
+{
+ MODE_CLASSES
+};
+#undef DEF_MODE_CLASS
+#undef MODE_CLASSES
+
+#ifdef EXTRA_MODES_FILE
+# define HAVE_EXTRA_MODES 1
+#else
+# define HAVE_EXTRA_MODES 0
+# define EXTRA_MODES_FILE ""
+#endif
+
+/* Data structure for building up what we know about a mode.
+ They're clustered by mode class. */
+struct mode_data
+{
+ struct mode_data *next; /* next this class - arbitrary order */
+
+ const char *name; /* printable mode name -- SI, not SImode */
+ enum mode_class class; /* this mode class */
+ unsigned int bitsize; /* size in bits, equiv to TYPE_PRECISION */
+ unsigned int bytesize; /* storage size in addressable units */
+ unsigned int ncomponents; /* number of subunits */
+ unsigned int alignment; /* mode alignment */
+
+ struct mode_data *component; /* mode of components */
+ struct mode_data *wider; /* next wider mode */
+
+ const char *file; /* file and line of definition, */
+ unsigned int line; /* for error reporting */
+};
+
+static struct mode_data *known_modes[MAX_MODE_CLASS];
+static unsigned int n_modes[MAX_MODE_CLASS];
+static struct mode_data *void_mode;
+
+static const struct mode_data blank_mode = {
+ 0, "<unknown>", MAX_MODE_CLASS,
+ -1, -1, -1, -1,
+ 0, 0,
+ "<unknown>", 0
+};
+
+/* Mode class operations. */
+static enum mode_class
+complex_class (enum mode_class class)
+{
+ switch (class)
+ {
+ case MODE_INT: return MODE_COMPLEX_INT;
+ case MODE_FLOAT: return MODE_COMPLEX_FLOAT;
+ default:
+ error ("no complex class for class %s", mode_class_names[class]);
+ return MODE_RANDOM;
+ }
+}
+
+static enum mode_class
+vector_class (enum mode_class class)
+{
+ switch (class)
+ {
+ case MODE_INT: return MODE_VECTOR_INT;
+ case MODE_FLOAT: return MODE_VECTOR_FLOAT;
+ default:
+ error ("no vector class for class %s", mode_class_names[class]);
+ return MODE_RANDOM;
+ }
+}
+
+static struct mode_data *
+find_mode (enum mode_class class, const char *name)
+{
+ struct mode_data *m;
+
+ for (m = known_modes[class]; m; m = m->next)
+ if (!strcmp (name, m->name))
+ return m;
+
+ return 0;
+}
+
+static struct mode_data *
+new_mode (enum mode_class class, const char *name,
+ const char *file, unsigned int line)
+{
+ struct mode_data *m;
+
+ m = find_mode (class, name);
+ if (m)
+ {
+ error ("%s:%d: duplicate definition of mode \"%s\"",
+ trim_filename (file), line, name);
+ error ("%s:%d: previous definition here", m->file, m->line);
+ return m;
+ }
+
+ m = xmalloc (sizeof (struct mode_data));
+ memcpy (m, &blank_mode, sizeof (struct mode_data));
+ m->class = class;
+ m->name = name;
+ if (file)
+ m->file = trim_filename (file);
+ m->line = line;
+
+ m->next = known_modes[class];
+ known_modes[class] = m;
+ n_modes[class]++;
+ return m;
+}
+
+#define for_all_modes(C, M) \
+ for (C = 0; C < MAX_MODE_CLASS; C++) \
+ for (M = known_modes[C]; M; M = M->next)
+
+
+/* Diagnose failure to meet expectations in a partially filled out
+ mode structure. */
+enum requirement { SET, UNSET, OPTIONAL };
+
+#define validate_field_(mname, fname, req, val, unset, file, line) do { \
+ switch (req) \
+ { \
+ case SET: \
+ if (val == unset) \
+ error ("%s:%d: (%s) field %s must be set", \
+ file, line, mname, fname); \
+ break; \
+ case UNSET: \
+ if (val != unset) \
+ error ("%s:%d: (%s) field %s must not be set", \
+ file, line, mname, fname); \
+ case OPTIONAL: \
+ break; \
+ } \
+} while (0)
+
+#define validate_field(M, F) \
+ validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
+
+static void
+validate_mode (struct mode_data *m,
+ enum requirement r_bitsize,
+ enum requirement r_bytesize,
+ enum requirement r_component,
+ enum requirement r_ncomponents)
+{
+ validate_field (m, bitsize);
+ validate_field (m, bytesize);
+ validate_field (m, component);
+ validate_field (m, ncomponents);
+}
+#undef validate_field
+#undef validate_field_
+
+/* Given a partially-filled-out mode structure, figure out what we can
+ and fill the rest of it in; die if it isn't enough. */
+static void
+complete_mode (struct mode_data *m)
+{
+ unsigned int alignment;
+
+ if (!m->name)
+ {
+ error ("%s:%d: mode with no name", m->file, m->line);
+ return;
+ }
+ if (m->class == MAX_MODE_CLASS)
+ {
+ error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
+ return;
+ }
+
+ switch (m->class)
+ {
+ case MODE_RANDOM:
+ /* Nothing more need be said. */
+ if (!strcmp (m->name, "VOID"))
+ void_mode = m;
+
+ validate_mode (m, UNSET, UNSET, UNSET, UNSET);
+
+ m->bitsize = 0;
+ m->bytesize = 0;
+ m->ncomponents = 0;
+ m->component = 0;
+ break;
+
+ case MODE_CC:
+ /* Again, nothing more need be said. For historical reasons,
+ the size of a CC mode is four units. */
+ validate_mode (m, UNSET, UNSET, UNSET, UNSET);
+
+ m->bytesize = 4;
+ m->ncomponents = 0;
+ m->component = 0;
+ break;
+
+ case MODE_INT:
+ case MODE_FLOAT:
+ /* A scalar mode must have a byte size, may have a bit size,
+ and must not have components. */
+ validate_mode (m, OPTIONAL, SET, UNSET, UNSET);
+
+ m->ncomponents = 0;
+ m->component = 0;
+ break;
+
+ case MODE_PARTIAL_INT:
+ /* A partial integer mode uses ->component to say what the
+ corresponding full-size integer mode is, and may also
+ specify a bit size. */
+ validate_mode (m, OPTIONAL, UNSET, SET, UNSET);
+
+ m->bytesize = m->component->bytesize;
+
+ m->ncomponents = 0;
+ m->component = 0; /* ??? preserve this */
+ break;
+
+ case MODE_COMPLEX_INT:
+ case MODE_COMPLEX_FLOAT:
+ /* Complex modes should have a component indicated, but no more. */
+ validate_mode (m, UNSET, UNSET, SET, UNSET);
+ m->ncomponents = 2;
+ if (m->component->bitsize != (unsigned int)-1)
+ m->bitsize = 2 * m->component->bitsize;
+ m->bytesize = 2 * m->component->bytesize;
+ break;
+
+ case MODE_VECTOR_INT:
+ case MODE_VECTOR_FLOAT:
+ /* Vector modes should have a component and a number of components. */
+ validate_mode (m, UNSET, UNSET, SET, SET);
+ if (m->component->bitsize != (unsigned int)-1)
+ m->bitsize = m->ncomponents * m->component->bitsize;
+ m->bytesize = m->ncomponents * m->component->bytesize;
+ break;
+
+ default:
+ abort ();
+ }
+
+ /* If not already specified, the mode alignment defaults to the largest
+ power of two that divides the size of the object. Complex types are
+ not more aligned than their contents. */
+ if (m->class == MODE_COMPLEX_INT || m->class == MODE_COMPLEX_FLOAT)
+ alignment = m->component->bytesize;
+ else
+ alignment = m->bytesize;
+
+ m->alignment = alignment & (~alignment + 1);
+}
+
+static void
+complete_all_modes (void)
+{
+ struct mode_data *m;
+ enum mode_class c;
+
+ for_all_modes (c, m)
+ complete_mode (m);
+}
+
+/* For each mode in class CLASS, construct a corresponding complex mode. */
+#define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
+static void
+make_complex_modes (enum mode_class class,
+ const char *file, unsigned int line)
+{
+ struct mode_data *m;
+ struct mode_data *c;
+ char buf[8];
+ enum mode_class cclass = complex_class (class);
+
+ if (cclass == MODE_RANDOM)
+ return;
+
+ for (m = known_modes[class]; m; m = m->next)
+ {
+ /* Skip BImode. FIXME: BImode probably shouldn't be MODE_INT. */
+ if (m->bitsize == 1)
+ continue;
+
+ if (strlen (m->name) >= sizeof buf)
+ {
+ error ("%s:%d:mode name \"%s\" is too long",
+ m->file, m->line, m->name);
+ continue;
+ }
+
+ /* Float complex modes are named SCmode, etc.
+ Int complex modes are named CSImode, etc.
+ This inconsistency should be eliminated. */
+ if (class == MODE_FLOAT)
+ {
+ char *p;
+ strncpy (buf, m->name, sizeof buf);
+ p = strchr (buf, 'F');
+ if (p == 0)
+ {
+ error ("%s:%d: float mode \"%s\" has no 'F'",
+ m->file, m->line, m->name);
+ continue;
+ }
+
+ *p = 'C';
+ }
+ else
+ snprintf (buf, sizeof buf, "C%s", m->name);
+
+ c = new_mode (cclass, xstrdup (buf), file, line);
+ c->component = m;
+ }
+}
+
+/* For all modes in class CLASS, construct vector modes of width
+ WIDTH, having as many components as necessary. */
+#define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
+static void
+make_vector_modes (enum mode_class class, unsigned int width,
+ const char *file, unsigned int line)
+{
+ struct mode_data *m;
+ struct mode_data *v;
+ char buf[8];
+ unsigned int ncomponents;
+ enum mode_class vclass = vector_class (class);
+
+ if (vclass == MODE_RANDOM)
+ return;
+
+ for (m = known_modes[class]; m; m = m->next)
+ {
+ /* Do not construct vector modes with only one element, or
+ vector modes where the element size doesn't divide the full
+ size evenly. */
+ ncomponents = width / m->bytesize;
+ if (ncomponents < 2)
+ continue;
+ if (width % m->bytesize)
+ continue;
+
+ /* Skip QFmode and BImode. FIXME: this special case should
+ not be necessary. */
+ if (class == MODE_FLOAT && m->bytesize == 1)
+ continue;
+ if (class == MODE_INT && m->bitsize == 1)
+ continue;
+
+ if ((size_t)snprintf (buf, sizeof buf, "V%u%s", ncomponents, m->name)
+ >= sizeof buf)
+ {
+ error ("%s:%d: mode name \"%s\" is too long",
+ m->file, m->line, m->name);
+ continue;
+ }
+
+ v = new_mode (vclass, xstrdup (buf), file, line);
+ v->component = m;
+ v->ncomponents = ncomponents;
+ }
+}
+
+/* Input. */
+
+#define _SPECIAL_MODE(C, N) make_special_mode(MODE_##C, #N, __FILE__, __LINE__)
+#define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
+#define CC_MODE(N) _SPECIAL_MODE (CC, N)
+
+static void
+make_special_mode (enum mode_class class, const char *name,
+ const char *file, unsigned int line)
+{
+ new_mode (class, name, file, line);
+}
+
+#define _SCALAR_MODE(C, N, B, Y) \
+ make_scalar_mode (MODE_##C, #N, B, Y, __FILE__, __LINE__)
+
+#define INT_MODE(N, Y) _SCALAR_MODE (INT, N, -1, Y)
+#define FRACTIONAL_INT_MODE(N, B, Y) _SCALAR_MODE (INT, N, B, Y)
+#define FLOAT_MODE(N, Y) _SCALAR_MODE (FLOAT, N, -1, Y)
+#define FRACTIONAL_FLOAT_MODE(N, B, Y) _SCALAR_MODE (FLOAT, N, B, Y)
+
+static void
+make_scalar_mode (enum mode_class class, const char *name,
+ unsigned int bitsize, unsigned int bytesize,
+ const char *file, unsigned int line)
+{
+ struct mode_data *m = new_mode (class, name, file, line);
+ m->bytesize = bytesize;
+ m->bitsize = bitsize;
+}
+
+/* Partial integer modes are specified by relation to a full integer mode.
+ For now, we do not attempt to narrow down their bit sizes. */
+#define PARTIAL_INT_MODE(M) \
+ make_partial_integer_mode (#M, "P" #M, -1, __FILE__, __LINE__)
+static void ATTRIBUTE_UNUSED
+make_partial_integer_mode (const char *base, const char *name,
+ unsigned int bitsize,
+ const char *file, unsigned int line)
+{
+ struct mode_data *m;
+ struct mode_data *component = find_mode (MODE_INT, base);
+ if (!component)
+ {
+ error ("%s:%d: no mode \"%s\" in class INT", file, line, name);
+ return;
+ }
+
+ m = new_mode (MODE_PARTIAL_INT, name, file, line);
+ m->bitsize = bitsize;
+ m->component = component;
+}
+
+/* A single vector mode can be specified by naming its component
+ mode and the number of components. */
+#define VECTOR_MODE(C, M, N) \
+ make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
+static void ATTRIBUTE_UNUSED
+make_vector_mode (enum mode_class bclass,
+ const char *base,
+ unsigned int ncomponents,
+ const char *file, unsigned int line)
+{
+ struct mode_data *v;
+ enum mode_class vclass = vector_class (bclass);
+ struct mode_data *component = find_mode (bclass, base);
+ char namebuf[8];
+
+ if (vclass == MODE_RANDOM)
+ return;
+ if (component == 0)
+ {
+ error ("%s:%d: no mode \"%s\" in class %s",
+ file, line, base, mode_class_names[bclass] + 5);
+ return;
+ }
+
+ if ((size_t)snprintf (namebuf, sizeof namebuf, "V%u%s",
+ ncomponents, base) >= sizeof namebuf)
+ {
+ error ("%s:%d: mode name \"%s\" is too long",
+ base, file, line);
+ return;
+ }
+
+ v = new_mode (vclass, xstrdup (namebuf), file, line);
+ v->ncomponents = ncomponents;
+ v->component = component;
+}
+
+
+static void
+create_modes (void)
+{
+#include "machmode.def"
+}
+
+/* Processing. */
+
+/* Sort a list of modes into the order needed for the WIDER field:
+ major sort by bitsize, minor sort by component bitsize.
+
+ For instance:
+ QI < HI < SI < DI < TI
+ V4QI < V2HI < V8QI < V4HI < V2SI.
+
+ If the bitsize is not set, sort by the bytesize. A mode with
+ bitsize set gets sorted before a mode without bitsize set, if
+ they have the same bytesize; this is the right thing because
+ the bitsize must always be smaller than the bytesize * BITS_PER_UNIT.
+ We don't have to do anything special to get this done -- an unset
+ bitsize shows up as (unsigned int)-1, i.e. UINT_MAX. */
+static int
+cmp_modes (const void *a, const void *b)
+{
+ struct mode_data *m = *(struct mode_data **)a;
+ struct mode_data *n = *(struct mode_data **)b;
+
+ if (m->bytesize > n->bytesize)
+ return 1;
+ else if (m->bytesize < n->bytesize)
+ return -1;
+
+ if (m->bitsize > n->bitsize)
+ return 1;
+ else if (m->bitsize < n->bitsize)
+ return -1;
+
+ if (!m->component && !n->component)
+ return 0;
+
+ if (m->component->bytesize > n->component->bytesize)
+ return 1;
+ else if (m->component->bytesize < n->component->bytesize)
+ return -1;
+
+ if (m->component->bitsize > n->component->bitsize)
+ return 1;
+ else if (m->component->bitsize < n->component->bitsize)
+ return -1;
+
+ return 0;
+}
+
+static void
+calc_wider_mode (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+ struct mode_data **sortbuf;
+ unsigned int max_n_modes = 0;
+ unsigned int i, j;
+
+ for (c = 0; c < MAX_MODE_CLASS; c++)
+ max_n_modes = MAX (max_n_modes, n_modes[c]);
+
+ sortbuf = alloca (max_n_modes * sizeof (struct mode_data *));
+
+ for (c = 0; c < MAX_MODE_CLASS; c++)
+ {
+ /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
+ However, we want these in textual order, and we have
+ precisely the reverse. */
+ if (c == MODE_RANDOM || c == MODE_CC)
+ {
+ struct mode_data *prev, *next;
+
+ for (prev = 0, m = known_modes[c]; m; m = next)
+ {
+ m->wider = void_mode;
+
+ /* this is nreverse */
+ next = m->next;
+ m->next = prev;
+ prev = m;
+ }
+ known_modes[c] = prev;
+ }
+ else
+ {
+ if (!known_modes[c])
+ continue;
+
+ for (i = 0, m = known_modes[c]; m; i++, m = m->next)
+ sortbuf[i] = m;
+
+ qsort (sortbuf, i, sizeof (struct mode_data *), cmp_modes);
+
+ sortbuf[i] = 0;
+ for (j = 0; j < i; j++)
+ sortbuf[j]->next = sortbuf[j]->wider = sortbuf[j + 1];
+
+
+ known_modes[c] = sortbuf[0];
+ }
+ }
+}
+
+/* Output routines. */
+
+#define tagged_printf(FMT, ARG, TAG) do { \
+ int count_; \
+ printf (" " FMT ",%n", ARG, &count_); \
+ printf ("%*s/* %s */\n", 27 - count_, "", TAG); \
+} while (0)
+
+#define print_decl(TYPE, NAME, ASIZE) \
+ printf ("\nconst %s %s[%s] =\n{\n", TYPE, NAME, ASIZE);
+
+#define print_closer() puts ("};")
+
+static void
+emit_insn_modes_h (void)
+{
+ enum mode_class c;
+ struct mode_data *m, *first, *last;
+
+ printf ("/* Generated automatically from machmode.def%s%s\n",
+ HAVE_EXTRA_MODES ? " and " : "",
+ EXTRA_MODES_FILE);
+
+ puts ("\
+ by genmodes. */\n\
+\n\
+#ifndef GCC_INSN_MODES_H\n\
+#define GCC_INSN_MODES_H\n\
+\n\
+enum machine_mode\n{");
+
+ for (c = 0; c < MAX_MODE_CLASS; c++)
+ for (m = known_modes[c]; m; m = m->next)
+ {
+ int count_;
+ printf (" %smode,%n", m->name, &count_);
+ printf ("%*s/* %s:%d */\n", 27 - count_, "",
+ trim_filename (m->file), m->line);
+ }
+
+ puts (" MAX_MACHINE_MODE,\n");
+
+ for (c = 0; c < MAX_MODE_CLASS; c++)
+ {
+ first = known_modes[c];
+ last = 0;
+ for (m = first; m; last = m, m = m->next)
+ ;
+
+ /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
+ end will try to use it for bitfields in structures and the
+ like, which we do not want. Only the target md file should
+ generate BImode widgets. */
+ if (first && first->bitsize == 1)
+ first = first->next;
+
+ if (first && last)
+ printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
+ mode_class_names[c], first->name,
+ mode_class_names[c], last->name);
+ else
+ printf (" MIN_%s = %smode,\n MAX_%s = %smode,\n\n",
+ mode_class_names[c], void_mode->name,
+ mode_class_names[c], void_mode->name);
+ }
+
+ puts ("\
+ NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
+};\n\
+\n\
+#endif /* insn-modes.h */");
+}
+
+static void
+emit_insn_modes_c_header (void)
+{
+ printf ("/* Generated automatically from machmode.def%s%s\n",
+ HAVE_EXTRA_MODES ? " and " : "",
+ EXTRA_MODES_FILE);
+
+ puts ("\
+ by genmodes. */\n\
+\n\
+#define GENERATOR_FILE /* This inhibits insn-flags.h and\n\
+ insn-constants.h, which don't exist yet. */\n\
+#include \"config.h\"\n\
+#include \"system.h\"\n\
+#include \"coretypes.h\"\n\
+#include \"tm.h\"\n\
+#include \"machmode.h\"");
+}
+
+static void
+emit_mode_name (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+
+ print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
+
+ for_all_modes (c, m)
+ printf (" \"%s\",\n", m->name);
+
+ print_closer ();
+}
+
+static void
+emit_mode_class (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+
+ print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
+
+ for_all_modes (c, m)
+ tagged_printf ("%s", mode_class_names[m->class], m->name);
+
+ print_closer ();
+}
+
+static void
+emit_mode_bitsize (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+
+ print_decl ("unsigned short", "mode_bitsize", "NUM_MACHINE_MODES");
+
+ for_all_modes (c, m)
+ if (m->bitsize != (unsigned int)-1)
+ tagged_printf ("%u", m->bitsize, m->name);
+ else
+ tagged_printf ("%u*BITS_PER_UNIT", m->bytesize, m->name);
+
+ print_closer ();
+}
+
+static void
+emit_mode_size (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+
+ print_decl ("unsigned char", "mode_size", "NUM_MACHINE_MODES");
+
+ for_all_modes (c, m)
+ tagged_printf ("%u", m->bytesize, m->name);
+
+ print_closer ();
+}
+
+static void
+emit_mode_unit_size (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+
+ print_decl ("unsigned char", "mode_unit_size", "NUM_MACHINE_MODES");
+
+ for_all_modes (c, m)
+ tagged_printf ("%u",
+ m->component
+ ? m->component->bytesize : m->bytesize,
+ m->name);
+
+ print_closer ();
+}
+
+static void
+emit_mode_wider (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+
+ print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
+
+ for_all_modes (c, m)
+ tagged_printf ("%smode",
+ m->wider ? m->wider->name : void_mode->name,
+ m->name);
+
+ print_closer ();
+}
+
+static void
+emit_mode_mask (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+
+ print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
+ "NUM_MACHINE_MODES");
+ puts ("\
+#define MASK(m) \\\n\
+ ((m) >= HOST_BITS_PER_WIDE_INT) \\\n\
+ ? ~(unsigned HOST_WIDE_INT) 0 \\\n\
+ : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
+
+ for_all_modes (c, m)
+ if (m->bitsize != (unsigned int)-1)
+ tagged_printf ("MASK (%u)", m->bitsize, m->name);
+ else
+ tagged_printf ("MASK (%u*BITS_PER_UNIT)", m->bytesize, m->name);
+
+ puts ("#undef MASK");
+ print_closer ();
+}
+
+static void
+emit_mode_inner (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+
+ print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
+
+ for_all_modes (c, m)
+ tagged_printf ("%smode",
+ m->component ? m->component->name : void_mode->name,
+ m->name);
+
+ print_closer ();
+}
+
+static void
+emit_mode_base_align (void)
+{
+ enum mode_class c;
+ struct mode_data *m;
+
+ print_decl ("unsigned char", "mode_base_align", "NUM_MACHINE_MODES");
+
+ for_all_modes (c, m)
+ tagged_printf ("%u", m->alignment, m->name);
+
+ print_closer ();
+}
+
+static void
+emit_class_narrowest_mode (void)
+{
+ enum mode_class c;
+
+ print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
+
+ for (c = 0; c < MAX_MODE_CLASS; c++)
+ /* Bleah, all this to get the comment right for MIN_MODE_INT. */
+ tagged_printf ("MIN_%s", mode_class_names[c],
+ known_modes[c]
+ ? (known_modes[c]->bitsize != 1
+ ? known_modes[c]->name
+ : (known_modes[c]->next
+ ? known_modes[c]->next->name
+ : void_mode->name))
+ : void_mode->name);
+
+ print_closer ();
+}
+
+static void
+emit_insn_modes_c (void)
+{
+ emit_insn_modes_c_header ();
+ emit_mode_name ();
+ emit_mode_class ();
+ emit_mode_bitsize ();
+ emit_mode_size ();
+ emit_mode_unit_size ();
+ emit_mode_wider ();
+ emit_mode_mask ();
+ emit_mode_inner ();
+ emit_mode_base_align ();
+ emit_class_narrowest_mode ();
+}
+
+/* Master control. */
+int
+main(int argc, char **argv)
+{
+ bool gen_header;
+ progname = argv[0];
+
+ if (argc == 1)
+ gen_header = false;
+ else if (argc == 2 && !strcmp (argv[1], "-h"))
+ gen_header = true;
+ else
+ {
+ error ("usage: %s [-h] > file", progname);
+ return FATAL_EXIT_CODE;
+ }
+
+ create_modes ();
+ complete_all_modes ();
+
+ if (have_error)
+ return FATAL_EXIT_CODE;
+
+ calc_wider_mode ();
+
+ if (gen_header)
+ emit_insn_modes_h ();
+ else
+ emit_insn_modes_c ();
+
+ if (fflush (stdout) || fclose (stdout))
+ return FATAL_EXIT_CODE;
+ return SUCCESS_EXIT_CODE;
+}
/* This file contains the definitions and documentation for the
machine modes used in the GNU compiler.
- Copyright (C) 1987, 1992, 1994, 1997, 1998, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1987, 1992, 1994, 1997, 1998, 2000, 2003
+ Free Software Foundation, Inc.
This file is part of GCC.
has a machine mode which describes data of that type or the
data of the variable declared. */
-/* The first argument is the internal name of the machine mode
- used in the C source.
- By convention these are in UPPER_CASE, except for the word "mode".
-
- The second argument is the name of the machine mode in the
- external ASCII format used for reading and printing RTL and trees.
- By convention these names in UPPER_CASE.
-
- Third argument states the kind of representation:
- MODE_INT - integer
- MODE_FLOAT - floating
- MODE_PARTIAL_INT - PQImode, PHImode, PSImode and PDImode
- MODE_CC - modes used for representing the condition code in a register
- MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT - complex number
- MODE_VECTOR_INT, MODE_VECTOR_FLOAT - vector
- MODE_RANDOM - anything else
-
- Fourth argument is the relative size of the object, in bits,
- so we can have modes smaller than 1 byte.
-
- Fifth argument is the relative size of the object, in bytes.
- It is zero when the size is meaningless or not determined.
- A byte's size is determined by BITS_PER_UNIT in tm.h.
-
- Sixth arg is the relative size of subunits of the object.
- It is same as the fifth argument except for complexes and vectors,
- since they are really made of many equal size subunits.
-
- Seventh arg is next wider natural mode of the same class. 0 if
- there is none. Vector modes use this field to point to the next
- vector size, so we can iterate through the different vectors modes.
- The ordering is by increasing byte size, with QI coming before HI,
- HI before SI, etc.
-
- Eigth arg is the mode of the internal elements in a vector or
- complex, and VOIDmode if not applicable.
-*/
+/* This file is included by the genmodes program. Its text is the
+ body of a function. Do not rely on this, it will change in the
+ future.
+
+ The following statements can be used in this file -- all have
+ the form of a C macro call. In their arguments:
+
+ A CLASS argument must be one of the constants defined in
+ mode-classes.def, less the leading MODE_ prefix; some statements
+ that take CLASS arguments have restructions on which classes are
+ acceptable. For instance, INT.
+
+ A MODE argument must be the printable name of a machine mode,
+ without quotation marks or trailing "mode". For instance, SI.
+
+ A BITSIZE, BYTESIZE, or COUNT argument must be a positive integer
+ constant.
+
+ Order matters in this file in so far as statements which refer to
+ other modes must appear after the modes they refer to. However,
+ statements which do not refer to other modes may appear in any
+ order.
+
+ RANDOM_MODE (MODE);
+ declares MODE to be of class RANDOM.
+
+ CC_MODE (MODE);
+ declares MODE to be of class CC.
+
+ INT_MODE (MODE, BYTESIZE);
+ declares MODE to be of class INT and BYTESIZE bytes wide.
+ All of the bits of its representation are significant.
+
+ FRACTIONAL_INT_MODE (MODE, BITSIZE, BYTESIZE);
+ declares MODE to be of class INT, BYTESIZE bytes wide in
+ storage, but with only BITSIZE significant bits.
+
+ FLOAT_MODE (MODE, BYTESIZE);
+ declares MODE to be of class FLOAT and BYTESIZE bytes wide.
+ All of the bits of its representation are significant.
+
+ FRACTIONAL_FLOAT_MODE (MODE, BITSIZE, BYTESIZE);
+ declares MODE to be of class FLOAT, BYTESIZE bytes wide in
+ storage, but with only BITSIZE significant bits.
+
+ PARTIAL_INT_MODE (MODE);
+ declares a mode of class PARTIAL_INT with the same size as
+ MODE (which must be an INT mode). The name of the new mode
+ is made by prefixing a P to the name MODE. This statement
+ may grow a BITSIZE argument in the future.
+
+ VECTOR_MODE (CLASS, MODE, COUNT);
+ Declare a vector mode whose component mode is MODE (of class
+ CLASS) with COUNT components. CLASS must be INT or FLOAT.
+ The name of the vector mode takes the form VnX where n is
+ COUNT in decimal and X is MODE.
+
+ VECTOR_MODES (CLASS, WIDTH);
+ For all modes presently declared in class CLASS, construct
+ corresponding vector modes having width WIDTH. Modes whose
+ byte sizes do not evenly divide WIDTH are ignored, as are
+ modes that would produce vector modes with only one component,
+ and modes smaller than one byte (if CLASS is INT) or smaller
+ than two bytes (if CLASS is FLOAT). CLASS must be INT or
+ FLOAT. The names follow the same rule as VECTOR_MODE uses.
+
+ COMPLEX_MODES (CLASS);
+ For all modes presently declared in class CLASS, construct
+ corresponding complex modes. Modes smaller than one byte
+ are ignored. For FLOAT modes, the names are derived by
+ replacing the 'F' in the mode name with a 'C'. (It is an
+ error if there is no 'F'. For INT modes, the names are
+ derived by prefixing a C to the name.
+
+ BITS_PER_UNIT (COUNT);
+ Sets the number of bits in a machine byte (least addressable
+ unit). If this statement does not appear, the default is 8.
+
+ Note: If a mode is ever made which is more than 255 bytes wide,
+ machmode.h and genmodes.c will have to be changed to allocate
+ more space for the mode_size and mode_alignment arrays. */
/* VOIDmode is used when no mode needs to be specified,
as for example on CONST_INT RTL expressions. */
-DEF_MACHMODE (VOIDmode, "VOID", MODE_RANDOM, 0, 0, 0, VOIDmode, VOIDmode)
+RANDOM_MODE (VOID);
+
+/* BLKmode is used for structures, arrays, etc.
+ that fit no more specific mode. */
+RANDOM_MODE (BLK);
+
+/* Single bit mode used for booleans. */
+FRACTIONAL_INT_MODE (BI, 1, 1);
-DEF_MACHMODE (BImode, "BI", MODE_INT, 1, 1, 1, QImode, VOIDmode)
-DEF_MACHMODE (QImode, "QI", MODE_INT, BITS_PER_UNIT, 1, 1, HImode, VOIDmode)
-DEF_MACHMODE (HImode, "HI", MODE_INT, BITS_PER_UNIT*2, 2, 2, SImode, VOIDmode)
-DEF_MACHMODE (SImode, "SI", MODE_INT, BITS_PER_UNIT*4, 4, 4, DImode, VOIDmode)
-DEF_MACHMODE (DImode, "DI", MODE_INT, BITS_PER_UNIT*8, 8, 8, TImode, VOIDmode)
-DEF_MACHMODE (TImode, "TI", MODE_INT, BITS_PER_UNIT*16, 16, 16, OImode, VOIDmode)
-DEF_MACHMODE (OImode, "OI", MODE_INT, BITS_PER_UNIT*32, 32, 32, VOIDmode, VOIDmode)
+/* Basic integer modes. */
+INT_MODE (QI, 1);
+INT_MODE (HI, 2);
+INT_MODE (SI, 4);
+INT_MODE (DI, 8);
+INT_MODE (TI, 16);
+INT_MODE (OI, 32);
/* Pointers on some machines use these types to distinguish them from
ints. Useful if a pointer is 4 bytes but has some bits that are
not significant, so it is really not quite as wide as an integer. */
-DEF_MACHMODE (PQImode, "PQI", MODE_PARTIAL_INT, BITS_PER_UNIT, 1, 1, PHImode, VOIDmode)
-DEF_MACHMODE (PHImode, "PHI", MODE_PARTIAL_INT, BITS_PER_UNIT*2, 2, 2, PSImode, VOIDmode)
-DEF_MACHMODE (PSImode, "PSI", MODE_PARTIAL_INT, BITS_PER_UNIT*4, 4, 4, PDImode, VOIDmode)
-DEF_MACHMODE (PDImode, "PDI", MODE_PARTIAL_INT, BITS_PER_UNIT*8, 8, 8, VOIDmode, VOIDmode)
-
-DEF_MACHMODE (QFmode, "QF", MODE_FLOAT, BITS_PER_UNIT, 1, 1, HFmode, VOIDmode)
-DEF_MACHMODE (HFmode, "HF", MODE_FLOAT, BITS_PER_UNIT*2, 2, 2, TQFmode, VOIDmode)
-DEF_MACHMODE (TQFmode, "TQF", MODE_FLOAT, BITS_PER_UNIT*3, 3, 3, SFmode, VOIDmode) /* MIL-STD-1750A */
-DEF_MACHMODE (SFmode, "SF", MODE_FLOAT, BITS_PER_UNIT*4, 4, 4, DFmode, VOIDmode)
-DEF_MACHMODE (DFmode, "DF", MODE_FLOAT, BITS_PER_UNIT*8, 8, 8, XFmode, VOIDmode)
-DEF_MACHMODE (XFmode, "XF", MODE_FLOAT, BITS_PER_UNIT*12, 12, 12, TFmode, VOIDmode) /* IEEE extended */
-DEF_MACHMODE (TFmode, "TF", MODE_FLOAT, BITS_PER_UNIT*16, 16, 16, VOIDmode, VOIDmode)
+PARTIAL_INT_MODE (QI);
+PARTIAL_INT_MODE (HI);
+PARTIAL_INT_MODE (SI);
+PARTIAL_INT_MODE (DI);
+
+/* Basic floating point modes. */
+FLOAT_MODE (QF, 1); /* C4x single precision */
+FLOAT_MODE (HF, 2); /* C4x double precision */
+FLOAT_MODE (TQF, 3); /* MIL-STD-1750a */
+FLOAT_MODE (SF, 4);
+FLOAT_MODE (DF, 8);
+FLOAT_MODE (XF, 12); /* IEEE extended (80-bit) */
+FLOAT_MODE (TF, 16);
+
+/* Basic CC modes. */
+CC_MODE (CC);
+
+/* Allow the target to specify additional modes of various kinds. */
+#if HAVE_EXTRA_MODES
+# define CC(X) CC_MODE(X); /* backward compatibility, temporary */
+# include EXTRA_MODES_FILE
+# undef CC
+#endif
/* Complex modes. */
-DEF_MACHMODE (QCmode, "QC", MODE_COMPLEX_FLOAT, BITS_PER_UNIT*2, 2, 1, HCmode, QFmode)
-DEF_MACHMODE (HCmode, "HC", MODE_COMPLEX_FLOAT, BITS_PER_UNIT*4, 4, 2, SCmode, HFmode)
-DEF_MACHMODE (SCmode, "SC", MODE_COMPLEX_FLOAT, BITS_PER_UNIT*8, 8, 4, DCmode, SFmode)
-DEF_MACHMODE (DCmode, "DC", MODE_COMPLEX_FLOAT, BITS_PER_UNIT*16, 16, 8, XCmode, DFmode)
-DEF_MACHMODE (XCmode, "XC", MODE_COMPLEX_FLOAT, BITS_PER_UNIT*24, 24, 12, TCmode, XFmode)
-DEF_MACHMODE (TCmode, "TC", MODE_COMPLEX_FLOAT, BITS_PER_UNIT*32, 32, 16, VOIDmode, TFmode)
-
-DEF_MACHMODE (CQImode, "CQI", MODE_COMPLEX_INT, BITS_PER_UNIT*2, 2, 1, CHImode, QImode)
-DEF_MACHMODE (CHImode, "CHI", MODE_COMPLEX_INT, BITS_PER_UNIT*4, 4, 2, CSImode, HImode)
-DEF_MACHMODE (CSImode, "CSI", MODE_COMPLEX_INT, BITS_PER_UNIT*8, 8, 4, CDImode, SImode)
-DEF_MACHMODE (CDImode, "CDI", MODE_COMPLEX_INT, BITS_PER_UNIT*16, 16, 8, CTImode, DImode)
-DEF_MACHMODE (CTImode, "CTI", MODE_COMPLEX_INT, BITS_PER_UNIT*32, 32, 16, COImode, TImode)
-DEF_MACHMODE (COImode, "COI", MODE_COMPLEX_INT, BITS_PER_UNIT*64, 64, 32, VOIDmode, OImode)
+COMPLEX_MODES (INT);
+COMPLEX_MODES (FLOAT);
/* Vector modes. */
-/* The wider mode field for vectors follows in order of increasing bit
- size with QI coming before HI, HI before SI, and SI before DI
- within same bit sizes. */
-DEF_MACHMODE (V1DImode, "V1DI", MODE_VECTOR_INT, BITS_PER_UNIT*8, 8, 8, V2QImode, DImode)
-DEF_MACHMODE (V2QImode, "V2QI", MODE_VECTOR_INT, BITS_PER_UNIT*2, 2, 1, V4QImode, QImode)
-DEF_MACHMODE (V2HImode, "V2HI", MODE_VECTOR_INT, BITS_PER_UNIT*4, 4, 2, V8QImode, HImode)
-DEF_MACHMODE (V2SImode, "V2SI", MODE_VECTOR_INT, BITS_PER_UNIT*8, 8, 4, V16QImode, SImode)
-DEF_MACHMODE (V2DImode, "V2DI", MODE_VECTOR_INT, BITS_PER_UNIT*16, 16, 8, V8SImode, DImode)
-
-DEF_MACHMODE (V4QImode, "V4QI", MODE_VECTOR_INT, BITS_PER_UNIT*4, 4, 1, V2HImode, QImode)
-DEF_MACHMODE (V4HImode, "V4HI", MODE_VECTOR_INT, BITS_PER_UNIT*8, 8, 2, V2SImode, HImode)
-DEF_MACHMODE (V4SImode, "V4SI", MODE_VECTOR_INT, BITS_PER_UNIT*16, 16, 4, V2DImode, SImode)
-DEF_MACHMODE (V4DImode, "V4DI", MODE_VECTOR_INT, BITS_PER_UNIT*32, 32, 8, V8DImode, DImode)
-
-DEF_MACHMODE (V8QImode, "V8QI", MODE_VECTOR_INT, BITS_PER_UNIT*8, 8, 1, V4HImode, QImode)
-DEF_MACHMODE (V8HImode, "V8HI", MODE_VECTOR_INT, BITS_PER_UNIT*16, 16, 2, V4SImode, HImode)
-DEF_MACHMODE (V8SImode, "V8SI", MODE_VECTOR_INT, BITS_PER_UNIT*32, 32, 4, V4DImode, SImode)
-DEF_MACHMODE (V8DImode, "V8DI", MODE_VECTOR_INT, BITS_PER_UNIT*64, 64, 8, VOIDmode, DImode)
-
-DEF_MACHMODE (V16QImode, "V16QI", MODE_VECTOR_INT, BITS_PER_UNIT*16, 16, 1, V8HImode, QImode)
-
-DEF_MACHMODE (V2HFmode, "V2HF", MODE_VECTOR_FLOAT, BITS_PER_UNIT*4, 4, 2, V4HFmode, HFmode)
-DEF_MACHMODE (V2SFmode, "V2SF", MODE_VECTOR_FLOAT, BITS_PER_UNIT*8, 8, 4, V4SFmode, SFmode)
-DEF_MACHMODE (V2DFmode, "V2DF", MODE_VECTOR_FLOAT, BITS_PER_UNIT*16, 16, 8, V8SFmode, DFmode)
-
-DEF_MACHMODE (V4HFmode, "V4HF", MODE_VECTOR_FLOAT, BITS_PER_UNIT*8, 8, 2, V2SFmode, HFmode)
-DEF_MACHMODE (V4SFmode, "V4SF", MODE_VECTOR_FLOAT, BITS_PER_UNIT*16, 16, 4, V2DFmode, SFmode)
-DEF_MACHMODE (V4DFmode, "V4DF", MODE_VECTOR_FLOAT, BITS_PER_UNIT*32, 32, 8, V8DFmode, DFmode)
-
-DEF_MACHMODE (V8HFmode, "V8HF", MODE_VECTOR_FLOAT, BITS_PER_UNIT*16, 16, 2, V4SFmode, HFmode)
-DEF_MACHMODE (V8SFmode, "V8SF", MODE_VECTOR_FLOAT, BITS_PER_UNIT*32, 32, 4, V4DFmode, SFmode)
-DEF_MACHMODE (V8DFmode, "V8DF", MODE_VECTOR_FLOAT, BITS_PER_UNIT*64, 64, 8, VOIDmode, DFmode)
-DEF_MACHMODE (V16SFmode, "V16SF", MODE_VECTOR_FLOAT, 512, 64, 4, VOIDmode, SFmode)
-
-/* BLKmode is used for structures, arrays, etc.
- that fit no more specific mode. */
-DEF_MACHMODE (BLKmode, "BLK", MODE_RANDOM, 0, 0, 0, VOIDmode, VOIDmode)
-
-/* The modes for representing the condition codes come last. CCmode
- is always defined. Additional modes for the condition code can be
- specified in the EXTRA_CC_MODES header. All MODE_CC modes are the
- same width as SImode and have VOIDmode as their next wider mode. */
-
-/* We do not use CC() for CCmode to avoid a warning about use of
- function-like macros with no arguments. */
-DEF_MACHMODE (CCmode, "CC", MODE_CC, BITS_PER_UNIT*4, 4, 4, VOIDmode, VOIDmode)
-
-#ifdef EXTRA_MODES_FILE
-#define CC(N) \
- DEF_MACHMODE (N##mode, #N, \
- MODE_CC, BITS_PER_UNIT*4, 4, 4, VOIDmode, VOIDmode)
-#include EXTRA_MODES_FILE
-#undef CC
-#endif
+VECTOR_MODES (INT, 2); /* V2QI */
+VECTOR_MODES (INT, 4); /* V4QI V2HI */
+VECTOR_MODES (INT, 8); /* V8QI V4HI V2SI */
+VECTOR_MODES (INT, 16); /* V16QI V8HI V4SI V2DI */
+/* VECTOR_MODES (INT, 32); V8SI V4DI */
+/* VECTOR_MODES (INT, 64); V8DI */
+
+VECTOR_MODE (INT, SI, 8)
+VECTOR_MODE (INT, DI, 4);
+VECTOR_MODE (INT, DI, 8);
+
+VECTOR_MODE (INT, DI, 1); /* PPC uses this. Why not plain DI? */
+
+VECTOR_MODES (FLOAT, 4); /* V2HF */
+VECTOR_MODES (FLOAT, 8); /* V4HF V2SF */
+VECTOR_MODES (FLOAT, 16); /* V8HF V4SF V2DF */
+/* VECTOR_MODES (FLOAT, 32); V8SF V4DF */
+/* VECTOR_MODES (FLOAT, 64); V16SF V8DF */
+
+VECTOR_MODE (FLOAT, SF, 8);
+VECTOR_MODE (FLOAT, SF, 16);
+VECTOR_MODE (FLOAT, DF, 4);
+VECTOR_MODE (FLOAT, DF, 8);
/* The symbol Pmode stands for one of the above machine modes (usually SImode).
- The tm file specifies which one. It is not a distinct mode. */
+ The tm.h file specifies which one. It is not a distinct mode. */
/*
Local variables:
#define HAVE_MACHINE_MODES
/* Make an enum class that gives all the machine modes. */
-
-#define DEF_MACHMODE(SYM, NAME, TYPE, BITSIZE, SIZE, UNIT, WIDER, INNER) SYM,
-
-enum machine_mode {
-#include "machmode.def"
-MAX_MACHINE_MODE };
-
-#undef DEF_MACHMODE
-
-#ifndef NUM_MACHINE_MODES
-#define NUM_MACHINE_MODES (int) MAX_MACHINE_MODE
-#endif
+#include "insn-modes.h"
/* Get the name of mode MODE as a string. */
extern const char * const mode_name[NUM_MACHINE_MODES];
-#define GET_MODE_NAME(MODE) (mode_name[(int) (MODE)])
+#define GET_MODE_NAME(MODE) mode_name[MODE]
+
+/* Mode classes. */
-enum mode_class { MODE_RANDOM, MODE_INT, MODE_FLOAT, MODE_PARTIAL_INT, MODE_CC,
- MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT,
- MODE_VECTOR_INT, MODE_VECTOR_FLOAT,
- MAX_MODE_CLASS};
+#include "mode-classes.def"
+#define DEF_MODE_CLASS(M) M
+enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
+#undef DEF_MODE_CLASS
+#undef MODE_CLASSES
/* Get the general kind of object that mode MODE represents
(integer, floating, complex, etc.) */
-extern const enum mode_class mode_class[NUM_MACHINE_MODES];
-#define GET_MODE_CLASS(MODE) (mode_class[(int) (MODE)])
+extern const unsigned char mode_class[NUM_MACHINE_MODES];
+#define GET_MODE_CLASS(MODE) mode_class[MODE]
/* Nonzero if MODE is an integral mode. */
#define INTEGRAL_MODE_P(MODE) \
/* Get the size in bytes of an object of mode MODE. */
extern const unsigned char mode_size[NUM_MACHINE_MODES];
-#define GET_MODE_SIZE(MODE) (mode_size[(int) (MODE)])
+#define GET_MODE_SIZE(MODE) mode_size[MODE]
/* Get the size in bytes of the basic parts of an object of mode MODE. */
extern const unsigned char mode_unit_size[NUM_MACHINE_MODES];
-#define GET_MODE_UNIT_SIZE(MODE) (mode_unit_size[(int) (MODE)])
+#define GET_MODE_UNIT_SIZE(MODE) mode_unit_size[MODE]
/* Get the number of units in the object. */
/* Get the size in bits of an object of mode MODE. */
extern const unsigned short mode_bitsize[NUM_MACHINE_MODES];
-#define GET_MODE_BITSIZE(MODE) (mode_bitsize[(int) (MODE)])
+#define GET_MODE_BITSIZE(MODE) mode_bitsize[MODE]
#endif /* not HAVE_MACHINE_MODES */
extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
-#define GET_MODE_MASK(MODE) mode_mask_array[(int) (MODE)]
+#define GET_MODE_MASK(MODE) mode_mask_array[MODE]
-extern const enum machine_mode inner_mode_array[NUM_MACHINE_MODES];
+extern const unsigned char mode_inner[NUM_MACHINE_MODES];
/* Return the mode of the inner elements in a vector. */
-#define GET_MODE_INNER(MODE) inner_mode_array[(int) (MODE)]
+#define GET_MODE_INNER(MODE) mode_inner[MODE]
#endif /* defined (HOST_WIDE_INT) && ! defined GET_MODE_MASK */
/* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI). */
-extern const unsigned char mode_wider_mode[NUM_MACHINE_MODES];
-#define GET_MODE_WIDER_MODE(MODE) ((enum machine_mode)mode_wider_mode[(int) (MODE)])
+extern const unsigned char mode_wider[NUM_MACHINE_MODES];
+#define GET_MODE_WIDER_MODE(MODE) mode_wider[MODE]
/* Return the mode for data of a given size SIZE and mode class CLASS.
If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
/* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT. */
+extern const unsigned char mode_base_align[NUM_MACHINE_MODES];
+
extern unsigned get_mode_alignment (enum machine_mode);
#define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
/* For each class, get the narrowest mode in that class. */
-extern const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS];
-#define GET_CLASS_NARROWEST_MODE(CLASS) class_narrowest_mode[(int) (CLASS)]
+extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
+#define GET_CLASS_NARROWEST_MODE(CLASS) class_narrowest_mode[CLASS]
/* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
and the mode whose class is Pmode and whose size is POINTER_SIZE. */
--- /dev/null
+/* Machine mode class definitions for GCC.
+ Copyright (C) 2003
+ Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
+
+#define MODE_CLASSES \
+ DEF_MODE_CLASS (MODE_RANDOM), /* other */ \
+ DEF_MODE_CLASS (MODE_CC), /* condition code in a register */ \
+ DEF_MODE_CLASS (MODE_INT), /* integer */ \
+ DEF_MODE_CLASS (MODE_PARTIAL_INT), /* integer with padding bits */ \
+ DEF_MODE_CLASS (MODE_FLOAT), /* floating point */ \
+ DEF_MODE_CLASS (MODE_COMPLEX_INT), /* complex numbers */ \
+ DEF_MODE_CLASS (MODE_COMPLEX_FLOAT), \
+ DEF_MODE_CLASS (MODE_VECTOR_INT), /* SIMD vectors */ \
+ DEF_MODE_CLASS (MODE_VECTOR_FLOAT)
/* The target format used for each floating floating point mode.
Indexed by MODE - QFmode. */
-extern const struct real_format *real_format_for_mode[TFmode - QFmode + 1];
+extern const struct real_format *
+ real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1];
-#define REAL_MODE_FORMAT(MODE) (real_format_for_mode[(MODE) - QFmode])
+#define REAL_MODE_FORMAT(MODE) (real_format_for_mode[(MODE) - MIN_MODE_FLOAT])
/* Declare functions in real.c. */
#undef DEF_RTL_EXPR
-/* Indexed by machine mode, gives the name of that machine mode.
- This name does not include the letters "mode". */
-
-#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) NAME,
-
-const char * const mode_name[NUM_MACHINE_MODES] = {
-#include "machmode.def"
-};
-
-#undef DEF_MACHMODE
-
-/* Indexed by machine mode, gives the class mode for GET_MODE_CLASS. */
-
-#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) CLASS,
-
-const enum mode_class mode_class[NUM_MACHINE_MODES] = {
-#include "machmode.def"
-};
-
-#undef DEF_MACHMODE
-
-/* Indexed by machine mode, gives the length of the mode, in bits.
- GET_MODE_BITSIZE uses this. */
-
-#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) BITSIZE,
-
-const unsigned short mode_bitsize[NUM_MACHINE_MODES] = {
-#include "machmode.def"
-};
-
-#undef DEF_MACHMODE
-
-/* Indexed by machine mode, gives the length of the mode, in bytes.
- GET_MODE_SIZE uses this. */
-
-#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) SIZE,
-
-const unsigned char mode_size[NUM_MACHINE_MODES] = {
-#include "machmode.def"
-};
-
-#undef DEF_MACHMODE
-
-/* Indexed by machine mode, gives the length of the mode's subunit.
- GET_MODE_UNIT_SIZE uses this. */
-
-#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) UNIT,
-
-const unsigned char mode_unit_size[NUM_MACHINE_MODES] = {
-#include "machmode.def" /* machine modes are documented here */
-};
-
-#undef DEF_MACHMODE
-
-/* Indexed by machine mode, gives next wider natural mode
- (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
- use this. */
-
-#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \
- (unsigned char) WIDER,
-
-const unsigned char mode_wider_mode[NUM_MACHINE_MODES] = {
-#include "machmode.def" /* machine modes are documented here */
-};
-
-#undef DEF_MACHMODE
-
-#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \
- ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT) 0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
-
-/* Indexed by machine mode, gives mask of significant bits in mode. */
-
-const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES] = {
-#include "machmode.def"
-};
-
-#undef DEF_MACHMODE
-
-#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) INNER,
-
-/* Indexed by machine mode, gives the mode of the inner elements in a
- vector type. */
-
-const enum machine_mode inner_mode_array[NUM_MACHINE_MODES] = {
-#include "machmode.def"
-};
-
-/* Indexed by mode class, gives the narrowest mode for each class.
- The Q modes are always of width 1 (2 for complex) - it is impossible
- for any mode to be narrower.
-
- Note that we use QImode instead of BImode for MODE_INT, since
- otherwise the middle end will try to use it for bitfields in
- structures and the like, which we do not want. Only the target
- md file should generate BImode widgets. */
-
-const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
- /* MODE_RANDOM */ VOIDmode,
- /* MODE_INT */ QImode,
- /* MODE_FLOAT */ QFmode,
- /* MODE_PARTIAL_INT */ PQImode,
- /* MODE_CC */ CCmode,
- /* MODE_COMPLEX_INT */ CQImode,
- /* MODE_COMPLEX_FLOAT */ QCmode,
- /* MODE_VECTOR_INT */ V1DImode,
- /* MODE_VECTOR_FLOAT */ V2SFmode
-};
-
-
/* Indexed by rtx code, gives a sequence of operand-types for
rtx's of that code. The sequence is a C string in which
each character describes one operand. */
unsigned int
get_mode_alignment (enum machine_mode mode)
{
- unsigned int alignment;
-
- if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
- || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
- alignment = GET_MODE_UNIT_SIZE (mode);
- else
- alignment = GET_MODE_SIZE (mode);
-
- /* Extract the LSB of the size. */
- alignment = alignment & -alignment;
- alignment *= BITS_PER_UNIT;
-
- alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment));
- return alignment;
+ return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT));
}
/* Return the value of VALUE, rounded up to a multiple of DIVISOR.
OSDN Git Service
