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) make_special_mode(MODE_##C, #N, __FILE__, __LINE__)
 526 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
 527 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
 528
 529 static void
 530 make_special_mode (enum mode_class cl, const char *name,
 531                    const char *file, unsigned int line)
 532 {
 533   new_mode (cl, name, file, line);
 534 }
 535
 536 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
 537 #define FRACTIONAL_INT_MODE(N, B, Y) \
 538   make_int_mode (#N, B, Y, __FILE__, __LINE__)
 539
 540 static void
 541 make_int_mode (const char *name,
 542                unsigned int precision, unsigned int bytesize,
 543                const char *file, unsigned int line)
 544 {
 545   struct mode_data *m = new_mode (MODE_INT, name, file, line);
 546   m->bytesize = bytesize;
 547   m->precision = precision;
 548 }
 549
 550 #define FRACT_MODE(N, Y, F) \
 551         make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
 552
 553 #define UFRACT_MODE(N, Y, F) \
 554         make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
 555
 556 #define ACCUM_MODE(N, Y, I, F) \
 557         make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
 558
 559 #define UACCUM_MODE(N, Y, I, F) \
 560         make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
 561
 562 /* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
 563    FILE, and LINE.  */
 564
 565 static void
 566 make_fixed_point_mode (enum mode_class cl,
 567                        const char *name,
 568                        unsigned int bytesize,
 569                        unsigned int ibit,
 570                        unsigned int fbit,
 571                        const char *file, unsigned int line)
 572 {
 573   struct mode_data *m = new_mode (cl, name, file, line);
 574   m->bytesize = bytesize;
 575   m->ibit = ibit;
 576   m->fbit = fbit;
 577 }
 578
 579 #define FLOAT_MODE(N, Y, F)             FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
 580 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
 581   make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
 582
 583 static void
 584 make_float_mode (const char *name,
 585                  unsigned int precision, unsigned int bytesize,
 586                  const char *format,
 587                  const char *file, unsigned int line)
 588 {
 589   struct mode_data *m = new_mode (MODE_FLOAT, name, file, line);
 590   m->bytesize = bytesize;
 591   m->precision = precision;
 592   m->format = format;
 593 }
 594
 595 #define DECIMAL_FLOAT_MODE(N, Y, F)     \
 596         FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
 597 #define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F)       \
 598   make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
 599
 600 static void
 601 make_decimal_float_mode (const char *name,
 602                          unsigned int precision, unsigned int bytesize,
 603                          const char *format,
 604                          const char *file, unsigned int line)
 605 {
 606   struct mode_data *m = new_mode (MODE_DECIMAL_FLOAT, name, file, line);
 607   m->bytesize = bytesize;
 608   m->precision = precision;
 609   m->format = format;
 610 }
 611
 612 #define RESET_FLOAT_FORMAT(N, F) \
 613   reset_float_format (#N, #F, __FILE__, __LINE__)
 614 static void ATTRIBUTE_UNUSED
 615 reset_float_format (const char *name, const char *format,
 616                     const char *file, unsigned int line)
 617 {
 618   struct mode_data *m = find_mode (name);
 619   if (!m)
 620     {
 621       error ("%s:%d: no mode \"%s\"", file, line, name);
 622       return;
 623     }
 624   if (m->cl != MODE_FLOAT && m->cl != MODE_DECIMAL_FLOAT)
 625     {
 626       error ("%s:%d: mode \"%s\" is not a FLOAT class", file, line, name);
 627       return;
 628     }
 629   m->format = format;
 630 }
 631
 632 /* Partial integer modes are specified by relation to a full integer mode.
 633    For now, we do not attempt to narrow down their bit sizes.  */
 634 #define PARTIAL_INT_MODE(M) \
 635   make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__)
 636 static void ATTRIBUTE_UNUSED
 637 make_partial_integer_mode (const char *base, const char *name,
 638                            unsigned int precision,
 639                            const char *file, unsigned int line)
 640 {
 641   struct mode_data *m;
 642   struct mode_data *component = find_mode (base);
 643   if (!component)
 644     {
 645       error ("%s:%d: no mode \"%s\"", file, line, name);
 646       return;
 647     }
 648   if (component->cl != MODE_INT)
 649     {
 650       error ("%s:%d: mode \"%s\" is not class INT", file, line, name);
 651       return;
 652     }
 653
 654   m = new_mode (MODE_PARTIAL_INT, name, file, line);
 655   m->precision = precision;
 656   m->component = component;
 657 }
 658
 659 /* A single vector mode can be specified by naming its component
 660    mode and the number of components.  */
 661 #define VECTOR_MODE(C, M, N) \
 662   make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
 663 static void ATTRIBUTE_UNUSED
 664 make_vector_mode (enum mode_class bclass,
 665                   const char *base,
 666                   unsigned int ncomponents,
 667                   const char *file, unsigned int line)
 668 {
 669   struct mode_data *v;
 670   enum mode_class vclass = vector_class (bclass);
 671   struct mode_data *component = find_mode (base);
 672   char namebuf[8];
 673
 674   if (vclass == MODE_RANDOM)
 675     return;
 676   if (component == 0)
 677     {
 678       error ("%s:%d: no mode \"%s\"", file, line, base);
 679       return;
 680     }
 681   if (component->cl != bclass
 682       && (component->cl != MODE_PARTIAL_INT
 683           || bclass != MODE_INT))
 684     {
 685       error ("%s:%d: mode \"%s\" is not class %s",
 686              file, line, base, mode_class_names[bclass] + 5);
 687       return;
 688     }
 689
 690   if ((size_t)snprintf (namebuf, sizeof namebuf, "V%u%s",
 691                         ncomponents, base) >= sizeof namebuf)
 692     {
 693       error ("%s:%d: mode name \"%s\" is too long",
 694              file, line, base);
 695       return;
 696     }
 697
 698   v = new_mode (vclass, xstrdup (namebuf), file, line);
 699   v->ncomponents = ncomponents;
 700   v->component = component;
 701 }
 702
 703 /* Adjustability.  */
 704 #define _ADD_ADJUST(A, M, X, C1, C2) \
 705   new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
 706
 707 #define ADJUST_BYTESIZE(M, X)  _ADD_ADJUST(bytesize, M, X, RANDOM, RANDOM)
 708 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST(alignment, M, X, RANDOM, RANDOM)
 709 #define ADJUST_FLOAT_FORMAT(M, X)    _ADD_ADJUST(format, M, X, FLOAT, FLOAT)
 710 #define ADJUST_IBIT(M, X)  _ADD_ADJUST(ibit, M, X, ACCUM, UACCUM)
 711 #define ADJUST_FBIT(M, X)  _ADD_ADJUST(fbit, M, X, FRACT, UACCUM)
 712
 713 static void
 714 create_modes (void)
 715 {
 716 #include "machmode.def"
 717 }
 718
 719 /* Processing.  */
 720
 721 /* Sort a list of modes into the order needed for the WIDER field:
 722    major sort by precision, minor sort by component precision.
 723
 724    For instance:
 725      QI < HI < SI < DI < TI
 726      V4QI < V2HI < V8QI < V4HI < V2SI.
 727
 728    If the precision is not set, sort by the bytesize.  A mode with
 729    precision set gets sorted before a mode without precision set, if
 730    they have the same bytesize; this is the right thing because
 731    the precision must always be smaller than the bytesize * BITS_PER_UNIT.
 732    We don't have to do anything special to get this done -- an unset
 733    precision shows up as (unsigned int)-1, i.e. UINT_MAX.  */
 734 static int
 735 cmp_modes (const void *a, const void *b)
 736 {
 737   const struct mode_data *const m = *(const struct mode_data *const*)a;
 738   const struct mode_data *const n = *(const struct mode_data *const*)b;
 739
 740   if (m->bytesize > n->bytesize)
 741     return 1;
 742   else if (m->bytesize < n->bytesize)
 743     return -1;
 744
 745   if (m->precision > n->precision)
 746     return 1;
 747   else if (m->precision < n->precision)
 748     return -1;
 749
 750   if (!m->component && !n->component)
 751     {
 752       if (m->counter < n->counter)
 753         return -1;
 754       else
 755         return 1;
 756     }
 757
 758   if (m->component->bytesize > n->component->bytesize)
 759     return 1;
 760   else if (m->component->bytesize < n->component->bytesize)
 761     return -1;
 762
 763   if (m->component->precision > n->component->precision)
 764     return 1;
 765   else if (m->component->precision < n->component->precision)
 766     return -1;
 767
 768   if (m->counter < n->counter)
 769     return -1;
 770   else
 771     return 1;
 772 }
 773
 774 static void
 775 calc_wider_mode (void)
 776 {
 777   int c;
 778   struct mode_data *m;
 779   struct mode_data **sortbuf;
 780   unsigned int max_n_modes = 0;
 781   unsigned int i, j;
 782
 783   for (c = 0; c < MAX_MODE_CLASS; c++)
 784     max_n_modes = MAX (max_n_modes, n_modes[c]);
 785
 786   /* Allocate max_n_modes + 1 entries to leave room for the extra null
 787      pointer assigned after the qsort call below.  */
 788   sortbuf = XALLOCAVEC (struct mode_data *, max_n_modes + 1);
 789
 790   for (c = 0; c < MAX_MODE_CLASS; c++)
 791     {
 792       /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
 793          However, we want these in textual order, and we have
 794          precisely the reverse.  */
 795       if (c == MODE_RANDOM || c == MODE_CC)
 796         {
 797           struct mode_data *prev, *next;
 798
 799           for (prev = 0, m = modes[c]; m; m = next)
 800             {
 801               m->wider = void_mode;
 802
 803               /* this is nreverse */
 804               next = m->next;
 805               m->next = prev;
 806               prev = m;
 807             }
 808           modes[c] = prev;
 809         }
 810       else
 811         {
 812           if (!modes[c])
 813             continue;
 814
 815           for (i = 0, m = modes[c]; m; i++, m = m->next)
 816             sortbuf[i] = m;
 817
 818           qsort (sortbuf, i, sizeof (struct mode_data *), cmp_modes);
 819
 820           sortbuf[i] = 0;
 821           for (j = 0; j < i; j++)
 822             {
 823               sortbuf[j]->next = sortbuf[j + 1];
 824               if (c == MODE_PARTIAL_INT)
 825                 sortbuf[j]->wider = sortbuf[j]->component;
 826               else
 827                 sortbuf[j]->wider = sortbuf[j]->next;
 828             }
 829
 830           modes[c] = sortbuf[0];
 831         }
 832     }
 833 }
 834
 835 /* Output routines.  */
 836
 837 #define tagged_printf(FMT, ARG, TAG) do {               \
 838   int count_ = printf ("  " FMT ",", ARG);              \
 839   printf ("%*s/* %s */\n", 27 - count_, "", TAG);       \
 840 } while (0)
 841
 842 #define print_decl(TYPE, NAME, ASIZE) \
 843   puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
 844
 845 #define print_maybe_const_decl(TYPE, NAME, ASIZE, CATEGORY)     \
 846   printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n",             \
 847           adj_##CATEGORY ? "" : "const ")
 848
 849 #define print_closer() puts ("};")
 850
 851 /* Compute the max bitsize of some of the classes of integers.  It may
 852    be that there are needs for the other integer classes, and this
 853    code is easy to extend.  */
 854 static void
 855 emit_max_int (void)
 856 {
 857   unsigned int max, mmax;
 858   struct mode_data *i;
 859   int j;
 860
 861   puts ("");
 862   for (max = 1, i = modes[MODE_INT]; i; i = i->next)
 863     if (max < i->bytesize)
 864         max = i->bytesize;
 865   mmax = max;
 866   for (max = 1, i = modes[MODE_PARTIAL_INT]; i; i = i->next)
 867     if (max < i->bytesize)
 868         max = i->bytesize;
 869   if (max > mmax)
 870     mmax = max;
 871   printf ("#define MAX_BITSIZE_MODE_ANY_INT %d*BITS_PER_UNIT\n", mmax);
 872
 873   mmax = 0;
 874   for (j = 0; j < MAX_MODE_CLASS; j++)
 875     for (i = modes[j]; i; i = i->next)
 876       if (mmax < i->bytesize)
 877         mmax = i->bytesize;
 878   printf ("#define MAX_BITSIZE_MODE_ANY_MODE %d*BITS_PER_UNIT\n", mmax);
 879 }
 880
 881 static void
 882 emit_insn_modes_h (void)
 883 {
 884   int c;
 885   struct mode_data *m, *first, *last;
 886
 887   printf ("/* Generated automatically from machmode.def%s%s\n",
 888            HAVE_EXTRA_MODES ? " and " : "",
 889            EXTRA_MODES_FILE);
 890
 891   puts ("\
 892    by genmodes.  */\n\
 893 \n\
 894 #ifndef GCC_INSN_MODES_H\n\
 895 #define GCC_INSN_MODES_H\n\
 896 \n\
 897 enum machine_mode\n{");
 898
 899   for (c = 0; c < MAX_MODE_CLASS; c++)
 900     for (m = modes[c]; m; m = m->next)
 901       {
 902         int count_ = printf ("  %smode,", m->name);
 903         printf ("%*s/* %s:%d */\n", 27 - count_, "",
 904                  trim_filename (m->file), m->line);
 905       }
 906
 907   puts ("  MAX_MACHINE_MODE,\n");
 908
 909   for (c = 0; c < MAX_MODE_CLASS; c++)
 910     {
 911       first = modes[c];
 912       last = 0;
 913       for (m = first; m; last = m, m = m->next)
 914         ;
 915
 916       /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
 917          end will try to use it for bitfields in structures and the
 918          like, which we do not want.  Only the target md file should
 919          generate BImode widgets.  */
 920       if (first && first->precision == 1)
 921         first = first->next;
 922
 923       if (first && last)
 924         printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
 925                  mode_class_names[c], first->name,
 926                  mode_class_names[c], last->name);
 927       else
 928         printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
 929                  mode_class_names[c], void_mode->name,
 930                  mode_class_names[c], void_mode->name);
 931     }
 932
 933   puts ("\
 934   NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
 935 };\n");
 936
 937   /* I can't think of a better idea, can you?  */
 938   printf ("#define CONST_MODE_SIZE%s\n", adj_bytesize ? "" : " const");
 939   printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment ? "" : " const");
 940 #if 0 /* disabled for backward compatibility, temporary */
 941   printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format ? "" :" const");
 942 #endif
 943   printf ("#define CONST_MODE_IBIT%s\n", adj_ibit ? "" : " const");
 944   printf ("#define CONST_MODE_FBIT%s\n", adj_fbit ? "" : " const");
 945   emit_max_int ();
 946   puts ("\
 947 \n\
 948 #endif /* insn-modes.h */");
 949 }
 950
 951 static void
 952 emit_insn_modes_c_header (void)
 953 {
 954   printf ("/* Generated automatically from machmode.def%s%s\n",
 955            HAVE_EXTRA_MODES ? " and " : "",
 956            EXTRA_MODES_FILE);
 957
 958   puts ("\
 959    by genmodes.  */\n\
 960 \n\
 961 #include \"config.h\"\n\
 962 #include \"system.h\"\n\
 963 #include \"coretypes.h\"\n\
 964 #include \"tm.h\"\n\
 965 #include \"machmode.h\"\n\
 966 #include \"real.h\"");
 967 }
 968
 969 static void
 970 emit_min_insn_modes_c_header (void)
 971 {
 972   printf ("/* Generated automatically from machmode.def%s%s\n",
 973            HAVE_EXTRA_MODES ? " and " : "",
 974            EXTRA_MODES_FILE);
 975
 976   puts ("\
 977    by genmodes.  */\n\
 978 \n\
 979 #include \"bconfig.h\"\n\
 980 #include \"system.h\"\n\
 981 #include \"machmode.h\"");
 982 }
 983
 984 static void
 985 emit_mode_name (void)
 986 {
 987   int c;
 988   struct mode_data *m;
 989
 990   print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
 991
 992   for_all_modes (c, m)
 993     printf ("  \"%s\",\n", m->name);
 994
 995   print_closer ();
 996 }
 997
 998 static void
 999 emit_mode_class (void)
