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