contrib/gcc-8.0/gcc/genmodes.c

   1 /* Generate the machine mode enumeration and associated tables.
   2    Copyright (C) 2003-2018 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
  24 /* enum mode_class is normally defined by machmode.h but we can't
  25    include that header here.  */
  26 #include "mode-classes.def"
  27
  28 #define DEF_MODE_CLASS(M) M
  29 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
  30 #undef DEF_MODE_CLASS
  31
  32 /* Text names of mode classes, for output.  */
  33 #define DEF_MODE_CLASS(M) #M
  34 static const char *const mode_class_names[MAX_MODE_CLASS] =
  35 {
  36   MODE_CLASSES
  37 };
  38 #undef DEF_MODE_CLASS
  39 #undef MODE_CLASSES
  40
  41 #ifdef EXTRA_MODES_FILE
  42 # define HAVE_EXTRA_MODES 1
  43 #else
  44 # define HAVE_EXTRA_MODES 0
  45 # define EXTRA_MODES_FILE ""
  46 #endif
  47
  48 /* Data structure for building up what we know about a mode.
  49    They're clustered by mode class.  */
  50 struct mode_data
  51 {
  52   struct mode_data *next;       /* next this class - arbitrary order */
  53
  54   const char *name;             /* printable mode name -- SI, not SImode */
  55   enum mode_class cl;           /* this mode class */
  56   unsigned int precision;       /* size in bits, equiv to TYPE_PRECISION */
  57   unsigned int bytesize;        /* storage size in addressable units */
  58   unsigned int ncomponents;     /* number of subunits */
  59   unsigned int alignment;       /* mode alignment */
  60   const char *format;           /* floating point format - float modes only */
  61
  62   struct mode_data *component;  /* mode of components */
  63   struct mode_data *wider;      /* next wider mode */
  64
  65   struct mode_data *contained;  /* Pointer to list of modes that have
  66                                    this mode as a component.  */
  67   struct mode_data *next_cont;  /* Next mode in that list.  */
  68
  69   struct mode_data *complex;    /* complex type with mode as component.  */
  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   bool need_nunits_adj;         /* true if this mode needs dynamic nunits
  76                                    adjustment */
  77   bool need_bytesize_adj;       /* true if this mode needs dynamic size
  78                                    adjustment */
  79   unsigned int int_n;           /* If nonzero, then __int<INT_N> will be defined */
  80 };
  81
  82 static struct mode_data *modes[MAX_MODE_CLASS];
  83 static unsigned int n_modes[MAX_MODE_CLASS];
  84 static struct mode_data *void_mode;
  85
  86 static const struct mode_data blank_mode = {
  87   0, "<unknown>", MAX_MODE_CLASS,
  88   -1U, -1U, -1U, -1U,
  89   0, 0, 0, 0, 0, 0,
  90   "<unknown>", 0, 0, 0, 0, false, false, 0
  91 };
  92
  93 static htab_t modes_by_name;
  94
  95 /* Data structure for recording target-specified runtime adjustments
  96    to a particular mode.  We support varying the byte size, the
  97    alignment, and the floating point format.  */
  98 struct mode_adjust
  99 {
 100   struct mode_adjust *next;
 101   struct mode_data *mode;
 102   const char *adjustment;
 103
 104   const char *file;
 105   unsigned int line;
 106 };
 107
 108 static struct mode_adjust *adj_nunits;
 109 static struct mode_adjust *adj_bytesize;
 110 static struct mode_adjust *adj_alignment;
 111 static struct mode_adjust *adj_format;
 112 static struct mode_adjust *adj_ibit;
 113 static struct mode_adjust *adj_fbit;
 114
 115 /* Mode class operations.  */
 116 static enum mode_class
 117 complex_class (enum mode_class c)
 118 {
 119   switch (c)
 120     {
 121     case MODE_INT: return MODE_COMPLEX_INT;
 122     case MODE_PARTIAL_INT: return MODE_COMPLEX_INT;
 123     case MODE_FLOAT: return MODE_COMPLEX_FLOAT;
 124     default:
 125       error ("no complex class for class %s", mode_class_names[c]);
 126       return MODE_RANDOM;
 127     }
 128 }
 129
 130 static enum mode_class
 131 vector_class (enum mode_class cl)
 132 {
 133   switch (cl)
 134     {
 135     case MODE_INT: return MODE_VECTOR_INT;
 136     case MODE_FLOAT: return MODE_VECTOR_FLOAT;
 137     case MODE_FRACT: return MODE_VECTOR_FRACT;
 138     case MODE_UFRACT: return MODE_VECTOR_UFRACT;
 139     case MODE_ACCUM: return MODE_VECTOR_ACCUM;
 140     case MODE_UACCUM: return MODE_VECTOR_UACCUM;
 141     default:
 142       error ("no vector class for class %s", mode_class_names[cl]);
 143       return MODE_RANDOM;
 144     }
 145 }
 146
 147 /* Utility routines.  */
 148 static inline struct mode_data *
 149 find_mode (const char *name)
 150 {
 151   struct mode_data key;
 152
 153   key.name = name;
 154   return (struct mode_data *) htab_find (modes_by_name, &key);
 155 }
 156
 157 static struct mode_data *
 158 new_mode (enum mode_class cl, const char *name,
 159           const char *file, unsigned int line)
 160 {
 161   struct mode_data *m;
 162   static unsigned int count = 0;
 163
 164   m = find_mode (name);
 165   if (m)
 166     {
 167       error ("%s:%d: duplicate definition of mode \"%s\"",
 168              trim_filename (file), line, name);
 169       error ("%s:%d: previous definition here", m->file, m->line);
 170       return m;
 171     }
 172
 173   m = XNEW (struct mode_data);
 174   memcpy (m, &blank_mode, sizeof (struct mode_data));
 175   m->cl = cl;
 176   m->name = name;
 177   if (file)
 178     m->file = trim_filename (file);
 179   m->line = line;
 180   m->counter = count++;
 181
 182   m->next = modes[cl];
 183   modes[cl] = m;
 184   n_modes[cl]++;
 185
 186   *htab_find_slot (modes_by_name, m, INSERT) = m;
 187
 188   return m;
 189 }
 190
 191 static hashval_t
 192 hash_mode (const void *p)
 193 {
 194   const struct mode_data *m = (const struct mode_data *)p;
 195   return htab_hash_string (m->name);
 196 }
 197
 198 static int
 199 eq_mode (const void *p, const void *q)
 200 {
 201   const struct mode_data *a = (const struct mode_data *)p;
 202   const struct mode_data *b = (const struct mode_data *)q;
 203
 204   return !strcmp (a->name, b->name);
 205 }
 206
 207 #define for_all_modes(C, M)                     \
 208   for (C = 0; C < MAX_MODE_CLASS; C++)          \
 209     for (M = modes[C]; M; M = M->next)
 210
 211 static void ATTRIBUTE_UNUSED
 212 new_adjust (const char *name,
 213             struct mode_adjust **category, const char *catname,
 214             const char *adjustment,
 215             enum mode_class required_class_from,
 216             enum mode_class required_class_to,
 217             const char *file, unsigned int line)
 218 {
 219   struct mode_data *mode = find_mode (name);
 220   struct mode_adjust *a;
 221
 222   file = trim_filename (file);
 223
 224   if (!mode)
 225     {
 226       error ("%s:%d: no mode \"%s\"", file, line, name);
 227       return;
 228     }
 229
 230   if (required_class_from != MODE_RANDOM
 231       && (mode->cl < required_class_from || mode->cl > required_class_to))
 232     {
 233       error ("%s:%d: mode \"%s\" is not among class {%s, %s}",
 234              file, line, name, mode_class_names[required_class_from] + 5,
 235              mode_class_names[required_class_to] + 5);
 236       return;
 237     }
 238
 239   for (a = *category; a; a = a->next)
 240     if (a->mode == mode)
 241       {
 242         error ("%s:%d: mode \"%s\" already has a %s adjustment",
 243                file, line, name, catname);
 244         error ("%s:%d: previous adjustment here", a->file, a->line);
 245         return;
 246       }
 247
 248   a = XNEW (struct mode_adjust);
 249   a->mode = mode;
 250   a->adjustment = adjustment;
 251   a->file = file;
 252   a->line = line;
 253
 254   a->next = *category;
 255   *category = a;
 256 }
 257
 258 /* Diagnose failure to meet expectations in a partially filled out
 259    mode structure.  */
 260 enum requirement { SET, UNSET, OPTIONAL };
 261
 262 #define validate_field_(mname, fname, req, val, unset, file, line) do { \
 263   switch (req)                                                          \
 264     {                                                                   \
 265     case SET:                                                           \
 266       if (val == unset)                                                 \
 267         error ("%s:%d: (%s) field %s must be set",                      \
 268                file, line, mname, fname);                               \
 269       break;                                                            \
 270     case UNSET:                                                         \
 271       if (val != unset)                                                 \
 272         error ("%s:%d: (%s) field %s must not be set",                  \
 273                file, line, mname, fname);                               \
 274     case OPTIONAL:                                                      \
 275       break;                                                            \
 276     }                                                                   \
 277 } while (0)
 278
 279 #define validate_field(M, F) \
 280   validate_field_(M->name, #F, r_##F, M->F, blank_mode.F, M->file, M->line)
 281
 282 static void
 283 validate_mode (struct mode_data *m,
 284                enum requirement r_precision,
 285                enum requirement r_bytesize,
 286                enum requirement r_component,
 287                enum requirement r_ncomponents,
 288                enum requirement r_format)
 289 {
 290   validate_field (m, precision);
 291   validate_field (m, bytesize);
 292   validate_field (m, component);
 293   validate_field (m, ncomponents);
 294   validate_field (m, format);
 295 }
 296 #undef validate_field
 297 #undef validate_field_
 298
 299 /* Given a partially-filled-out mode structure, figure out what we can
 300    and fill the rest of it in; die if it isn't enough.  */
 301 static void
 302 complete_mode (struct mode_data *m)
 303 {
 304   unsigned int alignment;
 305
 306   if (!m->name)
 307     {
 308       error ("%s:%d: mode with no name", m->file, m->line);
 309       return;
 310     }
 311   if (m->cl == MAX_MODE_CLASS)
 312     {
 313       error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
 314       return;
 315     }
 316
 317   switch (m->cl)
 318     {
 319     case MODE_RANDOM:
 320       /* Nothing more need be said.  */
 321       if (!strcmp (m->name, "VOID"))
 322         void_mode = m;
 323
 324       validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
 325
 326       m->precision = 0;
 327       m->bytesize = 0;
 328       m->ncomponents = 0;
 329       m->component = 0;
 330       break;
 331
 332     case MODE_CC:
 333       /* Again, nothing more need be said.  For historical reasons,
 334          the size of a CC mode is four units.  */
 335       validate_mode (m, UNSET, UNSET, UNSET, UNSET, UNSET);
 336
 337       m->bytesize = 4;
 338       m->ncomponents = 1;
 339       m->component = 0;
 340       break;
 341
 342     case MODE_INT:
 343     case MODE_POINTER_BOUNDS:
 344     case MODE_FLOAT:
 345     case MODE_DECIMAL_FLOAT:
 346     case MODE_FRACT:
 347     case MODE_UFRACT:
 348     case MODE_ACCUM:
 349     case MODE_UACCUM:
 350       /* A scalar mode must have a byte size, may have a bit size,
 351          and must not have components.   A float mode must have a
 352          format.  */
 353       validate_mode (m, OPTIONAL, SET, UNSET, UNSET,
 354                      (m->cl == MODE_FLOAT || m->cl == MODE_DECIMAL_FLOAT)
 355                      ? SET : UNSET);
 356
 357       m->ncomponents = 1;
 358       m->component = 0;
 359       break;
 360
 361     case MODE_PARTIAL_INT:
 362       /* A partial integer mode uses ->component to say what the
 363          corresponding full-size integer mode is, and may also
 364          specify a bit size.  */
 365       validate_mode (m, OPTIONAL, UNSET, SET, UNSET, UNSET);
 366
 367       m->bytesize = m->component->bytesize;
 368
 369       m->ncomponents = 1;
 370       break;
 371
 372     case MODE_COMPLEX_INT:
 373     case MODE_COMPLEX_FLOAT:
 374       /* Complex modes should have a component indicated, but no more.  */
 375       validate_mode (m, UNSET, UNSET, SET, UNSET, UNSET);
 376       m->ncomponents = 2;
 377       if (m->component->precision != (unsigned int)-1)
 378         m->precision = 2 * m->component->precision;
 379       m->bytesize = 2 * m->component->bytesize;
 380       break;
 381
 382     case MODE_VECTOR_BOOL:
 383       validate_mode (m, UNSET, SET, SET, SET, UNSET);
 384       break;
 385
 386     case MODE_VECTOR_INT:
 387     case MODE_VECTOR_FLOAT:
 388     case MODE_VECTOR_FRACT:
 389     case MODE_VECTOR_UFRACT:
 390     case MODE_VECTOR_ACCUM:
 391     case MODE_VECTOR_UACCUM:
 392       /* Vector modes should have a component and a number of components.  */
 393       validate_mode (m, UNSET, UNSET, SET, SET, UNSET);
 394       if (m->component->precision != (unsigned int)-1)
 395         m->precision = m->ncomponents * m->component->precision;
 396       m->bytesize = m->ncomponents * m->component->bytesize;
 397       break;
 398
 399     default:
 400       gcc_unreachable ();
 401     }
 402
 403   /* If not already specified, the mode alignment defaults to the largest
 404      power of two that divides the size of the object.  Complex types are
 405      not more aligned than their contents.  */
 406   if (m->cl == MODE_COMPLEX_INT || m->cl == MODE_COMPLEX_FLOAT)
 407     alignment = m->component->bytesize;
 408   else
 409     alignment = m->bytesize;
 410
 411   m->alignment = alignment & (~alignment + 1);
 412
 413   /* If this mode has components, make the component mode point back
 414      to this mode, for the sake of adjustments.  */
 415   if (m->component)
 416     {
 417       m->next_cont = m->component->contained;
 418       m->component->contained = m;
 419     }
 420 }
 421
 422 static void
 423 complete_all_modes (void)
 424 {
 425   struct mode_data *m;
 426   int cl;
 427
 428   for_all_modes (cl, m)
 429     complete_mode (m);
 430 }
 431
 432 /* For each mode in class CLASS, construct a corresponding complex mode.  */
 433 #define COMPLEX_MODES(C) make_complex_modes (MODE_##C, __FILE__, __LINE__)
 434 static void
 435 make_complex_modes (enum mode_class cl,
 436                     const char *file, unsigned int line)
 437 {
 438   struct mode_data *m;
 439   struct mode_data *c;
 440   enum mode_class cclass = complex_class (cl);
 441
 442   if (cclass == MODE_RANDOM)
 443     return;
 444
 445   for (m = modes[cl]; m; m = m->next)
 446     {
 447       char *p, *buf;
 448       size_t m_len;
 449
 450       /* Skip BImode.  FIXME: BImode probably shouldn't be MODE_INT.  */
 451       if (m->precision == 1)
 452         continue;
 453
 454       m_len = strlen (m->name);
 455       /* The leading "1 +" is in case we prepend a "C" below.  */
 456       buf = (char *) xmalloc (1 + m_len + 1);
 457
 458       /* Float complex modes are named SCmode, etc.
 459          Int complex modes are named CSImode, etc.
 460          This inconsistency should be eliminated.  */
 461       p = 0;
 462       if (cl == MODE_FLOAT)
 463         {
 464           memcpy (buf, m->name, m_len + 1);
 465           p = strchr (buf, 'F');
 466           if (p == 0 && strchr (buf, 'D') == 0)
 467             {
 468               error ("%s:%d: float mode \"%s\" has no 'F' or 'D'",
 469                      m->file, m->line, m->name);
 470               free (buf);
 471               continue;
 472             }
 473         }
 474       if (p != 0)
 475         *p = 'C';
 476       else
 477         {
 478           buf[0] = 'C';
 479           memcpy (buf + 1, m->name, m_len + 1);
 480         }
 481
 482       c = new_mode (cclass, buf, file, line);
 483       c->component = m;
 484       m->complex = c;
 485     }
 486 }
 487
 488 /* For all modes in class CL, construct vector modes of width
 489    WIDTH, having as many components as necessary.  */
 490 #define VECTOR_MODES_WITH_PREFIX(PREFIX, C, W) \
 491   make_vector_modes (MODE_##C, #PREFIX, W, __FILE__, __LINE__)
 492 #define VECTOR_MODES(C, W) VECTOR_MODES_WITH_PREFIX (V, C, W)
 493 static void ATTRIBUTE_UNUSED
 494 make_vector_modes (enum mode_class cl, const char *prefix, unsigned int width,
 495                    const char *file, unsigned int line)
 496 {
 497   struct mode_data *m;
 498   struct mode_data *v;
 499   /* Big enough for a 32-bit UINT_MAX plus the text.  */
 500   char buf[12];
 501   unsigned int ncomponents;
 502   enum mode_class vclass = vector_class (cl);
 503
 504   if (vclass == MODE_RANDOM)
 505     return;
 506
 507   for (m = modes[cl]; m; m = m->next)
 508     {
 509       /* Do not construct vector modes with only one element, or
 510          vector modes where the element size doesn't divide the full
 511          size evenly.  */
 512       ncomponents = width / m->bytesize;
 513       if (ncomponents < 2)
 514         continue;
 515       if (width % m->bytesize)
 516         continue;
 517
 518       /* Skip QFmode and BImode.  FIXME: this special case should
 519          not be necessary.  */
 520       if (cl == MODE_FLOAT && m->bytesize == 1)
 521         continue;
 522       if (cl == MODE_INT && m->precision == 1)
 523         continue;
 524
 525       if ((size_t) snprintf (buf, sizeof buf, "%s%u%s", prefix,
 526                              ncomponents, m->name) >= sizeof buf)
 527         {
 528           error ("%s:%d: mode name \"%s\" is too long",
 529                  m->file, m->line, m->name);
 530           continue;
 531         }
 532
 533       v = new_mode (vclass, xstrdup (buf), file, line);
 534       v->component = m;
 535       v->ncomponents = ncomponents;
 536     }
 537 }
 538
 539 /* Create a vector of booleans called NAME with COUNT elements and
 540    BYTESIZE bytes in total.  */
 541 #define VECTOR_BOOL_MODE(NAME, COUNT, BYTESIZE) \
 542   make_vector_bool_mode (#NAME, COUNT, BYTESIZE, __FILE__, __LINE__)
 543 static void ATTRIBUTE_UNUSED
 544 make_vector_bool_mode (const char *name, unsigned int count,
 545                        unsigned int bytesize, const char *file,
 546                        unsigned int line)
 547 {
 548   struct mode_data *m = find_mode ("BI");
 549   if (!m)
 550     {
 551       error ("%s:%d: no mode \"BI\"", file, line);
 552       return;
 553     }
 554
 555   struct mode_data *v = new_mode (MODE_VECTOR_BOOL, name, file, line);
 556   v->component = m;
 557   v->ncomponents = count;
 558   v->bytesize = bytesize;
 559 }
 560
 561 /* Input.  */
 562
 563 #define _SPECIAL_MODE(C, N) \
 564   make_special_mode (MODE_##C, #N, __FILE__, __LINE__)
 565 #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
 566 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
 567
 568 static void
 569 make_special_mode (enum mode_class cl, const char *name,
 570                    const char *file, unsigned int line)
 571 {
 572   new_mode (cl, name, file, line);
 573 }
 574
 575 #define POINTER_BOUNDS_MODE(N, Y) \
 576   make_pointer_bounds_mode (#N, Y, __FILE__, __LINE__)
 577
 578 static void ATTRIBUTE_UNUSED
 579 make_pointer_bounds_mode (const char *name,
 580                           unsigned int bytesize,
 581                           const char *file, unsigned int line)
 582 {
 583   struct mode_data *m = new_mode (MODE_POINTER_BOUNDS, name, file, line);
 584   m->bytesize = bytesize;
 585 }
 586
 587
 588 #define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
 589 #define FRACTIONAL_INT_MODE(N, B, Y) \
 590   make_int_mode (#N, B, Y, __FILE__, __LINE__)
 591
 592 static void
 593 make_int_mode (const char *name,
 594                unsigned int precision, unsigned int bytesize,
 595                const char *file, unsigned int line)
 596 {
 597   struct mode_data *m = new_mode (MODE_INT, name, file, line);
 598   m->bytesize = bytesize;
 599   m->precision = precision;
 600 }
 601
 602 #define FRACT_MODE(N, Y, F) \
 603         make_fixed_point_mode (MODE_FRACT, #N, Y, 0, F, __FILE__, __LINE__)
 604
 605 #define UFRACT_MODE(N, Y, F) \
 606         make_fixed_point_mode (MODE_UFRACT, #N, Y, 0, F, __FILE__, __LINE__)
 607
 608 #define ACCUM_MODE(N, Y, I, F) \
 609         make_fixed_point_mode (MODE_ACCUM, #N, Y, I, F, __FILE__, __LINE__)
 610
 611 #define UACCUM_MODE(N, Y, I, F) \
 612         make_fixed_point_mode (MODE_UACCUM, #N, Y, I, F, __FILE__, __LINE__)
 613
 614 /* Create a fixed-point mode by setting CL, NAME, BYTESIZE, IBIT, FBIT,
 615    FILE, and LINE.  */
 616
 617 static void
 618 make_fixed_point_mode (enum mode_class cl,
 619                        const char *name,
 620                        unsigned int bytesize,
 621                        unsigned int ibit,
 622                        unsigned int fbit,
 623                        const char *file, unsigned int line)
 624 {
 625   struct mode_data *m = new_mode (cl, name, file, line);
 626   m->bytesize = bytesize;
 627   m->ibit = ibit;
 628   m->fbit = fbit;
 629 }
 630
 631 #define FLOAT_MODE(N, Y, F)             FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
 632 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
 633   make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
 634
 635 static void
 636 make_float_mode (const char *name,
 637                  unsigned int precision, unsigned int bytesize,
 638                  const char *format,
 639                  const char *file, unsigned int line)
 640 {
 641   struct mode_data *m = new_mode (MODE_FLOAT, name, file, line);
 642   m->bytesize = bytesize;
 643   m->precision = precision;
 644   m->format = format;
 645 }
 646
 647 #define DECIMAL_FLOAT_MODE(N, Y, F)     \
 648         FRACTIONAL_DECIMAL_FLOAT_MODE (N, -1U, Y, F)
 649 #define FRACTIONAL_DECIMAL_FLOAT_MODE(N, B, Y, F)       \
 650   make_decimal_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
 651
 652 static void
 653 make_decimal_float_mode (const char *name,
 654                          unsigned int precision, unsigned int bytesize,
 655                          const char *format,
 656                          const char *file, unsigned int line)
 657 {
 658   struct mode_data *m = new_mode (MODE_DECIMAL_FLOAT, name, file, line);
 659   m->bytesize = bytesize;
 660   m->precision = precision;
 661   m->format = format;
 662 }
 663
 664 #define RESET_FLOAT_FORMAT(N, F) \
 665   reset_float_format (#N, #F, __FILE__, __LINE__)
 666 static void ATTRIBUTE_UNUSED
 667 reset_float_format (const char *name, const char *format,
 668                     const char *file, unsigned int line)
 669 {
 670   struct mode_data *m = find_mode (name);
 671   if (!m)
 672     {
 673       error ("%s:%d: no mode \"%s\"", file, line, name);
 674       return;
 675     }
 676   if (m->cl != MODE_FLOAT && m->cl != MODE_DECIMAL_FLOAT)
 677     {
 678       error ("%s:%d: mode \"%s\" is not a FLOAT class", file, line, name);
 679       return;
 680     }
 681   m->format = format;
 682 }
 683
 684 /* __intN support.  */
 685 #define INT_N(M,PREC)                           \
 686   make_int_n (#M, PREC, __FILE__, __LINE__)
 687 static void ATTRIBUTE_UNUSED
 688 make_int_n (const char *m, int bitsize,
 689             const char *file, unsigned int line)
 690 {
 691   struct mode_data *component = find_mode (m);
 692   if (!component)
 693     {
 694       error ("%s:%d: no mode \"%s\"", file, line, m);
 695       return;
 696     }
 697   if (component->cl != MODE_INT
 698       && component->cl != MODE_PARTIAL_INT)
 699     {
 700       error ("%s:%d: mode \"%s\" is not class INT or PARTIAL_INT", file, line, m);
 701       return;
 702     }
 703   if (component->int_n != 0)
 704     {
 705       error ("%s:%d: mode \"%s\" already has an intN", file, line, m);
 706       return;
 707     }
 708
 709   component->int_n = bitsize;
 710 }
 711
 712 /* Partial integer modes are specified by relation to a full integer
 713    mode.  */
 714 #define PARTIAL_INT_MODE(M,PREC,NAME)                           \
 715   make_partial_integer_mode (#M, #NAME, PREC, __FILE__, __LINE__)
 716 static void ATTRIBUTE_UNUSED
 717 make_partial_integer_mode (const char *base, const char *name,
 718                            unsigned int precision,
 719                            const char *file, unsigned int line)
 720 {
 721   struct mode_data *m;
 722   struct mode_data *component = find_mode (base);
 723   if (!component)
 724     {
 725       error ("%s:%d: no mode \"%s\"", file, line, name);
 726       return;
 727     }
 728   if (component->cl != MODE_INT)
 729     {
 730       error ("%s:%d: mode \"%s\" is not class INT", file, line, name);
 731       return;
 732     }
 733
 734   m = new_mode (MODE_PARTIAL_INT, name, file, line);
 735   m->precision = precision;
 736   m->component = component;
 737 }
 738
 739 /* A single vector mode can be specified by naming its component
 740    mode and the number of components.  */
 741 #define VECTOR_MODE(C, M, N) \
 742   make_vector_mode (MODE_##C, #M, N, __FILE__, __LINE__);
 743 static void ATTRIBUTE_UNUSED
 744 make_vector_mode (enum mode_class bclass,
 745                   const char *base,
 746                   unsigned int ncomponents,
 747                   const char *file, unsigned int line)
 748 {
 749   struct mode_data *v;
 750   enum mode_class vclass = vector_class (bclass);
 751   struct mode_data *component = find_mode (base);
 752   char namebuf[16];
 753
 754   if (vclass == MODE_RANDOM)
 755     return;
 756   if (component == 0)
 757     {
 758       error ("%s:%d: no mode \"%s\"", file, line, base);
 759       return;
 760     }
 761   if (component->cl != bclass
 762       && (component->cl != MODE_PARTIAL_INT
 763           || bclass != MODE_INT))
 764     {
 765       error ("%s:%d: mode \"%s\" is not class %s",
 766              file, line, base, mode_class_names[bclass] + 5);
 767       return;
 768     }
 769
 770   if ((size_t)snprintf (namebuf, sizeof namebuf, "V%u%s",
 771                         ncomponents, base) >= sizeof namebuf)
 772     {
 773       error ("%s:%d: mode name \"%s\" is too long",
 774              file, line, base);
 775       return;
 776     }
 777
 778   v = new_mode (vclass, xstrdup (namebuf), file, line);
 779   v->ncomponents = ncomponents;
 780   v->component = component;
 781 }
 782
 783 /* Adjustability.  */
 784 #define _ADD_ADJUST(A, M, X, C1, C2) \
 785   new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
 786
 787 #define ADJUST_NUNITS(M, X)    _ADD_ADJUST (nunits, M, X, RANDOM, RANDOM)
 788 #define ADJUST_BYTESIZE(M, X)  _ADD_ADJUST (bytesize, M, X, RANDOM, RANDOM)
 789 #define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST (alignment, M, X, RANDOM, RANDOM)
 790 #define ADJUST_FLOAT_FORMAT(M, X)    _ADD_ADJUST (format, M, X, FLOAT, FLOAT)
 791 #define ADJUST_IBIT(M, X)  _ADD_ADJUST (ibit, M, X, ACCUM, UACCUM)
 792 #define ADJUST_FBIT(M, X)  _ADD_ADJUST (fbit, M, X, FRACT, UACCUM)
 793
 794 static int bits_per_unit;
 795 static int max_bitsize_mode_any_int;
 796 static int max_bitsize_mode_any_mode;
 797
 798 static void
 799 create_modes (void)
 800 {
 801 #include "machmode.def"
 802
 803   /* So put the default value unless the target needs a non standard
 804      value. */
 805 #ifdef BITS_PER_UNIT
 806   bits_per_unit = BITS_PER_UNIT;
 807 #else
 808   bits_per_unit = 8;
 809 #endif
 810
 811 #ifdef MAX_BITSIZE_MODE_ANY_INT
 812   max_bitsize_mode_any_int = MAX_BITSIZE_MODE_ANY_INT;
 813 #else
 814   max_bitsize_mode_any_int = 0;
 815 #endif
 816
 817 #ifdef MAX_BITSIZE_MODE_ANY_MODE
 818   max_bitsize_mode_any_mode = MAX_BITSIZE_MODE_ANY_MODE;
 819 #else
 820   max_bitsize_mode_any_mode = 0;
 821 #endif
 822 }
 823
 824 #ifndef NUM_POLY_INT_COEFFS
 825 #define NUM_POLY_INT_COEFFS 1
 826 #endif
 827
 828 /* Processing.  */
 829
 830 /* Sort a list of modes into the order needed for the WIDER field:
 831    major sort by precision, minor sort by component precision.
 832
 833    For instance:
 834      QI < HI < SI < DI < TI
 835      V4QI < V2HI < V8QI < V4HI < V2SI.
 836
 837    If the precision is not set, sort by the bytesize.  A mode with
 838    precision set gets sorted before a mode without precision set, if
 839    they have the same bytesize; this is the right thing because
 840    the precision must always be smaller than the bytesize * BITS_PER_UNIT.
 841    We don't have to do anything special to get this done -- an unset
 842    precision shows up as (unsigned int)-1, i.e. UINT_MAX.  */
 843 static int
 844 cmp_modes (const void *a, const void *b)
 845 {
 846   const struct mode_data *const m = *(const struct mode_data *const*)a;
 847   const struct mode_data *const n = *(const struct mode_data *const*)b;
 848
 849   if (m->bytesize > n->bytesize)
 850     return 1;
 851   else if (m->bytesize < n->bytesize)
 852     return -1;
 853
 854   if (m->precision > n->precision)
 855     return 1;
 856   else if (m->precision < n->precision)
 857     return -1;
 858
 859   if (!m->component && !n->component)
 860     {
 861       if (m->counter < n->counter)
 862         return -1;
 863       else
 864         return 1;
 865     }
 866
 867   if (m->component->bytesize > n->component->bytesize)
 868     return 1;
 869   else if (m->component->bytesize < n->component->bytesize)
 870     return -1;
 871
 872   if (m->component->precision > n->component->precision)
 873     return 1;
 874   else if (m->component->precision < n->component->precision)
 875     return -1;
 876
 877   if (m->counter < n->counter)
 878     return -1;
 879   else
 880     return 1;
 881 }
 882
 883 static void
 884 calc_wider_mode (void)
 885 {
 886   int c;
 887   struct mode_data *m;
 888   struct mode_data **sortbuf;
 889   unsigned int max_n_modes = 0;
 890   unsigned int i, j;
 891
 892   for (c = 0; c < MAX_MODE_CLASS; c++)
 893     max_n_modes = MAX (max_n_modes, n_modes[c]);
 894
 895   /* Allocate max_n_modes + 1 entries to leave room for the extra null
 896      pointer assigned after the qsort call below.  */
 897   sortbuf = XALLOCAVEC (struct mode_data *, max_n_modes + 1);
 898
 899   for (c = 0; c < MAX_MODE_CLASS; c++)
 900     {
 901       /* "wider" is not meaningful for MODE_RANDOM and MODE_CC.
 902          However, we want these in textual order, and we have
 903          precisely the reverse.  */
 904       if (c == MODE_RANDOM || c == MODE_CC)
 905         {
 906           struct mode_data *prev, *next;
 907
 908           for (prev = 0, m = modes[c]; m; m = next)
 909             {
 910               m->wider = void_mode;
 911
 912               /* this is nreverse */
 913               next = m->next;
 914               m->next = prev;
 915               prev = m;
 916             }
 917           modes[c] = prev;
 918         }
 919       else
 920         {
 921           if (!modes[c])
 922             continue;
 923
 924           for (i = 0, m = modes[c]; m; i++, m = m->next)
 925             sortbuf[i] = m;
 926
 927           (qsort) (sortbuf, i, sizeof (struct mode_data *), cmp_modes);
 928
 929           sortbuf[i] = 0;
 930           for (j = 0; j < i; j++)
 931             {
 932               sortbuf[j]->next = sortbuf[j + 1];
 933               if (c == MODE_PARTIAL_INT)
 934                 sortbuf[j]->wider = sortbuf[j]->component;
 935               else
 936                 sortbuf[j]->wider = sortbuf[j]->next;
 937             }
 938
 939           modes[c] = sortbuf[0];
 940         }
 941     }
 942 }
 943
 944 /* Text to add to the constant part of a poly_int_pod initializer in
 945    order to fill out te whole structure.  */
 946 #if NUM_POLY_INT_COEFFS == 1
 947 #define ZERO_COEFFS ""
 948 #elif NUM_POLY_INT_COEFFS == 2
 949 #define ZERO_COEFFS ", 0"
 950 #else
 951 #error "Unknown value of NUM_POLY_INT_COEFFS"
 952 #endif
 953
 954 /* Output routines.  */
 955
 956 #define tagged_printf(FMT, ARG, TAG) do {               \
 957   int count_ = printf ("  " FMT ",", ARG);              \
 958   printf ("%*s/* %s */\n", 27 - count_, "", TAG);       \
 959 } while (0)
 960
 961 #define print_decl(TYPE, NAME, ASIZE) \
 962   puts ("\nconst " TYPE " " NAME "[" ASIZE "] =\n{");
 963
 964 #define print_maybe_const_decl(TYPE, NAME, ASIZE, NEEDS_ADJ)    \
 965   printf ("\n" TYPE " " NAME "[" ASIZE "] = \n{\n",             \
 966           NEEDS_ADJ ? "" : "const ")
 967
 968 #define print_closer() puts ("};")
 969
 970 /* Compute the max bitsize of some of the classes of integers.  It may
 971    be that there are needs for the other integer classes, and this
 972    code is easy to extend.  */
 973 static void
 974 emit_max_int (void)
 975 {
 976   unsigned int max, mmax;
 977   struct mode_data *i;
 978   int j;
 979
 980   puts ("");
 981
 982   printf ("#define BITS_PER_UNIT (%d)\n", bits_per_unit);
 983
 984   if (max_bitsize_mode_any_int == 0)
 985     {
 986       for (max = 1, i = modes[MODE_INT]; i; i = i->next)
 987         if (max < i->bytesize)
 988           max = i->bytesize;
 989       mmax = max;
 990       for (max = 1, i = modes[MODE_PARTIAL_INT]; i; i = i->next)
 991         if (max < i->bytesize)
 992           max = i->bytesize;
 993       if (max > mmax)
 994         mmax = max;
 995       printf ("#define MAX_BITSIZE_MODE_ANY_INT (%d*BITS_PER_UNIT)\n", mmax);
 996     }
 997   else
 998     printf ("#define MAX_BITSIZE_MODE_ANY_INT %d\n", max_bitsize_mode_any_int);
 999
1000   if (max_bitsize_mode_any_mode == 0)
1001     {
1002       mmax = 0;
1003       for (j = 0; j < MAX_MODE_CLASS; j++)
1004         for (i = modes[j]; i; i = i->next)
1005           if (mmax < i->bytesize)
1006             mmax = i->bytesize;
1007       printf ("#define MAX_BITSIZE_MODE_ANY_MODE (%d*BITS_PER_UNIT)\n", mmax);
1008     }
1009   else
1010     printf ("#define MAX_BITSIZE_MODE_ANY_MODE %d\n",
1011             max_bitsize_mode_any_mode);
1012 }
1013
1014 /* Emit mode_size_inline routine into insn-modes.h header.  */
1015 static void
1016 emit_mode_size_inline (void)
1017 {
1018   int c;
1019   struct mode_adjust *a;
1020   struct mode_data *m;
1021
1022   /* Size adjustments must be propagated to all containing modes.  */
1023   for (a = adj_bytesize; a; a = a->next)
1024     {
1025       a->mode->need_bytesize_adj = true;
1026       for (m = a->mode->contained; m; m = m->next_cont)
1027         m->need_bytesize_adj = true;
1028     }
1029
1030   /* Changing the number of units by a factor of X also changes the size
1031      by a factor of X.  */
1032   for (mode_adjust *a = adj_nunits; a; a = a->next)
1033     a->mode->need_bytesize_adj = true;
1034
1035   printf ("\
1036 #ifdef __cplusplus\n\
1037 inline __attribute__((__always_inline__))\n\
1038 #else\n\
1039 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1040 #endif\n\
1041 poly_uint16\n\
1042 mode_size_inline (machine_mode mode)\n\
1043 {\n\
1044   extern %spoly_uint16_pod mode_size[NUM_MACHINE_MODES];\n\
1045   gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\
1046   switch (mode)\n\
1047     {\n", adj_nunits || adj_bytesize ? "" : "const ");
1048
1049   for_all_modes (c, m)
1050     if (!m->need_bytesize_adj)
1051       printf ("    case E_%smode: return %u;\n", m->name, m->bytesize);
1052
1053   puts ("\
1054     default: return mode_size[mode];\n\
1055     }\n\
1056 }\n");
1057 }
1058
1059 /* Emit mode_nunits_inline routine into insn-modes.h header.  */
1060 static void
1061 emit_mode_nunits_inline (void)
1062 {
1063   int c;
1064   struct mode_data *m;
1065
1066   for (mode_adjust *a = adj_nunits; a; a = a->next)
1067     a->mode->need_nunits_adj = true;
1068
1069   printf ("\
1070 #ifdef __cplusplus\n\
1071 inline __attribute__((__always_inline__))\n\
1072 #else\n\
1073 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1074 #endif\n\
1075 poly_uint16\n\
1076 mode_nunits_inline (machine_mode mode)\n\
1077 {\n\
1078   extern %spoly_uint16_pod mode_nunits[NUM_MACHINE_MODES];\n\
1079   switch (mode)\n\
1080     {\n", adj_nunits ? "" : "const ");
1081
1082   for_all_modes (c, m)
1083     if (!m->need_nunits_adj)
1084       printf ("    case E_%smode: return %u;\n", m->name, m->ncomponents);
1085
1086   puts ("\
1087     default: return mode_nunits[mode];\n\
1088     }\n\
1089 }\n");
1090 }
1091
1092 /* Emit mode_inner_inline routine into insn-modes.h header.  */
1093 static void
1094 emit_mode_inner_inline (void)
1095 {
1096   int c;
1097   struct mode_data *m;
1098
1099   puts ("\
1100 #ifdef __cplusplus\n\
1101 inline __attribute__((__always_inline__))\n\
1102 #else\n\
1103 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1104 #endif\n\
1105 unsigned char\n\
1106 mode_inner_inline (machine_mode mode)\n\
1107 {\n\
1108   extern const unsigned char mode_inner[NUM_MACHINE_MODES];\n\
1109   gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\
1110   switch (mode)\n\
1111     {");
1112
1113   for_all_modes (c, m)
1114     printf ("    case E_%smode: return E_%smode;\n", m->name,
1115             c != MODE_PARTIAL_INT && m->component
1116             ? m->component->name : m->name);
1117
1118   puts ("\
1119     default: return mode_inner[mode];\n\
1120     }\n\
1121 }\n");
1122 }
1123
1124 /* Emit mode_unit_size_inline routine into insn-modes.h header.  */
1125 static void
1126 emit_mode_unit_size_inline (void)
1127 {
1128   int c;
1129   struct mode_data *m;
1130
1131   puts ("\
1132 #ifdef __cplusplus\n\
1133 inline __attribute__((__always_inline__))\n\
1134 #else\n\
1135 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1136 #endif\n\
1137 unsigned char\n\
1138 mode_unit_size_inline (machine_mode mode)\n\
1139 {\n\
1140   extern CONST_MODE_UNIT_SIZE unsigned char mode_unit_size[NUM_MACHINE_MODES];\
1141 \n\
1142   gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\
1143   switch (mode)\n\
1144     {");
1145
1146   for_all_modes (c, m)
1147     {
1148       const char *name = m->name;
1149       struct mode_data *m2 = m;
1150       if (c != MODE_PARTIAL_INT && m2->component)
1151         m2 = m2->component;
1152       if (!m2->need_bytesize_adj)
1153         printf ("    case E_%smode: return %u;\n", name, m2->bytesize);
1154     }
1155
1156   puts ("\
1157     default: return mode_unit_size[mode];\n\
1158     }\n\
1159 }\n");
1160 }
1161
1162 /* Emit mode_unit_precision_inline routine into insn-modes.h header.  */
1163 static void
1164 emit_mode_unit_precision_inline (void)
1165 {
1166   int c;
1167   struct mode_data *m;
1168
1169   puts ("\
1170 #ifdef __cplusplus\n\
1171 inline __attribute__((__always_inline__))\n\
1172 #else\n\
1173 extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\
1174 #endif\n\
1175 unsigned short\n\
1176 mode_unit_precision_inline (machine_mode mode)\n\
1177 {\n\
1178   extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];\n\
1179   gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\
1180   switch (mode)\n\
1181     {");
1182
1183   for_all_modes (c, m)
1184     {
1185       struct mode_data *m2
1186         = (c != MODE_PARTIAL_INT && m->component) ? m->component : m;
1187       if (m2->precision != (unsigned int)-1)
1188         printf ("    case E_%smode: return %u;\n", m->name, m2->precision);
1189       else
1190         printf ("    case E_%smode: return %u*BITS_PER_UNIT;\n",
1191                 m->name, m2->bytesize);
1192     }
1193
1194   puts ("\
1195     default: return mode_unit_precision[mode];\n\
1196     }\n\
1197 }\n");
1198 }
1199
1200 /* Return the best machine mode class for MODE, or null if machine_mode
1201    should be used.  */
1202
1203 static const char *
1204 get_mode_class (struct mode_data *mode)
1205 {
1206   switch (mode->cl)
1207     {
1208     case MODE_INT:
1209     case MODE_PARTIAL_INT:
1210       return "scalar_int_mode";
1211
1212     case MODE_FRACT:
1213     case MODE_UFRACT:
1214     case MODE_ACCUM:
1215     case MODE_UACCUM:
1216     case MODE_POINTER_BOUNDS:
1217       return "scalar_mode";
1218
1219     case MODE_FLOAT:
1220     case MODE_DECIMAL_FLOAT:
1221       return "scalar_float_mode";
1222
1223     case MODE_COMPLEX_INT:
1224     case MODE_COMPLEX_FLOAT:
1225       return "complex_mode";
1226
1227     default:
1228       return NULL;
1229     }
1230 }
1231
1232 static void
1233 emit_insn_modes_h (void)
1234 {
1235   int c;
1236   struct mode_data *m, *first, *last;
1237   int n_int_n_ents = 0;
1238
1239   printf ("/* Generated automatically from machmode.def%s%s\n",
1240            HAVE_EXTRA_MODES ? " and " : "",
1241            EXTRA_MODES_FILE);
1242
1243   puts ("\
1244    by genmodes.  */\n\
1245 \n\
1246 #ifndef GCC_INSN_MODES_H\n\
1247 #define GCC_INSN_MODES_H\n\
1248 \n\
1249 enum machine_mode\n{");
1250
1251   for (c = 0; c < MAX_MODE_CLASS; c++)
1252     for (m = modes[c]; m; m = m->next)
1253       {
1254         int count_ = printf ("  E_%smode,", m->name);
1255         printf ("%*s/* %s:%d */\n", 27 - count_, "",
1256                  trim_filename (m->file), m->line);
1257         printf ("#define HAVE_%smode\n", m->name);
1258         printf ("#ifdef USE_ENUM_MODES\n");
1259         printf ("#define %smode E_%smode\n", m->name, m->name);
1260         printf ("#else\n");
1261         if (const char *mode_class = get_mode_class (m))
1262           printf ("#define %smode (%s ((%s::from_int) E_%smode))\n",
1263                   m->name, mode_class, mode_class, m->name);
1264         else
1265           printf ("#define %smode ((void) 0, E_%smode)\n",
1266                   m->name, m->name);
1267         printf ("#endif\n");
1268       }
1269
1270   puts ("  MAX_MACHINE_MODE,\n");
1271
1272   for (c = 0; c < MAX_MODE_CLASS; c++)
1273     {
1274       first = modes[c];
1275       last = 0;
1276       for (m = first; m; last = m, m = m->next)
1277         ;
1278
1279       /* Don't use BImode for MIN_MODE_INT, since otherwise the middle
1280          end will try to use it for bitfields in structures and the
1281          like, which we do not want.  Only the target md file should
1282          generate BImode widgets.  */
1283       if (first && first->precision == 1 && c == MODE_INT)
1284         first = first->next;
1285
1286       if (first && last)
1287         printf ("  MIN_%s = E_%smode,\n  MAX_%s = E_%smode,\n\n",
1288                  mode_class_names[c], first->name,
1289                  mode_class_names[c], last->name);
1290       else
1291         printf ("  MIN_%s = E_%smode,\n  MAX_%s = E_%smode,\n\n",
1292                  mode_class_names[c], void_mode->name,
1293                  mode_class_names[c], void_mode->name);
1294     }
1295
1296   puts ("\
1297   NUM_MACHINE_MODES = MAX_MACHINE_MODE\n\
1298 };\n");
1299
1300   /* I can't think of a better idea, can you?  */
1301   printf ("#define CONST_MODE_NUNITS%s\n", adj_nunits ? "" : " const");
1302   printf ("#define CONST_MODE_PRECISION%s\n", adj_nunits ? "" : " const");
1303   printf ("#define CONST_MODE_SIZE%s\n",
1304           adj_bytesize || adj_nunits ? "" : " const");
1305   printf ("#define CONST_MODE_UNIT_SIZE%s\n", adj_bytesize ? "" : " const");
1306   printf ("#define CONST_MODE_BASE_ALIGN%s\n", adj_alignment ? "" : " const");
1307 #if 0 /* disabled for backward compatibility, temporary */
1308   printf ("#define CONST_REAL_FORMAT_FOR_MODE%s\n", adj_format ? "" :" const");
1309 #endif
1310   printf ("#define CONST_MODE_IBIT%s\n", adj_ibit ? "" : " const");
1311   printf ("#define CONST_MODE_FBIT%s\n", adj_fbit ? "" : " const");
1312   emit_max_int ();
1313
1314   for_all_modes (c, m)
1315     if (m->int_n)
1316       n_int_n_ents ++;
1317
1318   printf ("#define NUM_INT_N_ENTS %d\n", n_int_n_ents);
1319
1320   printf ("#define NUM_POLY_INT_COEFFS %d\n", NUM_POLY_INT_COEFFS);
1321
1322   puts ("\
1323 \n\
1324 #endif /* insn-modes.h */");
1325 }
1326
1327 static void
1328 emit_insn_modes_inline_h (void)
1329 {
1330   printf ("/* Generated automatically from machmode.def%s%s\n",
1331            HAVE_EXTRA_MODES ? " and " : "",
1332            EXTRA_MODES_FILE);
1333
1334   puts ("\
1335    by genmodes.  */\n\
1336 \n\
1337 #ifndef GCC_INSN_MODES_INLINE_H\n\
1338 #define GCC_INSN_MODES_INLINE_H");
1339
1340   puts ("\n#if !defined (USED_FOR_TARGET) && GCC_VERSION >= 4001\n");
1341   emit_mode_size_inline ();
1342   emit_mode_nunits_inline ();
1343   emit_mode_inner_inline ();
1344   emit_mode_unit_size_inline ();
1345   emit_mode_unit_precision_inline ();
1346   puts ("#endif /* GCC_VERSION >= 4001 */");
1347
1348   puts ("\
1349 \n\
1350 #endif /* insn-modes-inline.h */");
1351 }
1352
1353 static void
1354 emit_insn_modes_c_header (void)
1355 {
1356   printf ("/* Generated automatically from machmode.def%s%s\n",
1357            HAVE_EXTRA_MODES ? " and " : "",
1358            EXTRA_MODES_FILE);
1359
1360   puts ("\
1361    by genmodes.  */\n\
1362 \n\
1363 #include \"config.h\"\n\
1364 #include \"system.h\"\n\
1365 #include \"coretypes.h\"\n\
1366 #include \"tm.h\"\n\
1367 #include \"real.h\"");
1368 }
1369
1370 static void
1371 emit_min_insn_modes_c_header (void)
1372 {
1373   printf ("/* Generated automatically from machmode.def%s%s\n",
1374            HAVE_EXTRA_MODES ? " and " : "",
1375            EXTRA_MODES_FILE);
1376
1377   puts ("\
1378    by genmodes.  */\n\
1379 \n\
1380 #include \"bconfig.h\"\n\
1381 #include \"system.h\"\n\
1382 #include \"coretypes.h\"");
1383 }
1384
1385 static void
1386 emit_mode_name (void)
1387 {
1388   int c;
1389   struct mode_data *m;
1390
1391   print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
1392
1393   for_all_modes (c, m)
1394     printf ("  \"%s\",\n", m->name);
1395
1396   print_closer ();
1397 }
1398
1399 static void
1400 emit_mode_class (void)
1401 {
1402   int c;
1403   struct mode_data *m;
1404
1405   print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
1406
1407   for_all_modes (c, m)
1408     tagged_printf ("%s", mode_class_names[m->cl], m->name);
1409
1410   print_closer ();
1411 }
1412
1413 static void
1414 emit_mode_precision (void)
1415 {
1416   int c;
1417   struct mode_data *m;
1418
1419   print_maybe_const_decl ("%spoly_uint16_pod", "mode_precision",
1420                           "NUM_MACHINE_MODES", adj_nunits);
1421
1422   for_all_modes (c, m)
1423     if (m->precision != (unsigned int)-1)
1424       tagged_printf ("{ %u" ZERO_COEFFS " }", m->precision, m->name);
1425     else
1426       tagged_printf ("{ %u * BITS_PER_UNIT" ZERO_COEFFS " }",
1427                      m->bytesize, m->name);
1428
1429   print_closer ();
1430 }
1431
1432 static void
1433 emit_mode_size (void)
1434 {
1435   int c;
1436   struct mode_data *m;
1437
1438   print_maybe_const_decl ("%spoly_uint16_pod", "mode_size",
1439                           "NUM_MACHINE_MODES", adj_nunits || adj_bytesize);
1440
1441   for_all_modes (c, m)
1442     tagged_printf ("{ %u" ZERO_COEFFS " }", m->bytesize, m->name);
1443
1444   print_closer ();
1445 }
1446
1447 static void
1448 emit_mode_nunits (void)
1449 {
1450   int c;
1451   struct mode_data *m;
1452
1453   print_maybe_const_decl ("%spoly_uint16_pod", "mode_nunits",
1454                           "NUM_MACHINE_MODES", adj_nunits);
1455
1456   for_all_modes (c, m)
1457     tagged_printf ("{ %u" ZERO_COEFFS " }", m->ncomponents, m->name);
1458
1459   print_closer ();
1460 }
1461
1462 static void
1463 emit_mode_wider (void)
1464 {
1465   int c;
1466   struct mode_data *m;
1467
1468   print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
1469
1470   for_all_modes (c, m)
1471     tagged_printf ("E_%smode",
1472                    m->wider ? m->wider->name : void_mode->name,
1473                    m->name);
1474
1475   print_closer ();
1476   print_decl ("unsigned char", "mode_2xwider", "NUM_MACHINE_MODES");
1477
1478   for_all_modes (c, m)
1479     {
1480       struct mode_data * m2;
1481
1482       for (m2 = m;
1483            m2 && m2 != void_mode;
1484            m2 = m2->wider)
1485         {
1486           if (m2->bytesize < 2 * m->bytesize)
1487             continue;
1488           if (m->precision != (unsigned int) -1)
1489             {
1490               if (m2->precision != 2 * m->precision)
1491                 continue;
1492             }
1493           else
1494             {
1495               if (m2->precision != (unsigned int) -1)
1496                 continue;
1497             }
1498
1499           /* For vectors we want twice the number of components,
1500              with the same element type.  */
1501           if (m->cl == MODE_VECTOR_BOOL
1502               || m->cl == MODE_VECTOR_INT
1503               || m->cl == MODE_VECTOR_FLOAT
1504               || m->cl == MODE_VECTOR_FRACT
1505               || m->cl == MODE_VECTOR_UFRACT
1506               || m->cl == MODE_VECTOR_ACCUM
1507               || m->cl == MODE_VECTOR_UACCUM)
1508             {
1509               if (m2->ncomponents != 2 * m->ncomponents)
1510                 continue;
1511               if (m->component != m2->component)
1512                 continue;
1513             }
1514
1515           break;
1516         }
1517       if (m2 == void_mode)
1518         m2 = 0;
1519       tagged_printf ("E_%smode",
1520                      m2 ? m2->name : void_mode->name,
1521                      m->name);
1522     }
1523
1524   print_closer ();
1525 }
1526
1527 static void
1528 emit_mode_complex (void)
1529 {
1530   int c;
1531   struct mode_data *m;
1532
1533   print_decl ("unsigned char", "mode_complex", "NUM_MACHINE_MODES");
1534
1535   for_all_modes (c, m)
1536     tagged_printf ("E_%smode",
1537                    m->complex ? m->complex->name : void_mode->name,
1538                    m->name);
1539
1540   print_closer ();
1541 }
1542
1543 static void
1544 emit_mode_mask (void)
1545 {
1546   int c;
1547   struct mode_data *m;
1548
1549   print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
1550               "NUM_MACHINE_MODES");
1551   puts ("\
1552 #define MODE_MASK(m)                          \\\n\
1553   ((m) >= HOST_BITS_PER_WIDE_INT)             \\\n\
1554    ? HOST_WIDE_INT_M1U                        \\\n\
1555    : (HOST_WIDE_INT_1U << (m)) - 1\n");
1556
1557   for_all_modes (c, m)
1558     if (m->precision != (unsigned int)-1)
1559       tagged_printf ("MODE_MASK (%u)", m->precision, m->name);
1560     else
1561       tagged_printf ("MODE_MASK (%u*BITS_PER_UNIT)", m->bytesize, m->name);
1562
1563   puts ("#undef MODE_MASK");
1564   print_closer ();
1565 }
1566
1567 static void
1568 emit_mode_inner (void)
1569 {
1570   int c;
1571   struct mode_data *m;
1572
1573   print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
1574
1575   for_all_modes (c, m)
1576     tagged_printf ("E_%smode",
1577                    c != MODE_PARTIAL_INT && m->component
1578                    ? m->component->name : m->name,
1579                    m->name);
1580
1581   print_closer ();
1582 }
1583
1584 /* Emit mode_unit_size array into insn-modes.c file.  */
1585 static void
1586 emit_mode_unit_size (void)
1587 {
1588   int c;
1589   struct mode_data *m;
1590
1591   print_maybe_const_decl ("%sunsigned char", "mode_unit_size",
1592                           "NUM_MACHINE_MODES", adj_bytesize);
1593
1594   for_all_modes (c, m)
1595     tagged_printf ("%u",
1596                    c != MODE_PARTIAL_INT && m->component
1597                    ? m->component->bytesize : m->bytesize, m->name);
1598
1599   print_closer ();
1600 }
1601
1602 /* Emit mode_unit_precision array into insn-modes.c file.  */
1603 static void
1604 emit_mode_unit_precision (void)
1605 {
1606   int c;
1607   struct mode_data *m;
1608
1609   print_decl ("unsigned short", "mode_unit_precision", "NUM_MACHINE_MODES");
1610
1611   for_all_modes (c, m)
1612     {
1613       struct mode_data *m2 = (c != MODE_PARTIAL_INT && m->component) ?
1614                              m->component : m;
1615       if (m2->precision != (unsigned int)-1)
1616         tagged_printf ("%u", m2->precision, m->name);
1617       else
1618         tagged_printf ("%u*BITS_PER_UNIT", m2->bytesize, m->name);
1619     }
1620
1621   print_closer ();
1622 }
1623
1624
1625 static void
1626 emit_mode_base_align (void)
1627 {
1628   int c;
1629   struct mode_data *m;
1630
1631   print_maybe_const_decl ("%sunsigned short",
1632                           "mode_base_align", "NUM_MACHINE_MODES",
1633                           adj_alignment);
1634
1635   for_all_modes (c, m)
1636     tagged_printf ("%u", m->alignment, m->name);
1637
1638   print_closer ();
1639 }
1640
1641 static void
1642 emit_class_narrowest_mode (void)
1643 {
1644   int c;
1645
1646   print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
1647
1648   for (c = 0; c < MAX_MODE_CLASS; c++)
1649     /* Bleah, all this to get the comment right for MIN_MODE_INT.  */
1650     tagged_printf ("MIN_%s", mode_class_names[c],
1651                    modes[c]
1652                    ? ((c != MODE_INT || modes[c]->precision != 1)
1653                       ? modes[c]->name
1654                       : (modes[c]->next
1655                          ? modes[c]->next->name
1656                          : void_mode->name))
1657                    : void_mode->name);
1658
1659   print_closer ();
1660 }
1661
1662 static void
1663 emit_real_format_for_mode (void)
1664 {
1665   struct mode_data *m;
1666
1667   /* The entities pointed to by this table are constant, whether
1668      or not the table itself is constant.
1669
1670      For backward compatibility this table is always writable
1671      (several targets modify it in TARGET_OPTION_OVERRIDE).   FIXME:
1672      convert all said targets to use ADJUST_FORMAT instead.  */
1673 #if 0
1674   print_maybe_const_decl ("const struct real_format *%s",
1675                           "real_format_for_mode",
1676                           "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1",
1677                           format);
1678 #else
1679   print_decl ("struct real_format *\n", "real_format_for_mode",
1680               "MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 "
1681               "+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1");
1682 #endif
1683
1684   /* The beginning of the table is entries for float modes.  */
1685   for (m = modes[MODE_FLOAT]; m; m = m->next)
1686     if (!strcmp (m->format, "0"))
1687       tagged_printf ("%s", m->format, m->name);
1688     else
1689       tagged_printf ("&%s", m->format, m->name);
1690
1691   /* The end of the table is entries for decimal float modes.  */
1692   for (m = modes[MODE_DECIMAL_FLOAT]; m; m = m->next)
1693     if (!strcmp (m->format, "0"))
1694       tagged_printf ("%s", m->format, m->name);
1695     else
1696       tagged_printf ("&%s", m->format, m->name);
1697
1698   print_closer ();
1699 }
1700
1701 static void
1702 emit_mode_adjustments (void)
1703 {
1704   struct mode_adjust *a;
1705   struct mode_data *m;
1706
1707   puts ("\
1708 \nvoid\
1709 \ninit_adjust_machine_modes (void)\
1710 \n{\
1711 \n  poly_uint16 ps ATTRIBUTE_UNUSED;\n\
1712   size_t s ATTRIBUTE_UNUSED;");
1713
1714   for (a = adj_nunits; a; a = a->next)
1715     {
1716       m = a->mode;
1717       printf ("\n"
1718               "  {\n"
1719               "    /* %s:%d */\n  ps = %s;\n",
1720               a->file, a->line, a->adjustment);
1721       printf ("    int old_factor = vector_element_size"
1722               " (mode_precision[E_%smode], mode_nunits[E_%smode]);\n",
1723               m->name, m->name);
1724       printf ("    mode_precision[E_%smode] = ps * old_factor;\n",  m->name);
1725       printf ("    mode_size[E_%smode] = exact_div (mode_precision[E_%smode],"
1726               " BITS_PER_UNIT);\n", m->name, m->name);
1727       printf ("    mode_nunits[E_%smode] = ps;\n", m->name);
1728       printf ("  }\n");
1729     }
1730
1731   /* Size adjustments must be propagated to all containing modes.
1732      A size adjustment forces us to recalculate the alignment too.  */
1733   for (a = adj_bytesize; a; a = a->next)
1734     {
1735       printf ("\n  /* %s:%d */\n", a->file, a->line);
1736       switch (a->mode->cl)
1737         {
1738         case MODE_VECTOR_BOOL:
1739         case MODE_VECTOR_INT:
1740         case MODE_VECTOR_FLOAT:
1741         case MODE_VECTOR_FRACT:
1742         case MODE_VECTOR_UFRACT:
1743         case MODE_VECTOR_ACCUM:
1744         case MODE_VECTOR_UACCUM:
1745           printf ("  ps = %s;\n", a->adjustment);
1746           printf ("  s = mode_unit_size[E_%smode];\n", a->mode->name);
1747           break;
1748
1749         default:
1750           printf ("  ps = s = %s;\n", a->adjustment);
1751           printf ("  mode_unit_size[E_%smode] = s;\n", a->mode->name);
1752           break;
1753         }
1754       printf ("  mode_size[E_%smode] = ps;\n", a->mode->name);
1755       printf ("  mode_base_align[E_%smode] = known_alignment (ps);\n",
1756               a->mode->name);
1757
1758       for (m = a->mode->contained; m; m = m->next_cont)
1759         {
1760           switch (m->cl)
1761             {
1762             case MODE_COMPLEX_INT:
1763             case MODE_COMPLEX_FLOAT:
1764               printf ("  mode_size[E_%smode] = 2*s;\n", m->name);
1765               printf ("  mode_unit_size[E_%smode] = s;\n", m->name);
1766               printf ("  mode_base_align[E_%smode] = s & (~s + 1);\n",
1767                       m->name);
1768               break;
1769
1770             case MODE_VECTOR_BOOL:
1771               /* Changes to BImode should not affect vector booleans.  */
1772               break;
1773
1774             case MODE_VECTOR_INT:
1775             case MODE_VECTOR_FLOAT:
1776             case MODE_VECTOR_FRACT:
1777             case MODE_VECTOR_UFRACT:
1778             case MODE_VECTOR_ACCUM:
1779             case MODE_VECTOR_UACCUM:
1780               printf ("  mode_size[E_%smode] = %d * ps;\n",
1781                       m->name, m->ncomponents);
1782               printf ("  mode_unit_size[E_%smode] = s;\n", m->name);
1783               printf ("  mode_base_align[E_%smode]"
1784                       " = known_alignment (%d * ps);\n",
1785                       m->name, m->ncomponents);
1786               break;
1787
1788             default:
1789               internal_error (
1790               "mode %s is neither vector nor complex but contains %s",
1791               m->name, a->mode->name);
1792               /* NOTREACHED */
1793             }
1794         }
1795     }
1796
1797   /* Alignment adjustments propagate too.
1798      ??? This may not be the right thing for vector modes.  */
1799   for (a = adj_alignment; a; a = a->next)
1800     {
1801       printf ("\n  /* %s:%d */\n  s = %s;\n",
1802               a->file, a->line, a->adjustment);
1803       printf ("  mode_base_align[E_%smode] = s;\n", a->mode->name);
1804
1805       for (m = a->mode->contained; m; m = m->next_cont)
1806         {
1807           switch (m->cl)
1808             {
1809             case MODE_COMPLEX_INT:
1810             case MODE_COMPLEX_FLOAT:
1811               printf ("  mode_base_align[E_%smode] = s;\n", m->name);
1812               break;
1813
1814             case MODE_VECTOR_BOOL:
1815               /* Changes to BImode should not affect vector booleans.  */
1816               break;
1817
1818             case MODE_VECTOR_INT:
1819             case MODE_VECTOR_FLOAT:
1820             case MODE_VECTOR_FRACT:
1821             case MODE_VECTOR_UFRACT:
1822             case MODE_VECTOR_ACCUM:
1823             case MODE_VECTOR_UACCUM:
1824               printf ("  mode_base_align[E_%smode] = %d*s;\n",
1825                       m->name, m->ncomponents);
1826               break;
1827
1828             default:
1829               internal_error (
1830               "mode %s is neither vector nor complex but contains %s",
1831               m->name, a->mode->name);
1832               /* NOTREACHED */
1833             }
1834         }
1835     }
1836
1837   /* Ibit adjustments don't have to propagate.  */
1838   for (a = adj_ibit; a; a = a->next)
1839     {
1840       printf ("\n  /* %s:%d */\n  s = %s;\n",
1841               a->file, a->line, a->adjustment);
1842       printf ("  mode_ibit[E_%smode] = s;\n", a->mode->name);
1843     }
1844
1845   /* Fbit adjustments don't have to propagate.  */
1846   for (a = adj_fbit; a; a = a->next)
1847     {
1848       printf ("\n  /* %s:%d */\n  s = %s;\n",
1849               a->file, a->line, a->adjustment);
1850       printf ("  mode_fbit[E_%smode] = s;\n", a->mode->name);
1851     }
1852
1853   /* Real mode formats don't have to propagate anywhere.  */
1854   for (a = adj_format; a; a = a->next)
1855     printf ("\n  /* %s:%d */\n  REAL_MODE_FORMAT (E_%smode) = %s;\n",
1856             a->file, a->line, a->mode->name, a->adjustment);
1857
1858   puts ("}");
1859 }
1860
1861 /* Emit ibit for all modes.  */
1862
1863 static void
1864 emit_mode_ibit (void)
1865 {
1866   int c;
1867   struct mode_data *m;
1868
1869   print_maybe_const_decl ("%sunsigned char",
1870                           "mode_ibit", "NUM_MACHINE_MODES",
1871                           adj_ibit);
1872
1873   for_all_modes (c, m)
1874     tagged_printf ("%u", m->ibit, m->name);
1875
1876   print_closer ();
1877 }
1878
1879 /* Emit fbit for all modes.  */
1880
1881 static void
1882 emit_mode_fbit (void)
1883 {
1884   int c;
1885   struct mode_data *m;
1886
1887   print_maybe_const_decl ("%sunsigned char",
1888                           "mode_fbit", "NUM_MACHINE_MODES",
1889                           adj_fbit);
1890
1891   for_all_modes (c, m)
1892     tagged_printf ("%u", m->fbit, m->name);
1893
1894   print_closer ();
1895 }
1896
1897 /* Emit __intN for all modes.  */
1898
1899 static void
1900 emit_mode_int_n (void)
1901 {
1902   int c;
1903   struct mode_data *m;
1904   struct mode_data **mode_sort;
1905   int n_modes = 0;
1906   int i, j;
1907
1908   print_decl ("int_n_data_t", "int_n_data", "");
1909
1910   n_modes = 0;
1911   for_all_modes (c, m)
1912     if (m->int_n)
1913       n_modes ++;
1914   mode_sort = XALLOCAVEC (struct mode_data *, n_modes);
1915
1916   n_modes = 0;
1917   for_all_modes (c, m)
1918     if (m->int_n)
1919       mode_sort[n_modes++] = m;
1920
1921   /* Yes, this is a bubblesort, but there are at most four (and
1922      usually only 1-2) entries to sort.  */
1923   for (i = 0; i<n_modes - 1; i++)
1924     for (j = i + 1; j < n_modes; j++)
1925       if (mode_sort[i]->int_n > mode_sort[j]->int_n)
1926         std::swap (mode_sort[i], mode_sort[j]);
1927
1928   for (i = 0; i < n_modes; i ++)
1929     {
1930       m = mode_sort[i];
1931       printf(" {\n");
1932       tagged_printf ("%u", m->int_n, m->name);
1933       printf ("{ E_%smode },", m->name);
1934       printf(" },\n");
1935     }
1936
1937   print_closer ();
1938 }
1939
1940
1941 static void
1942 emit_insn_modes_c (void)
1943 {
1944   emit_insn_modes_c_header ();
1945   emit_mode_name ();
1946   emit_mode_class ();
1947   emit_mode_precision ();
1948   emit_mode_size ();
1949   emit_mode_nunits ();
1950   emit_mode_wider ();
1951   emit_mode_complex ();
1952   emit_mode_mask ();
1953   emit_mode_inner ();
1954   emit_mode_unit_size ();
1955   emit_mode_unit_precision ();
1956   emit_mode_base_align ();
1957   emit_class_narrowest_mode ();
1958   emit_real_format_for_mode ();
1959   emit_mode_adjustments ();
1960   emit_mode_ibit ();
1961   emit_mode_fbit ();
1962   emit_mode_int_n ();
1963 }
1964
1965 static void
1966 emit_min_insn_modes_c (void)
1967 {
1968   emit_min_insn_modes_c_header ();
1969   emit_mode_name ();
1970   emit_mode_class ();
1971   emit_mode_nunits ();
1972   emit_mode_wider ();
1973   emit_mode_inner ();
1974   emit_class_narrowest_mode ();
1975 }
1976
1977 /* Master control.  */
1978 int
1979 main (int argc, char **argv)
1980 {
1981   bool gen_header = false, gen_inlines = false, gen_min = false;
1982   progname = argv[0];
1983
1984   if (argc == 1)
1985     ;
1986   else if (argc == 2 && !strcmp (argv[1], "-h"))
1987     gen_header = true;
1988   else if (argc == 2 && !strcmp (argv[1], "-i"))
1989     gen_inlines = true;
1990   else if (argc == 2 && !strcmp (argv[1], "-m"))
1991     gen_min = true;
1992   else
1993     {
1994       error ("usage: %s [-h|-i|-m] > file", progname);
1995       return FATAL_EXIT_CODE;
1996     }
1997
1998   modes_by_name = htab_create_alloc (64, hash_mode, eq_mode, 0, xcalloc, free);
1999
2000   create_modes ();
2001   complete_all_modes ();
2002
2003   if (have_error)
2004     return FATAL_EXIT_CODE;
2005
2006   calc_wider_mode ();
2007
2008   if (gen_header)
2009     emit_insn_modes_h ();
2010   else if (gen_inlines)
2011     emit_insn_modes_inline_h ();
2012   else if (gen_min)
2013     emit_min_insn_modes_c ();
2014   else
2015     emit_insn_modes_c ();
2016
2017   if (fflush (stdout) || fclose (stdout))
2018     return FATAL_EXIT_CODE;
2019   return SUCCESS_EXIT_CODE;
2020 }