1000 {
1001   int c;
1002   struct mode_data *m;
1003
1004   print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
1005
1006   for_all_modes (c, m)
1007     tagged_printf ("%s", mode_class_names[m->cl], m->name);
1008
1009   print_closer ();
1010 }
1011
1012 static void
1013 emit_mode_precision (void)
1014 {
1015   int c;
1016   struct mode_data *m;
1017
1018   print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
1019
1020   for_all_modes (c, m)
1021     if (m->precision != (unsigned int)-1)
1022       tagged_printf ("%u", m->precision, m->name);
1023     else
1024       tagged_printf ("%u*BITS_PER_UNIT", m->bytesize, m->name);
1025
1026   print_closer ();
1027 }
1028
1029 static void
1030 emit_mode_size (void)
1031 {
1032   int c;
1033   struct mode_data *m;
1034
1035   print_maybe_const_decl ("%sunsigned char", "mode_size",
1036                           "NUM_MACHINE_MODES", bytesize);
1037
1038   for_all_modes (c, m)
1039     tagged_printf ("%u", m->bytesize, m->name);
1040
1041   print_closer ();
1042 }
1043
1044 static void
1045 emit_mode_nunits (void)
1046 {
1047   int c;
1048   struct mode_data *m;
1049
1050   print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
1051
1052   for_all_modes (c, m)
1053     tagged_printf ("%u", m->ncomponents, m->name);
1054
1055   print_closer ();
1056 }
1057
1058 static void
1059 emit_mode_wider (void)
1060 {
1061   int c;
1062   struct mode_data *m;
1063
1064   print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1065
1066   for_all_modes (c, m)
1067     tagged_printf ("%smode",
1068                    m->wider ? m->wider->name : void_mode->name,
1069                    m->name);
1070
1071   print_closer ();
1072   print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1073
1074   for_all_modes (c, m)
1075     {
1076       struct mode_data * m2;
1077
1078       for (m2 = m;
1079            m2 && m2 != void_mode;
1080            m2 = m2->wider)
1081         {
1082           if (m2->bytesize < 2 * m->bytesize)
1083             continue;
1084           if (m->precision != (unsigned int) -1)
1085             {
1086               if (m2->precision != 2 * m->precision)
1087                 continue;
1088             }
1089           else
1090             {
1091               if (m2->precision != (unsigned int) -1)
1092                 continue;
1093             }
1094
1095           /* For vectors we want twice the number of components,
1096              with the same element type.  */
1097           if (m->cl == MODE_VECTOR_INT
1098               || m->cl == MODE_VECTOR_FLOAT
1099               || m->cl == MODE_VECTOR_FRACT
1100               || m->cl == MODE_VECTOR_UFRACT
1101               || m->cl == MODE_VECTOR_ACCUM
1102               || m->cl == MODE_VECTOR_UACCUM)
1103             {
1104               if (m2->ncomponents != 2 * m->ncomponents)
1105                 continue;
1106               if (m->component != m2->component)
1107                 continue;
1108             }
1109
1110           break;
1111         }
1112       if (m2 == void_mode)
1113         m2 = 0;
1114       tagged_printf ("%smode",
1115                      m2 ? m2->name : void_mode->name,
1116                      m->name);
1117     }
1118
1119   print_closer ();
1120 }
1121
1122 static void
1123 emit_mode_mask (void)
1124 {
1125   int c;
1126   struct mode_data *m;
1127
1128   print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1129               "NUM_MACHINE_MODES");
1130   puts ("\
1131 #define MODE_MASK(m)                          \\\n\
1132   ((m) >= HOST_BITS_PER_WIDE_INT)             \\\n\
1133    ? ~(unsigned HOST_WIDE_INT) 0              \\\n\
1134    : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
1135
1136   for_all_modes (c, m)
1137     if (m->precision != (unsigned int)-1)
1138       tagged_printf ("MODE_MASK (%u)", m->precision, m->name);
1139     else
1140       tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m->bytesize, m->name);
1141
1142   puts ("#undef MODE_MASK");
1143   print_closer ();
1144 }
1145
1146 static void
1147 emit_mode_inner (void)
1148 {
1149   int c;
1150   struct mode_data *m;
1151
1152   print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1153
1154   for_all_modes (c, m)
1155     tagged_printf ("%smode",
1156                    c != MODE_PARTIAL_INT && m->component
1157                    ? m->component->name : void_mode->name,
1158                    m->name);
1159
1160   print_closer ();
1161 }
1162
1163 static void
1164 emit_mode_base_align (void)
1165 {
1166   int c;
1167   struct mode_data *m;
1168
1169   print_maybe_const_decl ("%sunsigned char",
1170                           "mode_base_align", "NUM_MACHINE_MODES",
1171                           alignment);
1172
1173   for_all_modes (c, m)
1174     tagged_printf ("%u", m->alignment, m->name);
1175
1176   print_closer ();
1177 }
1178
1179 static void
1180 emit_class_narrowest_mode (void)
1181 {
1182   int c;
1183
1184   print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1185
1186   for (c = 0; c < MAX_MODE_CLASS; c++)
1187     /* Bleah, all this to get the comment right for MIN_MODE_INT.  */
1188     tagged_printf ("MIN_%s", mode_class_names[c],
1189                    modes[c]
1190                    ? (modes[c]->precision != 1
1191                       ? modes[c]->name
1192                       : (modes[c]->next
1193                          ? modes[c]->next->name
1194                          : void_mode->name))
1195                    : void_mode->name);
1196
1197   print_closer ();
1198 }
1199
1200 static void
1201 emit_real_format_for_mode (void)
1202 {
1203   struct mode_data *m;
1204
1205   /* The entities pointed to by this table are constant, whether
1206      or not the table itself is constant.
1207
1208      For backward compatibility this table is always writable
1209      (several targets modify it in TARGET_OPTION_OVERRIDE).   FIXME:
1210      convert all said targets to use ADJUST_FORMAT instead.  */
1211 #if 0
1212   print_maybe_const_decl ("const struct real_format *%s",
1213                           "real_format_for_mode",
1214                           "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1215                           format);
1216 #else
1217   print_decl ("struct real_format *\n", "real_format_for_mode",
1218               "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1219               "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1220 #endif
1221
1222   /* The beginning of the table is entries for float modes.  */
1223   for (m = modes[MODE_FLOAT]; m; m = m->next)
1224     if (!strcmp (m->format, "0"))
1225       tagged_printf ("%s", m->format, m->name);
1226     else
1227       tagged_printf ("&%s", m->format, m->name);
1228
1229   /* The end of the table is entries for decimal float modes.  */
1230   for (m = modes[MODE_DECIMAL_FLOAT]; m; m = m->next)
1231     if (!strcmp (m->format, "0"))
1232       tagged_printf ("%s", m->format, m->name);
1233     else
1234       tagged_printf ("&%s", m->format, m->name);
1235
1236   print_closer ();
1237 }
1238
1239 static void
1240 emit_mode_adjustments (void)
1241 {
1242   struct mode_adjust *a;
1243   struct mode_data *m;
1244
1245   puts ("\
1246 \nvoid\
1247 \ninit_adjust_machine_modes (void)\
1248 \n{\
1249 \n  size_t s ATTRIBUTE_UNUSED;");
1250
1251   /* Size adjustments must be propagated to all containing modes.
1252      A size adjustment forces us to recalculate the alignment too.  */
1253   for (a = adj_bytesize; a; a = a->next)
1254     {
1255       printf ("\n  /* %s:%d */\n  s = %s;\n",
1256               a->file, a->line, a->adjustment);
1257       printf ("  mode_size[%smode] = s;\n", a->mode->name);
1258       printf ("  mode_base_align[%smode] = s & (~s + 1);\n",
1259               a->mode->name);
1260
1261       for (m = a->mode->contained; m; m = m->next_cont)
1262         {
1263           switch (m->cl)
1264             {
1265             case MODE_COMPLEX_INT:
1266             case MODE_COMPLEX_FLOAT:
1267               printf ("  mode_size[%smode] = 2*s;\n", m->name);
1268               printf ("  mode_base_align[%smode] = s & (~s + 1);\n",
1269                       m->name);
1270               break;
1271
1272             case MODE_VECTOR_INT:
1273             case MODE_VECTOR_FLOAT:
1274             case MODE_VECTOR_FRACT:
1275             case MODE_VECTOR_UFRACT:
1276             case MODE_VECTOR_ACCUM:
1277             case MODE_VECTOR_UACCUM:
1278               printf ("  mode_size[%smode] = %d*s;\n",
1279                       m->name, m->ncomponents);
1280               printf ("  mode_base_align[%smode] = (%d*s) & (~(%d*s)+1);\n",
1281                       m->name, m->ncomponents, m->ncomponents);
1282               break;
1283
1284             default:
1285               internal_error (
1286               "mode %s is neither vector nor complex but contains %s",
1287               m->name, a->mode->name);
1288               /* NOTREACHED */
1289             }
1290         }
1291     }
1292
1293   /* Alignment adjustments propagate too.
1294      ??? This may not be the right thing for vector modes.  */
1295   for (a = adj_alignment; a; a = a->next)
1296     {
1297       printf ("\n  /* %s:%d */\n  s = %s;\n",
1298               a->file, a->line, a->adjustment);
1299       printf ("  mode_base_align[%smode] = s;\n", a->mode->name);
1300
1301       for (m = a->mode->contained; m; m = m->next_cont)
1302         {
1303           switch (m->cl)
1304             {
1305             case MODE_COMPLEX_INT:
1306             case MODE_COMPLEX_FLOAT:
1307               printf ("  mode_base_align[%smode] = s;\n", m->name);
1308               break;
1309
1310             case MODE_VECTOR_INT:
1311             case MODE_VECTOR_FLOAT:
1312             case MODE_VECTOR_FRACT:
1313             case MODE_VECTOR_UFRACT:
1314             case MODE_VECTOR_ACCUM:
1315             case MODE_VECTOR_UACCUM:
1316               printf ("  mode_base_align[%smode] = %d*s;\n",
1317                       m->name, m->ncomponents);
1318               break;
1319
1320             default:
1321               internal_error (
1322               "mode %s is neither vector nor complex but contains %s",
1323               m->name, a->mode->name);
1324               /* NOTREACHED */
1325             }
1326         }
1327     }
1328
1329   /* Ibit adjustments don't have to propagate.  */
1330   for (a = adj_ibit; a; a = a->next)
1331     {
1332       printf ("\n  /* %s:%d */\n  s = %s;\n",
1333               a->file, a->line, a->adjustment);
1334       printf ("  mode_ibit[%smode] = s;\n", a->mode->name);
1335     }
1336
1337   /* Fbit adjustments don't have to propagate.  */
1338   for (a = adj_fbit; a; a = a->next)
1339     {
1340       printf ("\n  /* %s:%d */\n  s = %s;\n",
1341               a->file, a->line, a->adjustment);
1342       printf ("  mode_fbit[%smode] = s;\n", a->mode->name);
1343     }
1344
1345   /* Real mode formats don't have to propagate anywhere.  */
1346   for (a = adj_format; a; a = a->next)
1347     printf ("\n  /* %s:%d */\n  REAL_MODE_FORMAT (%smode) = %s;\n",
1348             a->file, a->line, a->mode->name, a->adjustment);
1349
1350   puts ("}");
1351 }
1352
1353 /* Emit ibit for all modes.  */
1354
1355 static void
1356 emit_mode_ibit (void)
1357 {
1358   int c;
1359   struct mode_data *m;
1360
1361   print_maybe_const_decl ("%sunsigned char",
1362                           "mode_ibit", "NUM_MACHINE_MODES",
1363                           ibit);
1364
1365   for_all_modes (c, m)
1366     tagged_printf ("%u", m->ibit, m->name);
1367
1368   print_closer ();
1369 }
1370
1371 /* Emit fbit for all modes.  */
1372
1373 static void
1374 emit_mode_fbit (void)
1375 {
1376   int c;
1377   struct mode_data *m;
1378
1379   print_maybe_const_decl ("%sunsigned char",
1380                           "mode_fbit", "NUM_MACHINE_MODES",
1381                           fbit);
1382
1383   for_all_modes (c, m)
1384     tagged_printf ("%u", m->fbit, m->name);
1385
1386   print_closer ();
1387 }
1388
1389
1390 static void
1391 emit_insn_modes_c (void)
1392 {
1393   emit_insn_modes_c_header ();
1394   emit_mode_name ();
1395   emit_mode_class ();
1396   emit_mode_precision ();
1397   emit_mode_size ();
1398   emit_mode_nunits ();
1399   emit_mode_wider ();
1400   emit_mode_mask ();
1401   emit_mode_inner ();
1402   emit_mode_base_align ();
1403   emit_class_narrowest_mode ();
1404   emit_real_format_for_mode ();
1405   emit_mode_adjustments ();
1406   emit_mode_ibit ();
1407   emit_mode_fbit ();
1408 }
1409
1410 static void
1411 emit_min_insn_modes_c (void)
1412 {
1413   emit_min_insn_modes_c_header ();
1414   emit_mode_name ();
1415   emit_mode_class ();
1416   emit_mode_wider ();
1417   emit_class_narrowest_mode ();
1418 }
1419
1420 /* Master control.  */
1421 int
1422 main (int argc, char **argv)
1423 {
1424   bool gen_header = false, gen_min = false;
1425   progname = argv[0];
1426
1427   if (argc == 1)
1428     ;
1429   else if (argc == 2 && !strcmp (argv[1], "-h"))
1430     gen_header = true;
1431   else if (argc == 2 && !strcmp (argv[1], "-m"))
1432     gen_min = true;
1433   else
1434     {
1435       error ("usage: %s [-h|-m] > file", progname);
1436       return FATAL_EXIT_CODE;
1437     }
1438
1439   modes_by_name = htab_create_alloc (64, hash_mode, eq_mode, 0, xcalloc, free);
1440
1441   create_modes ();
1442   complete_all_modes ();
1443
1444   if (have_error)
1445     return FATAL_EXIT_CODE;
1446
1447   calc_wider_mode ();
1448
1449   if (gen_header)
1450     emit_insn_modes_h ();
1451   else if (gen_min)
1452     emit_min_insn_modes_c ();
1453   else
1454     emit_insn_modes_c ();
1455
1456   if (fflush (stdout) || fclose (stdout))
1457     return FATAL_EXIT_CODE;
1458   return SUCCESS_EXIT_CODE;
1459 }