diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 697368266b3..aafd1b536f7 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -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 insn-config.h insn-codes.h \
  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_H) coretypes.h $(TM_H) $(RTL_H) \
 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 $(BUILD_LIBDEPS)
 	$(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 $@ \
@@ -2270,6 +2288,12 @@ $(BUILD_PREFIX_1)ggc-none.o: ggc-none.c $(BCONFIG_H) coretypes.h $(GTM_H) $(SYST
 	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.
 intl.o: intl.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) intl.h Makefile
diff --git a/gcc/config/ip2k/ip2k.h b/gcc/config/ip2k/ip2k.h
index d3d77dc8fc0..88b90b0c186 100644
--- a/gcc/config/ip2k/ip2k.h
+++ b/gcc/config/ip2k/ip2k.h
@@ -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)
 
diff --git a/gcc/config/iq2000/iq2000.h b/gcc/config/iq2000/iq2000.h
index 15fa240432b..f32d0c388c9 100644
--- a/gcc/config/iq2000/iq2000.h
+++ b/gcc/config/iq2000/iq2000.h
@@ -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
diff --git a/gcc/gengenrtl.c b/gcc/gengenrtl.c
index 80ff784ba54..9fe9481bc8e 100644
--- a/gcc/gengenrtl.c
+++ b/gcc/gengenrtl.c
@@ -22,26 +22,24 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 #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);
 
diff --git a/gcc/genmodes.c b/gcc/genmodes.c
new file mode 100644
index 00000000000..7a5d2951b1b
--- /dev/null
+++ b/gcc/genmodes.c
@@ -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;
+}
diff --git a/gcc/machmode.def b/gcc/machmode.def
index 8555a6ee58d..8688f8ad029 100644
--- a/gcc/machmode.def
+++ b/gcc/machmode.def
@@ -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 - Suite 330, Boston, MA
    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".
+/* 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 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.
+   The following statements can be used in this file -- all have
+   the form of a C macro call.  In their arguments:
 
-   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
+   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.
 
-   Fourth argument is the relative size of the object, in bits,
-   so we can have modes smaller than 1 byte.
+   A MODE argument must be the printable name of a machine mode,
+   without quotation marks or trailing "mode".  For instance, SI.
 
-   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. 
+   A BITSIZE, BYTESIZE, or COUNT argument must be a positive integer
+   constant.
 
-   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.
+   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.
 
-   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.
+     RANDOM_MODE (MODE);
+        declares MODE to be of class RANDOM.
 
-   Eigth arg is the mode of the internal elements in a vector or
-   complex, and VOIDmode if not applicable.
-*/
+     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)
+PARTIAL_INT_MODE (QI);
+PARTIAL_INT_MODE (HI);
+PARTIAL_INT_MODE (SI);
+PARTIAL_INT_MODE (DI);
 
-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)
+/* 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);
 
-/* 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)
+/* Basic CC modes.  */
+CC_MODE (CC);
 
-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)
-
-/* 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
+/* 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.  */
+COMPLEX_MODES (INT);
+COMPLEX_MODES (FLOAT);
+
+/* Vector modes.  */
+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:
diff --git a/gcc/machmode.h b/gcc/machmode.h
index fbb48505e86..4c4086c312d 100644
--- a/gcc/machmode.h
+++ b/gcc/machmode.h
@@ -23,34 +23,26 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #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[NUM_MACHINE_MODES];
 /* 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_size[NUM_MACHINE_MODES];
 /* 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[NUM_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 */
 
@@ -129,8 +121,8 @@ extern const enum machine_mode inner_mode_array[NUM_MACHINE_MODES];
 
 /* 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 (int, int, unsigned int,
 
 /* 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.  */
diff --git a/gcc/mode-classes.def b/gcc/mode-classes.def
new file mode 100644
index 00000000000..d154493ebcc
--- /dev/null
+++ b/gcc/mode-classes.def
@@ -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)
diff --git a/gcc/real.h b/gcc/real.h
index e897098507c..3620d50580a 100644
--- a/gcc/real.h
+++ b/gcc/real.h
@@ -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.  */
 
diff --git a/gcc/rtl.c b/gcc/rtl.c
index 54b7476c738..f339ff69270 100644
--- a/gcc/rtl.c
+++ b/gcc/rtl.c
@@ -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.  */
diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index a7ffd4cb6d8..dcdca573a8c 100644
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -298,20 +298,7 @@ int_mode_for_mode (enum machine_mode mode)
 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.