gcc/genmodes.c

   1 /* Generate the machine mode enumeration and associated tables.
   2    Copyright (C) 2003
   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, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "bconfig.h"
  23 #include "system.h"
  24 #include "errors.h"
  25
  26 /* enum mode_class is normally defined by machmode.h but we can't
  27    include that header here.  */
  28 #include "mode-classes.def"
  29
  30 #define DEF_MODE_CLASS(M) M
  31 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
  32 #undef DEF_MODE_CLASS
  33
  34 /* Text names of mode classes, for output.  */
  35 #define DEF_MODE_CLASS(M) #M
  36 static const char *const mode_class_names[MAX_MODE_CLASS] =
  37 {
  38   MODE_CLASSES
  39 };
  40 #undef DEF_MODE_CLASS
  41 #undef MODE_CLASSES
  42
  43 #ifdef EXTRA_MODES_FILE
  44 # define HAVE_EXTRA_MODES 1
  45 #else
  46 # define HAVE_EXTRA_MODES 0
  47 # define EXTRA_MODES_FILE ""
  48 #endif
  49
  50 /* Data structure for building up what we know about a mode.
  51    They're clustered by mode class.  */
  52 struct mode_data
  53 {
  54   struct mode_data *next;       /* next this class - arbitrary order */
  55
  56   const char *name;             /* printable mode name -- SI, not SImode */
  57   enum mode_class class;        /* this mode class */
  58   unsigned int bitsize;         /* size in bits, equiv to TYPE_PRECISION */
  59   unsigned int bytesize;        /* storage size in addressable units */
  60   unsigned int ncomponents;     /* number of subunits */
  61   unsigned int alignment;       /* mode alignment */
  62   const char *format;           /* floating point format - MODE_FLOAT only */
  63
  64   struct mode_data *component;  /* mode of components */
  65   struct mode_data *wider;      /* next wider mode */
  66
  67   const char *file;             /* file and line of definition, */
  68   unsigned int line;            /* for error reporting */
  69 };
  70
  71 static struct mode_data *known_modes[MAX_MODE_CLASS];
  72 static unsigned int n_modes[MAX_MODE_CLASS];
  73 static struct mode_data *void_mode;
  74
  75 static const struct mode_data blank_mode = {
  76   0, "<unknown>", MAX_MODE_CLASS,
  77   -1, -1, -1, -1,
  78   0, 0, 0,
  79   "<unknown>", 0
  80 };
  81
  82 /* Mode class operations.  */
  83 static enum mode_class
  84 complex_class (enum mode_class class)
  85 {
  86   switch (class)
  87     {
  88     case MODE_INT: return MODE_COMPLEX_INT;
  89     case MODE_FLOAT: return MODE_COMPLEX_FLOAT;
  90     default:
  91       error ("no complex class for class %s", mode_class_names[class]);
  92       return MODE_RANDOM;
  93     }
  94 }
  95
  96 static enum mode_class
  97 vector_class (enum mode_class class)
  98 {
  99   switch (class)
 100     {
 101     case MODE_INT: return MODE_VECTOR_INT;
 102     case MODE_FLOAT: return MODE_VECTOR_FLOAT;
 103     default:
 104       error ("no vector class for class %s", mode_class_names[class]);
 105       return MODE_RANDOM;
 106     }
 107 }
 108
 109 static struct mode_data *
 110 find_mode (enum mode_class class, const char *name)
 111 {
 112   struct mode_data *m;
 113
 114   for (m = known_modes[class]; m; m = m->next)
 115     if (!strcmp (name, m->name))
 116       return m;
 117
 118   return 0;
 119 }
 120
 121 static struct mode_data *
 122 new_mode (enum mode_class class, const char *name,
 123           const char *file, unsigned int line)
 124 {
 125   struct mode_data *m;
 126
 127   m = find_mode (class, name);
 128   if (m)
 129     {
 130       error ("%s:%d: duplicate definition of mode \"%s\"",
 131              trim_filename (file), line, name);
 132       error ("%s:%d: previous definition here", m->file, m->line);
 133       return m;
 134     }
 135
 136   m = xmalloc (sizeof (struct mode_data));
 137   memcpy (m, &blank_mode, sizeof (struct mode_data));
 138   m->class = class;
 139   m->name = name;
 140   if (file)
 141     m->file = trim_filename (file);
 142   m->line = line;
 143
 144   m->next = known_modes[class];
 145   known_modes[class] = m;
 146   n_modes[class]++;
 147   return m;
 148 }
 149
 150 #define for_all_modes(C, M)                     \
 151   for (C = 0; C < MAX_MODE_CLASS; C++)          \
 152     for (M = known_modes[C]; M; M = M->next)
 153
 154
 155 /* Diagnose failure to meet expectations in a partially filled out
 156    mode structure.  */
 157 enum requirement { SET, UNSET, OPTIONAL };
 158
 159 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
 160   switch (req)                                                          \
 161     {                                                                   \
 162     case SET:                                                           \
 163       if (val == unset)                                                 \
 164         error ("%s:%d: (%s) field %s must be set",                      \
 165                file, line, mname, fname);                               \
 166       break;                                                            \
 167     case UNSET:                                                         \
 168       if (val != unset)                                                 \
 169         error ("%s:%d: (%s) field %s must not be set",                  \
 170                file, line, mname, fname);                               \
 171     case OPTIONAL:                                                      \
 172       break;                                                            \
 173     }                                                                   \
 174 } while (0)
 175
 176 #define validate_field(M, F) \
 177   validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
 178
 179 static void
 180 validate_mode (struct mode_data *m,
 181                enum requirement r_bitsize,
 182                enum requirement r_bytesize,
 183                enum requirement r_component,
 184                enum requirement r_ncomponents,
 185                enum requirement r_format)
 186 {
 187   validate_field (m, bitsize);
 188   validate_field (m, bytesize);
 189   validate_field (m, component);
 190   validate_field (m, ncomponents);
 191   validate_field (m, format);
 192 }
 193 #undef validate_field
 194 #undef validate_field_
 195
 196 /* Given a partially-filled-out mode structure, figure out what we can
 197    and fill the rest of it in; die if it isn't enough.  */
 198 static void
 199 complete_mode (struct mode_data *m)
 200 {
 201   unsigned int alignment;
 202
 203   if (!m->name)
 204     {
 205       error ("%s:%d: mode with no name", m->file, m->line);
 206       return;
 207     }
 208   if (m->class == MAX_MODE_CLASS)
 209     {
 210       error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
 211       return;
 212     }
 213
 214   switch (m->class)
 215     {
 216     case MODE_RANDOM:
 217       /* Nothing more need be said.  */
 218       if (!strcmp (m->name, "VOID"))
 219         void_mode = m;
 220
 221       validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
 222
 223       m->bitsize = 0;
 224       m->bytesize = 0;
 225       m->ncomponents = 0;
 226       m->component = 0;
 227       break;
 228
 229     case MODE_CC:
 230       /* Again, nothing more need be said.  For historical reasons,
 231          the size of a CC mode is four units.  */
 232       validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
 233
 234       m->bytesize = 4;
 235       m->ncomponents = 0;
 236       m->component = 0;
 237       break;
 238
 239     case MODE_INT:
 240     case MODE_FLOAT:
 241       /* A scalar mode must have a byte size, may have a bit size,
 242          and must not have components.   A float mode must have a
 243          format.  */
 244       validate_mode (m, OPTIONAL, SET, UNSET, UNSET,
 245                      m->class == MODE_FLOAT ? SET : UNSET);
 246
 247       m->ncomponents = 0;
 248       m->component = 0;
 249       break;
 250
 251     case MODE_PARTIAL_INT:
 252       /* A partial integer mode uses ->component to say what the
 253          corresponding full-size integer mode is, and may also
 254          specify a bit size.  */
 255       validate_mode (m, OPTIONAL, UNSET, SET, UNSET, UNSET);
 256
 257       m->bytesize = m->component->bytesize;
 258
 259       m->ncomponents = 0;
 260       m->component = 0;  /* ??? preserve this */
 261       break;
 262
 263     case MODE_COMPLEX_INT:
 264     case MODE_COMPLEX_FLOAT:
 265       /* Complex modes should have a component indicated, but no more.  */
 266       validate_mode (m, UNSET, UNSET, SET, UNSET, UNSET);
 267       m->ncomponents = 2;
 268       if (m->component->bitsize != (unsigned int)-1)
 269         m->bitsize = 2 * m->component->bitsize;
 270       m->bytesize = 2 * m->component->bytesize;
 271       break;
 272
 273     case MODE_VECTOR_INT:
 274     case MODE_VECTOR_FLOAT:
 275       /* Vector modes should have a component and a number of components.  */
 276       validate_mode (m, UNSET, UNSET, SET, SET, UNSET);
 277       if (m->component->bitsize != (unsigned int)-1)
 278         m->bitsize = m->ncomponents * m->component->bitsize;
 279       m->bytesize = m->ncomponents * m->component->bytesize;
 280       break;
 281
 282     default:
 283       abort ();
 284     }
 285
 286   /* If not already specified, the mode alignment defaults to the largest
 287      power of two that divides the size of the object.  Complex types are
 288      not more aligned than their contents.  */
 289   if (m->class == MODE_COMPLEX_INT || m->class == MODE_COMPLEX_FLOAT)
 290     alignment = m->component->bytesize;
 291   else
 292     alignment = m->bytesize;
 293
 294   m->alignment = alignment & (~alignment + 1);
 295 }
 296
 297 static void
 298 complete_all_modes (void)
 299 {
 300   struct mode_data *m;
 301   enum mode_class c;
 302
 303   for_all_modes (c, m)
 304     complete_mode (m);
 305 }
 306
 307 /* For each mode in class CLASS, construct a corresponding complex mode.  */
 308 #define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
 309 static void
 310 make_complex_modes (enum mode_class class,
 311                     const char *file, unsigned int line)
 312 {
 313   struct mode_data *m;
 314   struct mode_data *c;
 315   char buf[8];
 316   enum mode_class cclass = complex_class (class);
 317
 318   if (cclass == MODE_RANDOM)
 319     return;
 320
 321   for (m = known_modes[class]; m; m = m->next)
 322     {
 323       /* Skip BImode.  FIXME: BImode probably shouldn't be MODE_INT.  */
 324       if (m->bitsize == 1)
 325         continue;
 326
 327       if (strlen (m->name) >= sizeof buf)
 328         {
 329           error ("%s:%d:mode name \"%s\" is too long",
 330                  m->file, m->line, m->name);
 331           continue;
 332         }
 333
 334       /* Float complex modes are named SCmode, etc.
 335          Int complex modes are named CSImode, etc.
 336          This inconsistency should be eliminated.  */
 337       if (class == MODE_FLOAT)
 338         {
 339           char *p;
 340           strncpy (buf, m->name, sizeof buf);
 341           p = strchr (buf, 'F');
 342           if (p == 0)
 343             {
 344               error ("%s:%d: float mode \"%s\" has no 'F'",
 345                      m->file, m->line, m->name);
 346               continue;
 347             }
 348
 349           *p = 'C';
 350         }
 351       else
 352         snprintf (buf, sizeof buf, "C%s", m->name);
 353
 354       c = new_mode (cclass, xstrdup (buf), file, line);
 355       c->component = m;
 356     }
 357 }
 358
 359 /* For all modes in class CLASS, construct vector modes of width
 360    WIDTH, having as many components as necessary.  */
 361 #define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
 362 static void
 363 make_vector_modes (enum mode_class class, unsigned int width,
 364                    const char *file, unsigned int line)
 365 {
 366   struct mode_data *m;
 367   struct mode_data *v;
 368   char buf[8];
 369   unsigned int ncomponents;
 370   enum mode_class vclass = vector_class (class);
 371
 372   if (vclass == MODE_RANDOM)
 373     return;
 374
 375   for (m = known_modes[class]; m; m = m->next)
 376     {
 377       /* Do not construct vector modes with only one element, or
 378          vector modes where the element size doesn't divide the full
 379          size evenly.  */
 380       ncomponents = width / m->bytesize;
 381       if (ncomponents < 2)
 382         continue;
 383       if (width % m->bytesize)
 384         continue;
 385
 386       /* Skip QFmode and BImode.  FIXME: this special case should
 387          not be necessary.  */
 388       if (class == MODE_FLOAT && m->bytesize == 1)
 389         continue;
 390       if (class == MODE_INT && m->bitsize == 1)
 391         continue;
 392
 393       if ((size_t)snprintf (buf, sizeof buf, "V%u%s", ncomponents, m->name)
 394           >= sizeof buf)
 395         {
 396           error ("%s:%d: mode name \"%s\" is too long",
 397                  m->file, m->line, m->name);
 398           continue;
 399         }
 400
 401       v = new_mode (vclass, xstrdup (buf), file, line);
 402       v->component = m;
 403       v->ncomponents = ncomponents;
 404     }
 405 }
 406
 407 /* Input.  */
 408
 409 #define _SPECIAL_MODE(C, N) make_special_mode(MODE_##C, #N, __FILE__, __LINE__)
 410 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
 411 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
 412
 413 static void
 414 make_special_mode (enum mode_class class, const char *name,
 415                    const char *file, unsigned int line)
 416 {
 417   new_mode (class, name, file, line);
 418 }
 419
 420 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1, Y)
 421 #define FRACTIONAL_INT_MODE(N, B, Y) \
 422   make_int_mode (#N, B, Y, __FILE__, __LINE__)
 423
 424 static void
 425 make_int_mode (const char *name,
 426                unsigned int bitsize, unsigned int bytesize,
 427                const char *file, unsigned int line)
 428 {
 429   struct mode_data *m = new_mode (MODE_INT, name, file, line);
 430   m->bytesize = bytesize;
 431   m->bitsize = bitsize;
 432 }
 433
 434 #define FLOAT_MODE(N, Y, F)             FRACTIONAL_FLOAT_MODE (N, -1, Y, F)
 435 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
 436   make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
 437
 438 static void
 439 make_float_mode (const char *name,
 440                  unsigned int bitsize, unsigned int bytesize,
 441                  const char *format,
 442                  const char *file, unsigned int line)
 443 {
 444   struct mode_data *m = new_mode (MODE_FLOAT, name, file, line);
 445   m->bytesize = bytesize;
 446   m->bitsize = bitsize;
 447   m->format = format;
 448 }
 449
 450 #define RESET_FLOAT_FORMAT(N, F) \
 451   reset_float_format (#N, #F, __FILE__, __LINE__)
 452 static void ATTRIBUTE_UNUSED
 453 reset_float_format (const char *name, const char *format,
 454                     const char *file, const char *line)
 455 {
 456   struct mode_data *m = find_mode (MODE_FLOAT, name);
 457   if (!m)
 458     {
 459       error ("%s:%d: no mode \"%s\" in class FLOAT", file, line, name);
 460       return;
 461     }
 462   m->format = format;
 463 }
 464
 465 /* Partial integer modes are specified by relation to a full integer mode.
 466    For now, we do not attempt to narrow down their bit sizes.  */
 467 #define PARTIAL_INT_MODE(M) \
 468   make_partial_integer_mode (#M, "P" #M, -1, __FILE__, __LINE__)
 469 static void ATTRIBUTE_UNUSED
 470 make_partial_integer_mode (const char *base, const char *name,
 471                            unsigned int bitsize,
 472                            const char *file, unsigned int line)
 473 {
 474   struct mode_data *m;
 475   struct mode_data *component = find_mode (MODE_INT, base);
 476   if (!component)
 477     {
 478       error ("%s:%d: no mode \"%s\" in class INT", file, line, name);
 479       return;
 480     }
 481
 482   m = new_mode (MODE_PARTIAL_INT, name, file, line);
 483   m->bitsize = bitsize;
 484   m->component = component;
 485 }
 486
 487 /* A single vector mode can be specified by naming its component
 488    mode and the number of components.  */
 489 #define VECTOR_MODE(C, M, N) \
 490   make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
 491 static void ATTRIBUTE_UNUSED
 492 make_vector_mode (enum mode_class bclass,
 493                   const char *base,
 494                   unsigned int ncomponents,
 495                   const char *file, unsigned int line)
 496 {
 497   struct mode_data *v;
 498   enum mode_class vclass = vector_class (bclass);
 499   struct mode_data *component = find_mode (bclass, base);
 500   char namebuf[8];
 501
 502   if (vclass == MODE_RANDOM)
 503     return;
 504   if (component == 0)
 505     {
 506       error ("%s:%d: no mode \"%s\" in class %s",
 507              file, line, base, mode_class_names[bclass] + 5);
 508       return;
 509     }
 510
 511   if ((size_t)snprintf (namebuf, sizeof namebuf, "V%u%s",
 512                         ncomponents, base) >= sizeof namebuf)
 513     {
 514       error ("%s:%d: mode name \"%s\" is too long",
 515              base, file, line);
 516       return;
 517     }
 518
 519   v = new_mode (vclass, xstrdup (namebuf), file, line);
 520   v->ncomponents = ncomponents;
 521   v->component = component;
 522 }
 523
 524
 525 static void
 526 create_modes (void)
 527 {
 528 #include "machmode.def"
 529 }
 530
 531 /* Processing.  */
 532
 533 /* Sort a list of modes into the order needed for the WIDER field:
 534    major sort by bitsize, minor sort by component bitsize.
 535
 536    For instance:
 537      QI < HI < SI < DI < TI
 538      V4QI < V2HI < V8QI < V4HI < V2SI.
 539
 540    If the bitsize is not set, sort by the bytesize.  A mode with
 541    bitsize set gets sorted before a mode without bitsize set, if
 542    they have the same bytesize; this is the right thing because
 543    the bitsize must always be smaller than the bytesize * BITS_PER_UNIT.
 544    We don't have to do anything special to get this done -- an unset
 545    bitsize shows up as (unsigned int)-1, i.e. UINT_MAX.  */
 546 static int
 547 cmp_modes (const void *a, const void *b)
 548 {
 549   struct mode_data *m = *(struct mode_data **)a;
 550   struct mode_data *n = *(struct mode_data **)b;
 551
 552   if (m->bytesize > n->bytesize)
 553     return 1;
 554   else if (m->bytesize < n->bytesize)
 555     return -1;
 556
 557   if (m->bitsize > n->bitsize)
 558     return 1;
 559   else if (m->bitsize < n->bitsize)
 560     return -1;
 561
 562   if (!m->component && !n->component)
 563     return 0;
 564
 565   if (m->component->bytesize > n->component->bytesize)
 566     return 1;
 567   else if (m->component->bytesize < n->component->bytesize)
 568     return -1;
 569
 570   if (m->component->bitsize > n->component->bitsize)
 571     return 1;
 572   else if (m->component->bitsize < n->component->bitsize)
 573     return -1;
 574
 575   return 0;
 576 }
 577
 578 static void
 579 calc_wider_mode (void)
 580 {
 581   enum mode_class c;
 582   struct mode_data *m;
 583   struct mode_data **sortbuf;
 584   unsigned int max_n_modes = 0;
 585   unsigned int i, j;
 586
 587   for (c = 0; c < MAX_MODE_CLASS; c++)
 588     max_n_modes = MAX (max_n_modes, n_modes[c]);
 589
 590   sortbuf = alloca (max_n_modes * sizeof (struct mode_data *));
 591
 592   for (c = 0; c < MAX_MODE_CLASS; c++)
 593     {
 594       /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
 595          However, we want these in textual order, and we have
 596          precisely the reverse.  */
 597       if (c == MODE_RANDOM || c == MODE_CC)
 598         {
 599           struct mode_data *prev, *next;
 600
 601           for (prev = 0, m = known_modes[c]; m; m = next)
 602             {
 603               m->wider = void_mode;
 604
 605               /* this is nreverse */
 606               next = m->next;
 607               m->next = prev;
 608               prev = m;
 609             }
 610           known_modes[c] = prev;
 611         }
 612       else
 613         {
 614           if (!known_modes[c])
 615             continue;
 616
 617           for (i = 0, m = known_modes[c]; m; i++, m = m->next)
 618             sortbuf[i] = m;
 619
 620           qsort (sortbuf, i, sizeof (struct mode_data *), cmp_modes);
 621
 622           sortbuf[i] = 0;
 623           for (j = 0; j < i; j++)
 624             sortbuf[j]->next = sortbuf[j]->wider = sortbuf[j + 1];
 625
 626
 627           known_modes[c] = sortbuf[0];
 628         }
 629     }
 630 }
 631
 632 /* Output routines.  */
 633
 634 #define tagged_printf(FMT, ARG, TAG) do {               \
 635   int count_;                                           \
 636   printf ("  " FMT ",%n", ARG, &count_);                \
 637   printf ("%*s/* %s */\n", 27 - count_, "", TAG);       \
 638 } while (0)
 639
 640 #define print_decl(TYPE, NAME, ASIZE) \
 641   printf ("\nconst %s %s[%s] =\n{\n", TYPE, NAME, ASIZE);
 642
 643 #define print_closer() puts ("};")
 644
 645 static void
 646 emit_insn_modes_h (void)
 647 {
 648   enum mode_class c;
 649   struct mode_data *m, *first, *last;
 650
 651   printf ("/* Generated automatically from machmode.def%s%s\n",
 652            HAVE_EXTRA_MODES ? " and " : "",
 653            EXTRA_MODES_FILE);
 654
 655   puts ("\
 656    by genmodes.  */\n\
 657 \n\
 658 #ifndef GCC_INSN_MODES_H\n\
 659 #define GCC_INSN_MODES_H\n\
 660 \n\
 661 enum machine_mode\n{");
 662
 663   for (c = 0; c < MAX_MODE_CLASS; c++)
 664     for (m = known_modes[c]; m; m = m->next)
 665       {
 666         int count_;
 667         printf ("  %smode,%n", m->name, &count_);
 668         printf ("%*s/* %s:%d */\n", 27 - count_, "",
 669                  trim_filename (m->file), m->line);
 670       }
 671
 672   puts ("  MAX_MACHINE_MODE,\n");
 673
 674   for (c = 0; c < MAX_MODE_CLASS; c++)
 675     {
 676       first = known_modes[c];
 677       last = 0;
 678       for (m = first; m; last = m, m = m->next)
 679         ;
 680
 681       /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
 682          end will try to use it for bitfields in structures and the
 683          like, which we do not want.  Only the target md file should
 684          generate BImode widgets.  */
 685       if (first && first->bitsize == 1)
 686         first = first->next;
 687
 688       if (first && last)
 689         printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
 690                  mode_class_names[c], first->name,
 691                  mode_class_names[c], last->name);
 692       else
 693         printf ("  MIN_%s = %smode,\n  MAX_%s = %smode,\n\n",
 694                  mode_class_names[c], void_mode->name,
 695                  mode_class_names[c], void_mode->name);
 696     }
 697
 698   puts ("\
 699   NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
 700 };\n\
 701 \n\
 702 #endif /* insn-modes.h */");
 703 }
 704
 705 static void
 706 emit_insn_modes_c_header (void)
 707 {
 708   printf ("/* Generated automatically from machmode.def%s%s\n",
 709            HAVE_EXTRA_MODES ? " and " : "",
 710            EXTRA_MODES_FILE);
 711
 712   puts ("\
 713    by genmodes.  */\n\
 714 \n\
 715 #include \"config.h\"\n\
 716 #include \"system.h\"\n\
 717 #include \"coretypes.h\"\n\
 718 #include \"tm.h\"\n\
 719 #include \"machmode.h\"\n\
 720 #include \"real.h\"");
 721 }
 722
 723 static void
 724 emit_min_insn_modes_c_header (void)
 725 {
 726   printf ("/* Generated automatically from machmode.def%s%s\n",
 727            HAVE_EXTRA_MODES ? " and " : "",
 728            EXTRA_MODES_FILE);
 729
 730   puts ("\
 731    by genmodes.  */\n\
 732 \n\
 733 #include \"bconfig.h\"\n\
 734 #include \"system.h\"\n\
 735 #include \"machmode.h\"");
 736 }
 737
 738 static void
 739 emit_mode_name (void)
 740 {
 741   enum mode_class c;
 742   struct mode_data *m;
 743
 744   print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
 745
 746   for_all_modes (c, m)
 747     printf ("  \"%s\",\n", m->name);
 748
 749   print_closer ();
 750 }
 751
 752 static void
 753 emit_mode_class (void)
 754 {
 755   enum mode_class c;
 756   struct mode_data *m;
 757
 758   print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
 759
 760   for_all_modes (c, m)
 761     tagged_printf ("%s", mode_class_names[m->class], m->name);
 762
 763   print_closer ();
 764 }
 765
 766 static void
 767 emit_mode_bitsize (void)
 768 {
 769   enum mode_class c;
 770   struct mode_data *m;
 771
 772   print_decl ("unsigned short", "mode_bitsize", "NUM_MACHINE_MODES");
 773
 774   for_all_modes (c, m)
 775     if (m->bitsize != (unsigned int)-1)
 776       tagged_printf ("%u", m->bitsize, m->name);
 777     else
 778       tagged_printf ("%u*BITS_PER_UNIT", m->bytesize, m->name);
 779
 780   print_closer ();
 781 }
 782
 783 static void
 784 emit_mode_size (void)
 785 {
 786   enum mode_class c;
 787   struct mode_data *m;
 788
 789   print_decl ("unsigned char", "mode_size", "NUM_MACHINE_MODES");
 790
 791   for_all_modes (c, m)
 792     tagged_printf ("%u", m->bytesize, m->name);
 793
 794   print_closer ();
 795 }
 796
 797 static void
 798 emit_mode_unit_size (void)
 799 {
 800   enum mode_class c;
 801   struct mode_data *m;
 802
 803   print_decl ("unsigned char", "mode_unit_size", "NUM_MACHINE_MODES");
 804
 805   for_all_modes (c, m)
 806     tagged_printf ("%u",
 807                    m->component
 808                    ? m->component->bytesize : m->bytesize,
 809                    m->name);
 810
 811   print_closer ();
 812 }
 813
 814 static void
 815 emit_mode_wider (void)
 816 {
 817   enum mode_class c;
 818   struct mode_data *m;
 819
 820   print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
 821
 822   for_all_modes (c, m)
 823     tagged_printf ("%smode",
 824                    m->wider ? m->wider->name : void_mode->name,
 825                    m->name);
 826
 827   print_closer ();
 828 }
 829
 830 static void
 831 emit_mode_mask (void)
 832 {
 833   enum mode_class c;
 834   struct mode_data *m;
 835
 836   print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
 837               "NUM_MACHINE_MODES");
 838   puts ("\
 839 #define MODE_MASK(m)                          \\\n\
 840   ((m) >= HOST_BITS_PER_WIDE_INT)             \\\n\
 841    ? ~(unsigned HOST_WIDE_INT) 0              \\\n\
 842    : ((unsigned HOST_WIDE_INT) 1 << (m)) - 1\n");
 843
 844   for_all_modes (c, m)
 845     if (m->bitsize != (unsigned int)-1)
 846       tagged_printf ("MODE_MASK (%u)", m->bitsize, m->name);
 847     else
 848       tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m->bytesize, m->name);
 849
 850   puts ("#undef MODE_MASK");
 851   print_closer ();
 852 }
 853
 854 static void
 855 emit_mode_inner (void)
 856 {
 857   enum mode_class c;
 858   struct mode_data *m;
 859
 860   print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
 861
 862   for_all_modes (c, m)
 863     tagged_printf ("%smode",
 864                    m->component ? m->component->name : void_mode->name,
 865                    m->name);
 866
 867   print_closer ();
 868 }
 869
 870 static void
 871 emit_mode_base_align (void)
 872 {
 873   enum mode_class c;
 874   struct mode_data *m;
 875
 876   print_decl ("unsigned char", "mode_base_align", "NUM_MACHINE_MODES");
 877
 878   for_all_modes (c, m)
 879     tagged_printf ("%u", m->alignment, m->name);
 880
 881   print_closer ();
 882 }
 883
 884 static void
 885 emit_class_narrowest_mode (void)
 886 {
 887   enum mode_class c;
 888
 889   print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
 890
 891   for (c = 0; c < MAX_MODE_CLASS; c++)
 892     /* Bleah, all this to get the comment right for MIN_MODE_INT.  */
 893     tagged_printf ("MIN_%s", mode_class_names[c],
 894                    known_modes[c]
 895                    ? (known_modes[c]->bitsize != 1
 896                       ? known_modes[c]->name
 897                       : (known_modes[c]->next
 898                          ? known_modes[c]->next->name
 899                          : void_mode->name))
 900                    : void_mode->name);
 901
 902   print_closer ();
 903 }
 904
 905 static void
 906 emit_real_format_for_mode (void)
 907 {
 908   struct mode_data *m;
 909
 910   /* This will produce a table which is not constant, but points to
 911      entities that are constant, which is what we want.  */
 912   print_decl ("struct real_format *\n ", "real_format_for_mode",
 913               "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1");
 914
 915   for (m = known_modes[MODE_FLOAT]; m; m = m->next)
 916     if (!strcmp (m->format, "0"))
 917       tagged_printf ("%s", m->format, m->name);
 918     else
 919       tagged_printf ("&%s", m->format, m->name);
 920
 921   print_closer ();
 922 }
 923
 924 static void
 925 emit_insn_modes_c (void)
 926 {
 927   emit_insn_modes_c_header ();
 928   emit_mode_name ();
 929   emit_mode_class ();
 930   emit_mode_bitsize ();
 931   emit_mode_size ();
 932   emit_mode_unit_size ();
 933   emit_mode_wider ();
 934   emit_mode_mask ();
 935   emit_mode_inner ();
 936   emit_mode_base_align ();
 937   emit_class_narrowest_mode ();
 938   emit_real_format_for_mode ();
 939 }
 940
 941 static void
 942 emit_min_insn_modes_c (void)
 943 {
 944   emit_min_insn_modes_c_header ();
 945   emit_mode_name ();
 946   emit_mode_class ();
 947   emit_mode_wider ();
 948   emit_class_narrowest_mode ();
 949 }
 950
 951 /* Master control.  */
 952 int
 953 main(int argc, char **argv)
 954 {
 955   bool gen_header = false, gen_min = false;
 956   progname = argv[0];
 957
 958   if (argc == 1)
 959     ;
 960   else if (argc == 2 && !strcmp (argv[1], "-h"))
 961     gen_header = true;
 962   else if (argc == 2 && !strcmp (argv[1], "-m"))
 963     gen_min = true;
 964   else
 965     {
 966       error ("usage: %s [-h|-m] > file", progname);
 967       return FATAL_EXIT_CODE;
 968     }
 969
 970   create_modes ();
 971   complete_all_modes ();
 972
 973   if (have_error)
 974     return FATAL_EXIT_CODE;
 975
 976   calc_wider_mode ();
 977
 978   if (gen_header)
 979     emit_insn_modes_h ();
 980   else if (gen_min)
 981     emit_min_insn_modes_c ();
 982   else
 983     emit_insn_modes_c ();
 984
 985   if (fflush (stdout) || fclose (stdout))
 986     return FATAL_EXIT_CODE;
 987   return SUCCESS_EXIT_CODE;
 988 }