gcc/genmodes.c

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