Target-dependent modes (1/3)
Zack Weinberg
zack@codesourcery.com
Fri Oct 10 20:31:00 GMT 2003
Now that the language independent compiler isn't riddled with
assumptions about which machine modes exist, we can give targets
more ability to tweak the set of modes as suits them. This is the
first of three patches to do that. It adds a 'genmodes' program to
produce the tables of modes. For now, we are generating exactly the
same set of modes for all targets as we used to. However, the power
of the ARCH-modes.def file is now greatly increased; the next two
patches in this series will make use of that power.
This patch also gives us MIN_* and MAX_* constants for every mode
class, which can be used to remove some more hardwired uses of mode
constants; for instance, in real.h. And the way GET_MODE_ALIGNMENT
works has been changed a bit, which is a sign of things to come.
The changes to gengenrtl are related insofar as it may no longer be
possible for gengenrtl to include rtl.h (it wasn't in an earlier
revision and I haven't bothered to check if it is again), and in any
case it is unnecessary. There's a bit of a type botch in there which
I will fix in a subsequent patch.
I also removed redundant definitions of BITS_PER_UNIT from iq2000.h
and ip2k.h.
Bootstrapped i686-linux.
zw
* genmodes.c, mode-classes.def: New files.
* machmode.def: Rewritten to genmodes.c interface.
* Makefile.in (extra_modes_file): New substitution variable.
(MACHMODE_H): No longer includes machmode.def or
@extra_modes_file@; instead, mode-classes.def and insn-modes.h.
(BUILD_RTL): Add $(BUILD_PREFIX)insn-modes.o.
(OBJS-common): Add insn-modes.o.
(STAGESTUFF): Add insn-modes.c, insn-modes.h, s-modes, and
genmodes$(build_exeext).
(insn-modes.o, insn-modes.c, insn-modes.h, s-modes, genmodes.o,
genmodes$(build_exeext), $(BUILD_PREFIX_1)insn-modes.o): New targets.
(s-genrtl): Don't depend on $(RTL_BASE_H).
(gengenrtl.o): Don't depend on coretypes.h, $(GTM_H), real.h,
or $(RTL_BASE_H); just rtl.def.
* gengenrtl.c: Don't include coretypes.h, tm.h, rtl.h, or
real.h. Give fake definition of CONST_DOUBLE_FORMAT and
substitute definition of NUM_RTX_CODE. Add casts to avoid
warnings.
* machmode.h: Include insn-modes.h, not machmode.def. Include
mode-classes.def to define enum mode_class. Tweak definitions
of GET_MODE_CLASS, GET_MODE_SIZE, GET_MODE_BITSIZE, GET_MODE_MASK,
GET_MODE_INNER, GET_MODE_WIDER_MODE, GET_CLASS_NARROWEST_MODE.
(inner_mode_array): Renamed mode_inner.
(mode_base_align): New.
* rtl.c (mode_name, mode_class, mode_bitsize, mode_size,
mode_unit_size, mode_wider_mode, mode_mask_array,
inner_mode_array, class_narrowest_mode): Delete definitions.
* stor-layout.c (get_mode_alignment): Use mode_base_align.
* real.h: Use MIN_MODE_FLOAT and MAX_MODE_FLOAT, not QFmode
and TFmode, in real_format_for_mode and REAL_MODE_FORMAT.
* config/ip2k/ip2k.h, config/iq2000/iq2000.h:
No need to define BITS_PER_UNIT.
===================================================================
Index: Makefile.in
--- Makefile.in 8 Oct 2003 12:24:06 -0000 1.1168
+++ Makefile.in 10 Oct 2003 20:03:45 -0000
@@ -362,6 +362,7 @@ target_cpu_default=@target_cpu_default@
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@
@@ -632,7 +633,7 @@ TARGET_H = target.h
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
@@ -714,7 +715,7 @@ LDEXP_LIB = @LDEXP_LIB@
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
@@ -834,7 +835,7 @@ OBJS-common = \
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 \
@@ -862,8 +863,8 @@ BACKEND = main.o libbackend.a
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) \
@@ -871,7 +872,7 @@ STAGESTUFF = *$(objext) insn-flags.h ins
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) \
@@ -2000,13 +2001,24 @@ genrtl.o : genrtl.c $(CONFIG_H) $(SYSTEM
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
@@ -2176,8 +2188,14 @@ gengenrtl$(build_exeext) : gengenrtl.o $
$(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 $@ \
@@ -2269,6 +2287,12 @@ $(BUILD_PREFIX_1)ggc-none.o: ggc-none.c
rm -f $(BUILD_PREFIX)ggc-none.c
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)
#
# Remake internationalization support.
===================================================================
Index: gengenrtl.c
--- gengenrtl.c 5 Jul 2003 05:27:22 -0000 1.63
+++ gengenrtl.c 10 Oct 2003 20:03:45 -0000
@@ -22,26 +22,24 @@ Software Foundation, 59 Temple Place - S
#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];
@@ -169,7 +167,7 @@ find_formats (void)
{
int i;
- for (i = 0; i < NUM_RTX_CODE; i++)
+ for (i = 0; i < (int)NUM_RTX_CODE; i++)
{
const char **f;
@@ -309,7 +307,7 @@ genheader (void)
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);
===================================================================
Index: genmodes.c
--- genmodes.c 1 Jan 1970 00:00:00 -0000
+++ genmodes.c 10 Oct 2003 20:03:46 -0000
@@ -0,0 +1,908 @@
+/* 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;
+}
===================================================================
Index: machmode.def
--- machmode.def 16 Jun 2003 19:14:21 -0000 1.23
+++ machmode.def 10 Oct 2003 20:03:46 -0000
@@ -1,6 +1,7 @@
/* 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.
@@ -31,145 +32,165 @@ Software Foundation, 59 Temple Place - S
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);
-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)
+/* 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);
+
+/* 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:
===================================================================
Index: machmode.h
--- machmode.h 6 Jul 2003 09:56:04 -0000 1.33
+++ machmode.h 10 Oct 2003 20:03:46 -0000
@@ -23,34 +23,26 @@ Software Foundation, 59 Temple Place - S
#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]
-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};
+/* Mode classes. */
+
+#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) \
@@ -87,12 +79,12 @@ extern const enum mode_class mode_class[
/* 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. */
@@ -103,7 +95,7 @@ extern const unsigned char mode_unit_siz
/* 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 */
@@ -114,13 +106,13 @@ extern const unsigned short mode_bitsize
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 */
@@ -129,8 +121,8 @@ extern const enum machine_mode inner_mod
/* 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.
@@ -156,14 +148,16 @@ extern enum machine_mode get_best_mode (
/* 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. */
===================================================================
Index: mode-classes.def
--- mode-classes.def 1 Jan 1970 00:00:00 -0000
+++ mode-classes.def 10 Oct 2003 20:03:46 -0000
@@ -0,0 +1,31 @@
+/* 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)
===================================================================
Index: real.h
--- real.h 6 Oct 2003 22:47:18 -0000 1.74
+++ real.h 10 Oct 2003 20:03:46 -0000
@@ -143,9 +143,10 @@ struct real_format
/* 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. */
===================================================================
Index: rtl.c
--- rtl.c 30 Jul 2003 19:23:31 -0000 1.126
+++ rtl.c 10 Oct 2003 20:03:46 -0000
@@ -50,115 +50,6 @@ const char * const rtx_name[NUM_RTX_CODE
#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. */
===================================================================
Index: stor-layout.c
--- stor-layout.c 10 Oct 2003 19:21:11 -0000 1.169
+++ stor-layout.c 10 Oct 2003 20:03:47 -0000
@@ -298,20 +298,7 @@ int_mode_for_mode (enum machine_mode mod
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.
===================================================================
Index: config/ip2k/ip2k.h
--- config/ip2k/ip2k.h 2 Oct 2003 00:44:23 -0000 1.29
+++ config/ip2k/ip2k.h 10 Oct 2003 20:03:47 -0000
@@ -63,7 +63,6 @@ extern int target_flags;
#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)
===================================================================
Index: config/iq2000/iq2000.h
--- config/iq2000/iq2000.h 2 Oct 2003 00:44:23 -0000 1.5
+++ config/iq2000/iq2000.h 10 Oct 2003 20:03:47 -0000
@@ -142,8 +142,6 @@ extern int target_flags;
#define LIBGCC2_WORDS_BIG_ENDIAN 1
-#define BITS_PER_UNIT 8
-
#define BITS_PER_WORD 32
#define MAX_BITS_PER_WORD 64
More information about the Gcc-patches
mailing list