gcc/genmodes.c

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