gcc/genmodes.c

   1 /* Generate the machine mode enumeration and associated tables.
   2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2010
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "bconfig.h"
  22 #include "system.h"
  23 #include "errors.h"
  24 #include "hashtab.h"
  25
  26 /* enum mode_class is normally defined by machmode.h but we can't
  27    include that header here.  */
  28 #include "mode-classes.def"
  29
  30 #define DEF_MODE_CLASS(M) M
  31 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
  32 #undef DEF_MODE_CLASS
  33
  34 /* Text names of mode classes, for output.  */
  35 #define DEF_MODE_CLASS(M) #M
  36 static const char *const mode_class_names[MAX_MODE_CLASS] =
  37 {
  38   MODE_CLASSES
  39 };
  40 #undef DEF_MODE_CLASS
  41 #undef MODE_CLASSES
  42
  43 #ifdef EXTRA_MODES_FILE
  44 # define HAVE_EXTRA_MODES 1
  45 #else
  46 # define HAVE_EXTRA_MODES 0
  47 # define EXTRA_MODES_FILE ""
  48 #endif
  49
  50 /* Data structure for building up what we know about a mode.
  51    They're clustered by mode class.  */
  52 struct mode_data
  53 {
  54   struct mode_data *next;       /* next this class - arbitrary order */
  55
  56   const char *name;             /* printable mode name -- SI, not SImode */
  57   enum mode_class cl;           /* this mode class */
  58   unsigned int precision;       /* size in bits, equiv to TYPE_PRECISION */
  59   unsigned int bytesize;        /* storage size in addressable units */
  60   unsigned int ncomponents;     /* number of subunits */
  61   unsigned int alignment;       /* mode alignment */
  62   const char *format;           /* floating point format - float modes only */
  63
  64   struct mode_data *component;  /* mode of components */
  65   struct mode_data *wider;      /* next wider mode */
  66
  67   struct mode_data *contained;  /* Pointer to list of modes that have
  68                                    this mode as a component.  */
  69   struct mode_data *next_cont;  /* Next mode in that list.  */
  70
  71   const char *file;             /* file and line of definition, */
  72   unsigned int line;            /* for error reporting */
  73   unsigned int counter;         /* Rank ordering of modes */
  74   unsigned int ibit;            /* the number of integral bits */
  75   unsigned int fbit;            /* the number of fractional bits */
  76 };
  77
  78 static struct mode_data *modes[MAX_MODE_CLASS];
  79 static unsigned int n_modes[MAX_MODE_CLASS];
  80 static struct mode_data *void_mode;
  81
  82 static const struct mode_data blank_mode = {
  83   0, "<unknown>", MAX_MODE_CLASS,
  84   -1U, -1U, -1U, -1U,
  85   0, 0, 0, 0, 0,
  86   "<unknown>", 0, 0, 0, 0
  87 };
  88
  89 static htab_t modes_by_name;
  90
  91 /* Data structure for recording target-specified runtime adjustments
  92    to a particular mode.  We support varying the byte size, the
  93    alignment, and the floating point format.  */
  94 struct mode_adjust
  95 {
  96   struct mode_adjust *next;
  97   struct mode_data *mode;
  98   const char *adjustment;
  99
 100   const char *file;
 101   unsigned int line;
 102 };
 103
 104 static struct mode_adjust *adj_bytesize;
 105 static struct mode_adjust *adj_alignment;
 106 static struct mode_adjust *adj_format;
 107 static struct mode_adjust *adj_ibit;
 108 static struct mode_adjust *adj_fbit;
 109
 110 /* Mode class operations.  */
 111 static enum mode_class
 112 complex_class (enum mode_class c)
 113 {
 114   switch (c)
 115     {
 116     case MODE_INT: return MODE_COMPLEX_INT;
 117     case MODE_FLOAT: return MODE_COMPLEX_FLOAT;
 118     default:
 119       error ("no complex class for class %s", mode_class_names[c]);
 120       return MODE_RANDOM;
 121     }
 122 }
 123
 124 static enum mode_class
 125 vector_class (enum mode_class cl)
 126 {
 127   switch (cl)
 128     {
 129     case MODE_INT: return MODE_VECTOR_INT;
 130     case MODE_FLOAT: return MODE_VECTOR_FLOAT;
 131     case MODE_FRACT: return MODE_VECTOR_FRACT;
 132     case MODE_UFRACT: return MODE_VECTOR_UFRACT;
 133     case MODE_ACCUM: return MODE_VECTOR_ACCUM;
 134     case MODE_UACCUM: return MODE_VECTOR_UACCUM;
 135     default:
 136       error ("no vector class for class %s", mode_class_names[cl]);
 137       return MODE_RANDOM;
 138     }
 139 }
 140
 141 /* Utility routines.  */
 142 static inline struct mode_data *
 143 find_mode (const char *name)
 144 {
 145   struct mode_data key;
 146
 147   key.name = name;
 148   return (struct mode_data *) htab_find (modes_by_name, &key);
 149 }
 150
 151 static struct mode_data *
 152 new_mode (enum mode_class cl, const char *name,
 153           const char *file, unsigned int line)
 154 {
 155   struct mode_data *m;
 156   static unsigned int count = 0;
 157
 158   m = find_mode (name);
 159   if (m)
 160     {
 161       error ("%s:%d: duplicate definition of mode \"%s\"",
 162              trim_filename (file), line, name);
 163       error ("%s:%d: previous definition here", m->file, m->line);
 164       return m;
 165     }
 166
 167   m = XNEW (struct mode_data);
 168   memcpy (m, &blank_mode, sizeof (struct mode_data));
 169   m->cl = cl;
 170   m->name = name;
 171   if (file)
 172     m->file = trim_filename (file);
 173   m->line = line;
 174   m->counter = count++;
 175
 176   m->next = modes[cl];
 177   modes[cl] = m;
 178   n_modes[cl]++;
 179
 180   *htab_find_slot (modes_by_name, m, INSERT) = m;
 181
 182   return m;
 183 }
 184
 185 static hashval_t
 186 hash_mode (const void *p)
 187 {
 188   const struct mode_data *m = (const struct mode_data *)p;
 189   return htab_hash_string (m->name);
 190 }
 191
 192 static int
 193 eq_mode (const void *p, const void *q)
 194 {
 195   const struct mode_data *a = (const struct mode_data *)p;
 196   const struct mode_data *b = (const struct mode_data *)q;
 197
 198   return !strcmp (a->name, b->name);
 199 }
 200
 201 #define for_all_modes(C, M)                     \
 202   for (C = 0; C < MAX_MODE_CLASS; C++)          \
 203     for (M = modes[C]; M; M = M->next)
 204
 205 static void ATTRIBUTE_UNUSED
 206 new_adjust (const char *name,
 207             struct mode_adjust **category, const char *catname,
 208             const char *adjustment,
 209             enum mode_class required_class_from,
 210             enum mode_class required_class_to,
 211             const char *file, unsigned int line)
 212 {
 213   struct mode_data *mode = find_mode (name);
 214   struct mode_adjust *a;
 215
 216   file = trim_filename (file);
 217
 218   if (!mode)
 219     {
 220       error ("%s:%d: no mode \"%s\"", file, line, name);
 221       return;
 222     }
 223
 224   if (required_class_from != MODE_RANDOM
 225       && (mode->cl < required_class_from || mode->cl > required_class_to))
 226     {
 227       error ("%s:%d: mode \"%s\" is not among class {%s, %s}",
 228              file, line, name, mode_class_names[required_class_from] + 5,
 229              mode_class_names[required_class_to] + 5);
 230       return;
 231     }
 232
 233   for (a = *category; a; a = a->next)
 234     if (a->mode == mode)
 235       {
 236         error ("%s:%d: mode \"%s\" already has a %s adjustment",
 237                file, line, name, catname);
 238         error ("%s:%d: previous adjustment here", a->file, a->line);
 239         return;
 240       }
 241
 242   a = XNEW (struct mode_adjust);
 243   a->mode = mode;
 244   a->adjustment = adjustment;
 245   a->file = file;
 246   a->line = line;
 247
 248   a->next = *category;
 249   *category = a;
 250 }
 251
 252 /* Diagnose failure to meet expectations in a partially filled out
 253    mode structure.  */
 254 enum requirement { SET, UNSET, OPTIONAL };
 255
 256 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
 257   switch (req)                                                          \
 258     {                                                                   \
 259     case SET:                                                           \
 260       if (val == unset)                                                 \
 261         error ("%s:%d: (%s) field %s must be set",                      \
 262                file, line, mname, fname);                               \
 263       break;                                                            \
 264     case UNSET:                                                         \
 265       if (val != unset)                                                 \
 266         error ("%s:%d: (%s) field %s must not be set",                  \
 267                file, line, mname, fname);                               \
 268     case OPTIONAL:                                                      \
 269       break;                                                            \
 270     }                                                                   \
 271 } while (0)
 272
 273 #define validate_field(M, F) \
 274   validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
 275
 276 static void
 277 validate_mode (struct mode_data *m,
 278                enum requirement r_precision,
 279                enum requirement r_bytesize,
 280                enum requirement r_component,
 281                enum requirement r_ncomponents,
 282                enum requirement r_format)
 283 {
 284   validate_field (m, precision);
 285   validate_field (m, bytesize);
 286   validate_field (m, component);
 287   validate_field (m, ncomponents);
 288   validate_field (m, format);
 289 }
 290 #undef validate_field
 291 #undef validate_field_
 292
 293 /* Given a partially-filled-out mode structure, figure out what we can
 294    and fill the rest of it in; die if it isn't enough.  */
 295 static void
 296 complete_mode (struct mode_data *m)
 297 {
 298   unsigned int alignment;
 299
 300   if (!m->name)
 301     {
 302       error ("%s:%d: mode with no name", m->file, m->line);
 303       return;
 304     }
 305   if (m->cl == MAX_MODE_CLASS)
 306     {
 307       error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
 308       return;
 309     }
 310
 311   switch (m->cl)
 312     {
 313     case MODE_RANDOM:
 314       /* Nothing more need be said.  */
 315       if (!strcmp (m->name, "VOID"))
 316         void_mode = m;
 317
 318       validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
 319
 320       m->precision = 0;
 321       m->bytesize = 0;
 322       m->ncomponents = 0;
 323       m->component = 0;
 324       break;
 325
 326     case MODE_CC:
 327       /* Again, nothing more need be said.  For historical reasons,
 328          the size of a CC mode is four units.  */
 329       validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
 330
 331       m->bytesize = 4;
 332       m->ncomponents = 1;
 333       m->component = 0;
 334       break;
 335
 336     case MODE_INT:
 337     case MODE_FLOAT:
 338     case MODE_DECIMAL_FLOAT:
 339     case MODE_FRACT:
 340     case MODE_UFRACT:
 341     case MODE_ACCUM:
 342     case MODE_UACCUM:
 343       /* A scalar mode must have a byte size, may have a bit size,
 344          and must not have components.   A float mode must have a
 345          format.  */
 346       validate_mode (m, OPTIONAL, SET, UNSET, UNSET,
 347                      (m->cl == MODE_FLOAT || m->cl == MODE_DECIMAL_FLOAT)
 348                      ? SET : UNSET);
 349
 350       m->ncomponents = 1;
 351       m->component = 0;
 352       break;
 353
 354     case MODE_PARTIAL_INT:
 355       /* A partial integer mode uses ->component to say what the
 356          corresponding full-size integer mode is, and may also
 357          specify a bit size.  */
 358       validate_mode (m, OPTIONAL, UNSET, SET, UNSET, UNSET);
 359
 360       m->bytesize = m->component->bytesize;
 361
 362       m->ncomponents = 1;
 363       m->component = 0;  /* ??? preserve this */
 364       break;
 365
 366     case MODE_COMPLEX_INT:
 367     case MODE_COMPLEX_FLOAT:
 368       /* Complex modes should have a component indicated, but no more.  */
 369       validate_mode (m, UNSET, UNSET, SET, UNSET, UNSET);
 370       m->ncomponents = 2;
 371       if (m->component->precision != (unsigned int)-1)
 372         m->precision = 2 * m->component->precision;
 373       m->bytesize = 2 * m->component->bytesize;
 374       break;
 375
 376     case MODE_VECTOR_INT:
 377     case MODE_VECTOR_FLOAT:
 378     case MODE_VECTOR_FRACT:
 379     case MODE_VECTOR_UFRACT:
 380     case MODE_VECTOR_ACCUM:
 381     case MODE_VECTOR_UACCUM:
 382       /* Vector modes should have a component and a number of components.  */
 383       validate_mode (m, UNSET, UNSET, SET, SET, UNSET);
 384       if (m->component->precision != (unsigned int)-1)
 385         m->precision = m->ncomponents * m->component->precision;
 386       m->bytesize = m->ncomponents * m->component->bytesize;
 387       break;
 388
 389     default:
 390       gcc_unreachable ();
 391     }
 392
 393   /* If not already specified, the mode alignment defaults to the largest
 394      power of two that divides the size of the object.  Complex types are
 395      not more aligned than their contents.  */
 396   if (m->cl == MODE_COMPLEX_INT || m->cl == MODE_COMPLEX_FLOAT)
 397     alignment = m->component->bytesize;
 398   else
 399     alignment = m->bytesize;
 400
 401   m->alignment = alignment & (~alignment + 1);
 402
 403   /* If this mode has components, make the component mode point back
 404      to this mode, for the sake of adjustments.  */
 405   if (m->component)
 406     {
 407       m->next_cont = m->component->contained;
 408       m->component->contained = m;
 409     }
 410 }
 411
 412 static void
 413 complete_all_modes (void)
 414 {
 415   struct mode_data *m;
 416   int cl;
 417
 418   for_all_modes (cl, m)
 419     complete_mode (m);
 420 }
 421
 422 /* For each mode in class CLASS, construct a corresponding complex mode.  */
 423 #define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
 424 static void
 425 make_complex_modes (enum mode_class cl,
 426                     const char *file, unsigned int line)
 427 {
 428   struct mode_data *m;
 429   struct mode_data *c;
 430   char buf[8];
 431   enum mode_class cclass = complex_class (cl);
 432
 433   if (cclass == MODE_RANDOM)
 434     return;
 435
 436   for (m = modes[cl]; m; m = m->next)
 437     {
 438       /* Skip BImode.  FIXME: BImode probably shouldn't be MODE_INT.  */
 439       if (m->precision == 1)
 440         continue;
 441
 442       if (strlen (m->name) >= sizeof buf)
 443         {
 444           error ("%s:%d:mode name \"%s\" is too long",
 445                  m->file, m->line, m->name);
 446           continue;
 447         }
 448
 449       /* Float complex modes are named SCmode, etc.
 450          Int complex modes are named CSImode, etc.
 451          This inconsistency should be eliminated.  */
 452       if (cl == MODE_FLOAT)
 453         {
 454           char *p, *q = 0;
 455           strncpy (buf, m->name, sizeof buf);
 456           p = strchr (buf, 'F');
 457           if (p == 0)
 458             q = strchr (buf, 'D');
 459           if (p == 0 && q == 0)
 460             {
 461               error ("%s:%d: float mode \"%s\" has no 'F' or 'D'",
 462                      m->file, m->line, m->name);
 463               continue;
 464             }
 465
 466           if (p != 0)
 467             *p = 'C';
 468           else
 469             snprintf (buf, sizeof buf, "C%s", m->name);
 470         }
 471       else
 472         snprintf (buf, sizeof buf, "C%s", m->name);
 473
 474       c = new_mode (cclass, xstrdup (buf), file, line);
 475       c->component = m;
 476     }
 477 }
 478
 479 /* For all modes in class CL, construct vector modes of width
 480    WIDTH, having as many components as necessary.  */
 481 #define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
 482 static void ATTRIBUTE_UNUSED
 483 make_vector_modes (enum mode_class cl, unsigned int width,
 484                    const char *file, unsigned int line)
 485 {
 486   struct mode_data *m;
 487   struct mode_data *v;
 488   char buf[8];
 489   unsigned int ncomponents;
 490   enum mode_class vclass = vector_class (cl);
 491
 492   if (vclass == MODE_RANDOM)
 493     return;
 494
 495   for (m = modes[cl]; m; m = m->next)
 496     {
 497       /* Do not construct vector modes with only one element, or
 498          vector modes where the element size doesn't divide the full
 499          size evenly.  */
 500       ncomponents = width / m->bytesize;
 501       if (ncomponents < 2)
 502         continue;
 503       if (width % m->bytesize)
 504         continue;
 505
 506       /* Skip QFmode and BImode.  FIXME: this special case should
 507          not be necessary.  */
 508       if (cl == MODE_FLOAT && m->bytesize == 1)
 509         continue;
 510       if (cl == MODE_INT && m->precision == 1)
 511         continue;
 512
 513       if ((size_t)snprintf (buf, sizeof buf, "V%u%s", ncomponents, m->name)
 514           >= sizeof buf)
 515         {
 516           error ("%s:%d: mode name \"%s\" is too long",
 517                  m->file, m->line, m->name);
 518           continue;
 519         }
 520
 521       v = new_mode (vclass, xstrdup (buf), file, line);
 522       v->component = m;
 523       v->ncomponents = ncomponents;
 524     }
 525 }
 526
 527 /* Input.  */
 528
 529 #define _SPECIAL_MODE(C, N) make_special_mode(MODE_##C, #N, __FILE__, __LINE__)
 530 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
 531 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
 532
 533 static void
 534 make_special_mode (enum mode_class cl, const char *name,
 535                    const char *file, unsigned int line)
 536 {
 537   new_mode (cl, name, file, line);
 538 }
 539
 540 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
 541 #define FRACTIONAL_INT_MODE(N, B, Y) \
 542   make_int_mode (#N, B, Y, __FILE__, __LINE__)
 543
 544 static void
 545 make_int_mode (const char *name,
 546                unsigned int precision, unsigned int bytesize,
 547                const char *file, unsigned int line)
 548 {
 549   struct mode_data *m = new_mode (MODE_INT, name, file, line);
 550   m->bytesize = bytesize;
 551   m->precision = precision;
 552 }
 553
 554 #define FRACT_MODE(N, Y, F) \
 555         make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
 556
 557 #define UFRACT_MODE(N, Y, F) \
 558         make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
 559
 560 #define ACCUM_MODE(N, Y, I, F) \
 561         make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
 562
 563 #define UACCUM_MODE(N, Y, I, F) \
 564         make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
 565
 566 /* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
 567    FILE, and LINE.  */
 568
 569 static void
 570 make_fixed_point_mode (enum mode_class cl,
 571                        const char *name,
 572                        unsigned int bytesize,
 573                        unsigned int ibit,
 574                        unsigned int fbit,
 575                        const char *file, unsigned int line)
 576 {
 577   struct mode_data *m = new_mode (cl, name, file, line);
 578   m->bytesize = bytesize;
 579   m->ibit = ibit;
 580   m->fbit = fbit;
 581 }
 582
 583 #define FLOAT_MODE(N, Y, F)             FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
 584 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
 585   make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
 586
 587 static void
 588 make_float_mode (const char *name,
 589                  unsigned int precision, unsigned int bytesize,
 590                  const char *format,
 591                  const char *file, unsigned int line)
 592 {
 593   struct mode_data *m = new_mode (MODE_FLOAT, name, file, line);
 594   m->bytesize = bytesize;
 595   m->precision = precision;
 596   m->format = format;
 597 }
 598
 599 #define DECIMAL_FLOAT_MODE(N, Y, F)     \
 600         FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
 601 #define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F)       \
 602   make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
 603
 604 static void
 605 make_decimal_float_mode (const char *name,
 606                          unsigned int precision, unsigned int bytesize,
 607                          const char *format,
 608                          const char *file, unsigned int line)
 609 {
 610   struct mode_data *m = new_mode (MODE_DECIMAL_FLOAT, name, file, line);
 611   m->bytesize = bytesize;
 612   m->precision = precision;
 613   m->format = format;
 614 }
 615
 616 #define RESET_FLOAT_FORMAT(N, F) \
 617   reset_float_format (#N, #F, __FILE__, __LINE__)
 618 static void ATTRIBUTE_UNUSED
 619 reset_float_format (const char *name, const char *format,
 620                     const char *file, unsigned int line)
 621 {
 622   struct mode_data *m = find_mode (name);
 623   if (!m)
 624     {
 625       error ("%s:%d: no mode \"%s\"", file, line, name);
 626       return;
 627     }
 628   if (m->cl != MODE_FLOAT && m->cl != MODE_DECIMAL_FLOAT)
 629     {
 630       error ("%s:%d: mode \"%s\" is not a FLOAT class", file, line, name);
 631       return;
 632     }
 633   m->format = format;
 634 }
 635
 636 /* Partial integer modes are specified by relation to a full integer mode.
 637    For now, we do not attempt to narrow down their bit sizes.  */
 638 #define PARTIAL_INT_MODE(M) \
 639   make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__)
 640 static void ATTRIBUTE_UNUSED
 641 make_partial_integer_mode (const char *base, const char *name,
 642                            unsigned int precision,
 643                            const char *file, unsigned int line)
 644 {
 645   struct mode_data *m;
 646   struct mode_data *component = find_mode (base);
 647   if (!component)
 648     {
 649       error ("%s:%d: no mode \"%s\"", file, line, name);
 650       return;
 651     }
 652   if (component->cl != MODE_INT)
 653     {
 654       error ("%s:%d: mode \"%s\" is not class INT", file, line, name);
 655       return;
 656     }
 657
 658   m = new_mode (MODE_PARTIAL_INT, name, file, line);
 659   m->precision = precision;
 660   m->component = component;
 661 }
 662
 663 /* A single vector mode can be specified by naming its component
 664    mode and the number of components.  */
 665 #define VECTOR_MODE(C, M, N) \
 666   make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
 667 static void ATTRIBUTE_UNUSED
 668 make_vector_mode (enum mode_class bclass,
 669                   const char *base,
 670                   unsigned int ncomponents,
 671                   const char *file, unsigned int line)
 672 {
 673   struct mode_data *v;
 674   enum mode_class vclass = vector_class (bclass);
 675   struct mode_data *component = find_mode (base);
 676   char namebuf[8];
 677
 678   if (vclass == MODE_RANDOM)
 679     return;
 680   if (component == 0)
 681     {
 682       error ("%s:%d: no mode \"%s\"", file, line, base);
 683       return;
 684     }
 685   if (component->cl != bclass
 686       && (component->cl != MODE_PARTIAL_INT
 687           || bclass != MODE_INT))
 688     {
 689       error ("%s:%d: mode \"%s\" is not class %s",
 690              file, line, base, mode_class_names[bclass] + 5);
 691       return;
 692     }
 693
 694   if ((size_t)snprintf (namebuf, sizeof namebuf, "V%u%s",
 695                         ncomponents, base) >= sizeof namebuf)
 696     {
 697       error ("%s:%d: mode name \"%s\" is too long",
 698              file, line, base);
 699       return;
 700     }
 701
 702   v = new_mode (vclass, xstrdup (namebuf), file, line);
 703   v->ncomponents = ncomponents;
 704   v->component = component;
 705 }
 706
 707 /* Adjustability.  */
 708 #define _ADD_ADJUST(A, M, X, C1, C2) \
 709   new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
 710
 711 #define ADJUST_BYTESIZE(M, X)  _ADD_ADJUST(bytesize, M, X, RANDOM, RANDOM)
 712 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST(alignment, M, X, RANDOM, RANDOM)
 713 #define ADJUST_FLOAT_FORMAT(M, X)    _ADD_ADJUST(format, M, X, FLOAT, FLOAT)
 714 #define ADJUST_IBIT(M, X)  _ADD_ADJUST(ibit, M, X, ACCUM, UACCUM)
 715 #define ADJUST_FBIT(M, X)  _ADD_ADJUST(fbit, M, X, FRACT, UACCUM)
 716
 717 static void
 718 create_modes (void)
 719 {
 720 #include "machmode.def"
 721 }
 722
 723 /* Processing.  */
 724
 725 /* Sort a list of modes into the order needed for the WIDER field:
 726    major sort by precision, minor sort by component precision.
 727
 728    For instance:
 729      QI < HI < SI < DI < TI
 730      V4QI < V2HI < V8QI < V4HI < V2SI.
 731
 732    If the precision is not set, sort by the bytesize.  A mode with
 733    precision set gets sorted before a mode without precision set, if
 734    they have the same bytesize; this is the right thing because
 735    the precision must always be smaller than the bytesize * BITS_PER_UNIT.
 736    We don't have to do anything special to get this done -- an unset
 737    precision shows up as (unsigned int)-1, i.e. UINT_MAX.  */
 738 static int
 739 cmp_modes (const void *a, const void *b)
 740 {
 741   const struct mode_data *const m = *(const struct mode_data *const*)a;
 742   const struct mode_data *const n = *(const struct mode_data *const*)b;
 743
 744   if (m->bytesize > n->bytesize)
 745     return 1;
 746   else if (m->bytesize < n->bytesize)
 747     return -1;
 748
 749   if (m->precision > n->precision)
 750     return 1;
 751   else if (m->precision < n->precision)
 752     return -1;
 753
 754   if (!m->component && !n->component)
 755     {
 756       if (m->counter < n->counter)
 757         return -1;
 758       else
 759         return 1;
 760     }
 761
 762   if (m->component->bytesize > n->component->bytesize)
 763     return 1;
 764   else if (m->component->bytesize < n->component->bytesize)
 765     return -1;
 766
 767   if (m->component->precision > n->component->precision)
 768     return 1;
 769   else if (m->component->precision < n->component->precision)
 770     return -1;
 771
 772   if (m->counter < n->counter)
 773     return -1;
 774   else
 775     return 1;
 776 }
 777
 778 static void
 779 calc_wider_mode (void)
 780 {
 781   int c;
 782   struct mode_data *m;
 783   struct mode_data **sortbuf;
 784   unsigned int max_n_modes = 0;
 785   unsigned int i, j;
 786
 787   for (c = 0; c < MAX_MODE_CLASS; c++)
 788     max_n_modes = MAX (max_n_modes, n_modes[c]);
 789
 790   /* Allocate max_n_modes + 1 entries to leave room for the extra null
 791      pointer assigned after the qsort call below.  */
 792   sortbuf = XALLOCAVEC (struct mode_data *, max_n_modes + 1);
 793
 794   for (c = 0; c < MAX_MODE_CLASS; c++)
 795     {
 796       /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
 797          However, we want these in textual order, and we have
 798          precisely the reverse.  */
 799       if (c == MODE_RANDOM || c == MODE_CC)
 800         {
 801           struct mode_data *prev, *next;
 802
 803           for (prev = 0, m = modes[c]; m; m = next)
 804             {
 805               m->wider = void_mode;
 806
 807               /* this is nreverse */
 808               next = m->next;
 809               m->next = prev;
 810               prev = m;
 811             }
 812           modes[c] = prev;
 813         }
 814       else
 815         {
 816           if (!modes[c])
 817             continue;
 818
 819           for (i = 0, m = modes[c]; m; i++, m = m->next)
 820             sortbuf[i] = m;
 821
 822           qsort (sortbuf, i, sizeof (struct mode_data *), cmp_modes);
 823
 824           sortbuf[i] = 0;
 825           for (j = 0; j < i; j++)
 826             sortbuf[j]->next = sortbuf[j]->wider = sortbuf[j + 1];
 827
 828           modes[c] = sortbuf[0];
 829         }
 830     }
 831 }
 832
 833 /* Output routines.  */
 834
 835 #define tagged_printf(FMT, ARG, TAG) do {               \
 836   int count_ = printf ("  " FMT ",", ARG);              \
 837   printf ("%*s/* %s */\n", 27 - count_, "", TAG);       \
 838 } while (0)
 839
 840 #define print_decl(TYPE, NAME, ASIZE) \
 841   puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
 842
 843 #define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY)     \
 844   printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n",             \
 845           adj_##CATEGORY ? "" : "const ")
 846
 847 #define print_closer() puts ("};")
 848
 849 static void
 850 emit_insn_modes_h (void)
 851 {
 852   int c;
 853   struct mode_data *m, *first, *last;
 854
 855   printf ("/* Generated automatically from machmode.def%s%s\n",
 856            HAVE_EXTRA_MODES ? " and " : "",
 857            EXTRA_MODES_FILE);
 858
 859   puts ("\
 860    by genmodes.  */\n\
 861 \n\
 862 #ifndef GCC_INSN_MODES_H\n\
 863 #define GCC_INSN_MODES_H\n\
 864 \n\
 865 enum machine_mode\n{");
 866
 867   for (c = 0; c < MAX_MODE_CLASS; c++)
 868     for (m = modes[c]; m; m = m->next)
 869       {
 870         int count_ = printf ("  %smode,", m->name);
 871         printf ("%*s/* %s:%d */\n", 27 - count_, "",
 872                  trim_filename (m->file), m->line);
 873       }
 874
 875   puts ("  MAX_MACHINE_MODE,\n");
 876
 877   for (c = 0; c < MAX_MODE_CLASS; c++)
 878     {
 879       first = modes[c];
 880       last = 0;
 881       for (m = first; m; last = m, m = m->next)
 882         ;
 883
 884       /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
 885          end will try to use it for bitfields in structures and the
 886          like, which we do not want.  Only the target md file should
 887          generate BImode widgets.  */
 888       if (first && first->precision == 1)
 889         first = first->next;
 890
 891       if (first && last)
 892         printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
 893                  mode_class_names[c], first->name,
 894                  mode_class_names[c], last->name);
 895       else
 896         printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
 897                  mode_class_names[c], void_mode->name,
 898                  mode_class_names[c], void_mode->name);
 899     }
 900
 901   puts ("\
 902   NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
 903 };\n");
 904
 905   /* I can't think of a better idea, can you?  */
 906   printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize ? "" : " const");
 907   printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment ? "" : " const");
 908 #if 0 /* disabled for backward compatibility, temporary */
 909   printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format ? "" :" const");
 910 #endif
 911   printf ("#define CONST_MODE_IBIT%s\n", adj_ibit ? "" : " const");
 912   printf ("#define CONST_MODE_FBIT%s\n", adj_fbit ? "" : " const");
 913   puts ("\
 914 \n\
 915 #endif /* insn-modes.h */");
 916 }
 917
 918 static void
 919 emit_insn_modes_c_header (void)
 920 {
 921   printf ("/* Generated automatically from machmode.def%s%s\n",
 922            HAVE_EXTRA_MODES ? " and " : "",
 923            EXTRA_MODES_FILE);
 924
 925   puts ("\
 926    by genmodes.  */\n\
 927 \n\
 928 #include \"config.h\"\n\
 929 #include \"system.h\"\n\
 930 #include \"coretypes.h\"\n\
 931 #include \"tm.h\"\n\
 932 #include \"machmode.h\"\n\
 933 #include \"real.h\"");
 934 }
 935
 936 static void
 937 emit_min_insn_modes_c_header (void)
 938 {
 939   printf ("/* Generated automatically from machmode.def%s%s\n",
 940            HAVE_EXTRA_MODES ? " and " : "",
 941            EXTRA_MODES_FILE);
 942
 943   puts ("\
 944    by genmodes.  */\n\
 945 \n\
 946 #include \"bconfig.h\"\n\
 947 #include \"system.h\"\n\
 948 #include \"machmode.h\"");
 949 }
 950
 951 static void
 952 emit_mode_name (void)
 953 {
 954   int c;
 955   struct mode_data *m;
 956
 957   print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
 958
 959   for_all_modes (c, m)
 960     printf ("  \"%s\",\n", m->name);
 961
 962   print_closer ();
 963 }
 964
 965 static void
 966 emit_mode_class (void)
 967 {
 968   int c;
 969   struct mode_data *m;
 970
 971   print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
 972
 973   for_all_modes (c, m)
 974     tagged_printf ("%s", mode_class_names[m->cl], m->name);
 975
 976   print_closer ();
 977 }
 978
 979 static void
 980 emit_mode_precision (void)
 981 {
 982   int c;
 983   struct mode_data *m;
 984
 985   print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
 986
 987   for_all_modes (c, m)
 988     if (m->precision != (unsigned int)-1)
 989       tagged_printf ("%u", m->precision, m->name);
 990     else
 991       tagged_printf ("%u*BITS_PER_UNIT", m->bytesize, m->name);
 992
 993   print_closer ();
 994 }
 995
 996 static void
 997 emit_mode_size (void)
 998 {
 999   int c;
1000   struct mode_data *m;
1001
1002   print_maybe_const_decl ("%sunsigned char", "mode_size",
1003                           "NUM_MACHINE_MODES", bytesize);
1004
1005   for_all_modes (c, m)
1006     tagged_printf ("%u", m->bytesize, m->name);
1007
1008   print_closer ();
1009 }
1010
1011 static void
1012 emit_mode_nunits (void)
1013 {
1014   int c;
1015   struct mode_data *m;
1016
1017   print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1018
1019   for_all_modes (c, m)
1020     tagged_printf ("%u", m->ncomponents, m->name);
1021
1022   print_closer ();
1023 }
1024
1025 static void
1026 emit_mode_wider (void)
1027 {
1028   int c;
1029   struct mode_data *m;
1030
1031   print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1032
1033   for_all_modes (c, m)
1034     tagged_printf ("%smode",
1035                    m->wider ? m->wider->name : void_mode->name,
1036                    m->name);
1037
1038   print_closer ();
1039   print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1040
1041   for_all_modes (c, m)
1042     {
1043       struct mode_data * m2;
1044
1045       for (m2 = m;
1046            m2 && m2 != void_mode;
1047            m2 = m2->wider)
1048         {
1049           if (m2->bytesize < 2 * m->bytesize)
1050             continue;
1051           if (m->precision != (unsigned int) -1)
1052             {
1053               if (m2->precision != 2 * m->precision)
1054                 continue;
1055             }
1056           else
1057             {
1058               if (m2->precision != (unsigned int) -1)
1059                 continue;
1060             }
1061
1062           /* For vectors we want twice the number of components,
1063              with the same element type.  */
1064           if (m->cl == MODE_VECTOR_INT
1065               || m->cl == MODE_VECTOR_FLOAT
1066               || m->cl == MODE_VECTOR_FRACT
1067               || m->cl == MODE_VECTOR_UFRACT
1068               || m->cl == MODE_VECTOR_ACCUM
1069               || m->cl == MODE_VECTOR_UACCUM)
1070             {
1071               if (m2->ncomponents != 2 * m->ncomponents)
1072                 continue;
1073               if (m->component != m2->component)
1074                 continue;
1075             }
1076
1077           break;
1078         }
1079       if (m2 == void_mode)
1080         m2 = 0;
1081       tagged_printf ("%smode",
1082                      m2 ? m2->name : void_mode->name,
1083                      m->name);
1084     }
1085
1086   print_closer ();
1087 }
1088
1089 static void
1090 emit_mode_mask (void)
1091 {
1092   int c;
1093   struct mode_data *m;
1094
1095   print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1096               "NUM_MACHINE_MODES");
1097   puts ("\
1098 #define MODE_MASK(m)                          \\\n\
1099   ((m) >= HOST_BITS_PER_WIDE_INT)             \\\n\
1100    ? ~(unsigned HOST_WIDE_INT) 0              \\\n\
1101    : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
1102
1103   for_all_modes (c, m)
1104     if (m->precision != (unsigned int)-1)
1105       tagged_printf ("MODE_MASK (%u)", m->precision, m->name);
1106     else
1107       tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m->bytesize, m->name);
1108
1109   puts ("#undef MODE_MASK");
1110   print_closer ();
1111 }
1112
1113 static void
1114 emit_mode_inner (void)
1115 {
1116   int c;
1117   struct mode_data *m;
1118
1119   print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1120
1121   for_all_modes (c, m)
1122     tagged_printf ("%smode",
1123                    m->component ? m->component->name : void_mode->name,
1124                    m->name);
1125
1126   print_closer ();
1127 }
1128
1129 static void
1130 emit_mode_base_align (void)
1131 {
1132   int c;
1133   struct mode_data *m;
1134
1135   print_maybe_const_decl ("%sunsigned char",
1136                           "mode_base_align", "NUM_MACHINE_MODES",
1137                           alignment);
1138
1139   for_all_modes (c, m)
1140     tagged_printf ("%u", m->alignment, m->name);
1141
1142   print_closer ();
1143 }
1144
1145 static void
1146 emit_class_narrowest_mode (void)
1147 {
1148   int c;
1149
1150   print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1151
1152   for (c = 0; c < MAX_MODE_CLASS; c++)
1153     /* Bleah, all this to get the comment right for MIN_MODE_INT.  */
1154     tagged_printf ("MIN_%s", mode_class_names[c],
1155                    modes[c]
1156                    ? (modes[c]->precision != 1
1157                       ? modes[c]->name
1158                       : (modes[c]->next
1159                          ? modes[c]->next->name
1160                          : void_mode->name))
1161                    : void_mode->name);
1162
1163   print_closer ();
1164 }
1165
1166 static void
1167 emit_real_format_for_mode (void)
1168 {
1169   struct mode_data *m;
1170
1171   /* The entities pointed to by this table are constant, whether
1172      or not the table itself is constant.
1173
1174      For backward compatibility this table is always writable
1175      (several targets modify it in TARGET_OPTION_OVERRIDE).   FIXME:
1176      convert all said targets to use ADJUST_FORMAT instead.  */
1177 #if 0
1178   print_maybe_const_decl ("const struct real_format *%s",
1179                           "real_format_for_mode",
1180                           "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1181                           format);
1182 #else
1183   print_decl ("struct real_format *\n", "real_format_for_mode",
1184               "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1185               "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1186 #endif
1187
1188   /* The beginning of the table is entries for float modes.  */
1189   for (m = modes[MODE_FLOAT]; m; m = m->next)
1190     if (!strcmp (m->format, "0"))
1191       tagged_printf ("%s", m->format, m->name);
1192     else
1193       tagged_printf ("&%s", m->format, m->name);
1194
1195   /* The end of the table is entries for decimal float modes.  */
1196   for (m = modes[MODE_DECIMAL_FLOAT]; m; m = m->next)
1197     if (!strcmp (m->format, "0"))
1198       tagged_printf ("%s", m->format, m->name);
1199     else
1200       tagged_printf ("&%s", m->format, m->name);
1201
1202   print_closer ();
1203 }
1204
1205 static void
1206 emit_mode_adjustments (void)
1207 {
1208   struct mode_adjust *a;
1209   struct mode_data *m;
1210
1211   puts ("\
1212 \nvoid\
1213 \ninit_adjust_machine_modes (void)\
1214 \n{\
1215 \n  size_t s ATTRIBUTE_UNUSED;");
1216
1217   /* Size adjustments must be propagated to all containing modes.
1218      A size adjustment forces us to recalculate the alignment too.  */
1219   for (a = adj_bytesize; a; a = a->next)
1220     {
1221       printf ("\n  /* %s:%d */\n  s = %s;\n",
1222               a->file, a->line, a->adjustment);
1223       printf ("  mode_size[%smode] = s;\n", a->mode->name);
1224       printf ("  mode_base_align[%smode] = s & (~s + 1);\n",
1225               a->mode->name);
1226
1227       for (m = a->mode->contained; m; m = m->next_cont)
1228         {
1229           switch (m->cl)
1230             {
1231             case MODE_COMPLEX_INT:
1232             case MODE_COMPLEX_FLOAT:
1233               printf ("  mode_size[%smode] = 2*s;\n", m->name);
1234               printf ("  mode_base_align[%smode] = s & (~s + 1);\n",
1235                       m->name);
1236               break;
1237
1238             case MODE_VECTOR_INT:
1239             case MODE_VECTOR_FLOAT:
1240             case MODE_VECTOR_FRACT:
1241             case MODE_VECTOR_UFRACT:
1242             case MODE_VECTOR_ACCUM:
1243             case MODE_VECTOR_UACCUM:
1244               printf ("  mode_size[%smode] = %d*s;\n",
1245                       m->name, m->ncomponents);
1246               printf ("  mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1247                       m->name, m->ncomponents, m->ncomponents);
1248               break;
1249
1250             default:
1251               internal_error (
1252               "mode %s is neither vector nor complex but contains %s",
1253               m->name, a->mode->name);
1254               /* NOTREACHED */
1255             }
1256         }
1257     }
1258
1259   /* Alignment adjustments propagate too.
1260      ??? This may not be the right thing for vector modes.  */
1261   for (a = adj_alignment; a; a = a->next)
1262     {
1263       printf ("\n  /* %s:%d */\n  s = %s;\n",
1264               a->file, a->line, a->adjustment);
1265       printf ("  mode_base_align[%smode] = s;\n", a->mode->name);
1266
1267       for (m = a->mode->contained; m; m = m->next_cont)
1268         {
1269           switch (m->cl)
1270             {
1271             case MODE_COMPLEX_INT:
1272             case MODE_COMPLEX_FLOAT:
1273               printf ("  mode_base_align[%smode] = s;\n", m->name);
1274               break;
1275
1276             case MODE_VECTOR_INT:
1277             case MODE_VECTOR_FLOAT:
1278             case MODE_VECTOR_FRACT:
1279             case MODE_VECTOR_UFRACT:
1280             case MODE_VECTOR_ACCUM:
1281             case MODE_VECTOR_UACCUM:
1282               printf ("  mode_base_align[%smode] = %d*s;\n",
1283                       m->name, m->ncomponents);
1284               break;
1285
1286             default:
1287               internal_error (
1288               "mode %s is neither vector nor complex but contains %s",
1289               m->name, a->mode->name);
1290               /* NOTREACHED */
1291             }
1292         }
1293     }
1294
1295   /* Ibit adjustments don't have to propagate.  */
1296   for (a = adj_ibit; a; a = a->next)
1297     {
1298       printf ("\n  /* %s:%d */\n  s = %s;\n",
1299               a->file, a->line, a->adjustment);
1300       printf ("  mode_ibit[%smode] = s;\n", a->mode->name);
1301     }
1302
1303   /* Fbit adjustments don't have to propagate.  */
1304   for (a = adj_fbit; a; a = a->next)
1305     {
1306       printf ("\n  /* %s:%d */\n  s = %s;\n",
1307               a->file, a->line, a->adjustment);
1308       printf ("  mode_fbit[%smode] = s;\n", a->mode->name);
1309     }
1310
1311   /* Real mode formats don't have to propagate anywhere.  */
1312   for (a = adj_format; a; a = a->next)
1313     printf ("\n  /* %s:%d */\n  REAL_MODE_FORMAT (%smode) = %s;\n",
1314             a->file, a->line, a->mode->name, a->adjustment);
1315
1316   puts ("}");
1317 }
1318
1319 /* Emit ibit for all modes.  */
1320
1321 static void
1322 emit_mode_ibit (void)
1323 {
1324   int c;
1325   struct mode_data *m;
1326
1327   print_maybe_const_decl ("%sunsigned char",
1328                           "mode_ibit", "NUM_MACHINE_MODES",
1329                           ibit);
1330
1331   for_all_modes (c, m)
1332     tagged_printf ("%u", m->ibit, m->name);
1333
1334   print_closer ();
1335 }
1336
1337 /* Emit fbit for all modes.  */
1338
1339 static void
1340 emit_mode_fbit (void)
1341 {
1342   int c;
1343   struct mode_data *m;
1344
1345   print_maybe_const_decl ("%sunsigned char",
1346                           "mode_fbit", "NUM_MACHINE_MODES",
1347                           fbit);
1348
1349   for_all_modes (c, m)
1350     tagged_printf ("%u", m->fbit, m->name);
1351
1352   print_closer ();
1353 }
1354
1355
1356 static void
1357 emit_insn_modes_c (void)
1358 {
1359   emit_insn_modes_c_header ();
1360   emit_mode_name ();
1361   emit_mode_class ();
1362   emit_mode_precision ();
1363   emit_mode_size ();
1364   emit_mode_nunits ();
1365   emit_mode_wider ();
1366   emit_mode_mask ();
1367   emit_mode_inner ();
1368   emit_mode_base_align ();
1369   emit_class_narrowest_mode ();
1370   emit_real_format_for_mode ();
1371   emit_mode_adjustments ();
1372   emit_mode_ibit ();
1373   emit_mode_fbit ();
1374 }
1375
1376 static void
1377 emit_min_insn_modes_c (void)
1378 {
1379   emit_min_insn_modes_c_header ();
1380   emit_mode_name ();
1381   emit_mode_class ();
1382   emit_mode_wider ();
1383   emit_class_narrowest_mode ();
1384 }
1385
1386 /* Master control.  */
1387 int
1388 main (int argc, char **argv)
1389 {
1390   bool gen_header = false, gen_min = false;
1391   progname = argv[0];
1392
1393   if (argc == 1)
1394     ;
1395   else if (argc == 2 && !strcmp (argv[1], "-h"))
1396     gen_header = true;
1397   else if (argc == 2 && !strcmp (argv[1], "-m"))
1398     gen_min = true;
1399   else
1400     {
1401       error ("usage: %s [-h|-m] > file", progname);
1402       return FATAL_EXIT_CODE;
1403     }
1404
1405   modes_by_name = htab_create_alloc (64, hash_mode, eq_mode, 0, xcalloc, free);
1406
1407   create_modes ();
1408   complete_all_modes ();
1409
1410   if (have_error)
1411     return FATAL_EXIT_CODE;
1412
1413   calc_wider_mode ();
1414
1415   if (gen_header)
1416     emit_insn_modes_h ();
1417   else if (gen_min)
1418     emit_min_insn_modes_c ();
1419   else
1420     emit_insn_modes_c ();
1421
1422   if (fflush (stdout) || fclose (stdout))
1423     return FATAL_EXIT_CODE;
1424   return SUCCESS_EXIT_CODE;
1425 }