1 /* Process source files and output type information. 2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 3 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #ifdef GENERATOR_FILE 22 #include "bconfig.h" 23 #else 24 #include "config.h" 25 #endif 26 #include "system.h" 27 #include "errors.h" /* for fatal */ 28 #include "getopt.h" 29 #include "double-int.h" 30 #include "version.h" /* for version_string & pkgversion_string. */ 31 #include "hashtab.h" 32 #include "xregex.h" 33 #include "obstack.h" 34 #include "gengtype.h" 35 #include "filenames.h" 36 37 /* Data types, macros, etc. used only in this file. */ 38 39 40 /* The list of output files. */ 41 outf_p output_files; 42 43 /* The output header file that is included into pretty much every 44 source file. */ 45 outf_p header_file; 46 47 48 /* The name of the file containing the list of input files. */ 49 static char *inputlist; 50 51 /* The plugin input files and their number; in that case only 52 a single file is produced. */ 53 static input_file **plugin_files; 54 static size_t nb_plugin_files; 55 56 /* The generated plugin output file and name. */ 57 static outf_p plugin_output; 58 static char *plugin_output_filename; 59 60 /* Our source directory and its length. */ 61 const char *srcdir; 62 size_t srcdir_len; 63 64 /* Variables used for reading and writing the state. */ 65 const char *read_state_filename; 66 const char *write_state_filename; 67 68 /* Variables to help debugging. */ 69 int do_dump; 70 int do_debug; 71 72 /* Level for verbose messages. */ 73 int verbosity_level; 74 75 /* We have a type count and use it to set the state_number of newly 76 allocated types to some unique negative number. */ 77 static int type_count; 78 79 /* The backup directory should be in the same file system as the 80 generated files, otherwise the rename(2) system call would fail. 81 If NULL, no backup is made when overwriting a generated file. */ 82 static const char* backup_dir; /* (-B) program option. */ 83 84 85 static outf_p create_file (const char *, const char *); 86 87 static const char *get_file_basename (const input_file *); 88 static const char *get_file_realbasename (const input_file *); 89 90 static int get_prefix_langdir_index (const char *); 91 static const char *get_file_langdir (const input_file *); 92 93 94 /* Nonzero iff an error has occurred. */ 95 bool hit_error = false; 96 97 static void gen_rtx_next (void); 98 static void write_rtx_next (void); 99 static void open_base_files (void); 100 static void close_output_files (void); 101 102 /* Report an error at POS, printing MSG. */ 103 104 void 105 error_at_line (const struct fileloc *pos, const char *msg, ...) 106 { 107 va_list ap; 108 109 gcc_assert (pos != NULL && pos->file != NULL); 110 va_start (ap, msg); 111 112 fprintf (stderr, "%s:%d: ", get_input_file_name (pos->file), pos->line); 113 vfprintf (stderr, msg, ap); 114 fputc ('\n', stderr); 115 hit_error = true; 116 117 va_end (ap); 118 } 119 120 /* asprintf, but produces fatal message on out-of-memory. */ 121 char * 122 xasprintf (const char *format, ...) 123 { 124 int n; 125 char *result; 126 va_list ap; 127 128 va_start (ap, format); 129 n = vasprintf (&result, format, ap); 130 if (result == NULL || n < 0) 131 fatal ("out of memory"); 132 va_end (ap); 133 134 return result; 135 } 136 137 /* Input file handling. */ 138 139 /* Table of all input files. */ 140 const input_file **gt_files; 141 size_t num_gt_files; 142 143 /* A number of places use the name of this "gengtype.c" file for a 144 location for things that we can't rely on the source to define. 145 Make sure we can still use pointer comparison on filenames. */ 146 input_file* this_file; 147 /* The "system.h" file is likewise specially useful. */ 148 input_file* system_h_file; 149 150 /* Vector of per-language directories. */ 151 const char **lang_dir_names; 152 size_t num_lang_dirs; 153 154 /* An array of output files suitable for definitions. There is one 155 BASE_FILES entry for each language. */ 156 static outf_p *base_files; 157 158 159 160 #if ENABLE_CHECKING 161 /* Utility debugging function, printing the various type counts within 162 a list of types. Called thru the DBGPRINT_COUNT_TYPE macro. */ 163 void 164 dbgprint_count_type_at (const char *fil, int lin, const char *msg, type_p t) 165 { 166 int nb_types = 0, nb_scalar = 0, nb_string = 0; 167 int nb_struct = 0, nb_union = 0, nb_array = 0, nb_pointer = 0; 168 int nb_lang_struct = 0, nb_param_struct = 0; 169 type_p p = NULL; 170 for (p = t; p; p = p->next) 171 { 172 nb_types++; 173 switch (p->kind) 174 { 175 case TYPE_SCALAR: 176 nb_scalar++; 177 break; 178 case TYPE_STRING: 179 nb_string++; 180 break; 181 case TYPE_STRUCT: 182 nb_struct++; 183 break; 184 case TYPE_UNION: 185 nb_union++; 186 break; 187 case TYPE_POINTER: 188 nb_pointer++; 189 break; 190 case TYPE_ARRAY: 191 nb_array++; 192 break; 193 case TYPE_LANG_STRUCT: 194 nb_lang_struct++; 195 break; 196 case TYPE_PARAM_STRUCT: 197 nb_param_struct++; 198 break; 199 default: 200 gcc_unreachable (); 201 } 202 } 203 fprintf (stderr, "\n" "%s:%d: %s: @@%%@@ %d types ::\n", 204 lbasename (fil), lin, msg, nb_types); 205 if (nb_scalar > 0 || nb_string > 0) 206 fprintf (stderr, "@@%%@@ %d scalars, %d strings\n", nb_scalar, nb_string); 207 if (nb_struct > 0 || nb_union > 0) 208 fprintf (stderr, "@@%%@@ %d structs, %d unions\n", nb_struct, nb_union); 209 if (nb_pointer > 0 || nb_array > 0) 210 fprintf (stderr, "@@%%@@ %d pointers, %d arrays\n", nb_pointer, nb_array); 211 if (nb_lang_struct > 0 || nb_param_struct > 0) 212 fprintf (stderr, "@@%%@@ %d lang_structs, %d param_structs\n", 213 nb_lang_struct, nb_param_struct); 214 fprintf (stderr, "\n"); 215 } 216 #endif /* ENABLE_CHECKING */ 217 218 /* Scan the input file, LIST, and determine how much space we need to 219 store strings in. Also, count the number of language directories 220 and files. The numbers returned are overestimates as they does not 221 consider repeated files. */ 222 static size_t 223 measure_input_list (FILE *list) 224 { 225 size_t n = 0; 226 int c; 227 bool atbol = true; 228 num_lang_dirs = 0; 229 num_gt_files = plugin_files ? nb_plugin_files : 0; 230 while ((c = getc (list)) != EOF) 231 { 232 n++; 233 if (atbol) 234 { 235 if (c == '[') 236 num_lang_dirs++; 237 else 238 { 239 /* Add space for a lang_bitmap before the input file name. */ 240 n += sizeof (lang_bitmap); 241 num_gt_files++; 242 } 243 atbol = false; 244 } 245 246 if (c == '\n') 247 atbol = true; 248 } 249 250 rewind (list); 251 return n; 252 } 253 254 /* Read one input line from LIST to HEREP (which is updated). A 255 pointer to the string is returned via LINEP. If it was a language 256 subdirectory in square brackets, strip off the square brackets and 257 return true. Otherwise, leave space before the string for a 258 lang_bitmap, and return false. At EOF, returns false, does not 259 touch *HEREP, and sets *LINEP to NULL. POS is used for 260 diagnostics. */ 261 static bool 262 read_input_line (FILE *list, char **herep, char **linep, struct fileloc *pos) 263 { 264 char *here = *herep; 265 char *line; 266 int c = getc (list); 267 268 /* Read over whitespace. */ 269 while (c == '\n' || c == ' ') 270 c = getc (list); 271 272 if (c == EOF) 273 { 274 *linep = 0; 275 return false; 276 } 277 else if (c == '[') 278 { 279 /* No space for a lang_bitmap is necessary. Discard the '['. */ 280 c = getc (list); 281 line = here; 282 while (c != ']' && c != '\n' && c != EOF) 283 { 284 *here++ = c; 285 c = getc (list); 286 } 287 *here++ = '\0'; 288 289 if (c == ']') 290 { 291 c = getc (list); /* eat what should be a newline */ 292 if (c != '\n' && c != EOF) 293 error_at_line (pos, "junk on line after language tag [%s]", line); 294 } 295 else 296 error_at_line (pos, "missing close bracket for language tag [%s", 297 line); 298 299 *herep = here; 300 *linep = line; 301 return true; 302 } 303 else 304 { 305 /* Leave space for a lang_bitmap. */ 306 memset (here, 0, sizeof (lang_bitmap)); 307 here += sizeof (lang_bitmap); 308 line = here; 309 do 310 { 311 *here++ = c; 312 c = getc (list); 313 } 314 while (c != EOF && c != '\n'); 315 *here++ = '\0'; 316 *herep = here; 317 *linep = line; 318 return false; 319 } 320 } 321 322 /* Read the list of input files from LIST and compute all of the 323 relevant tables. There is one file per line of the list. At 324 first, all the files on the list are language-generic, but 325 eventually a line will appear which is the name of a language 326 subdirectory in square brackets, like this: [cp]. All subsequent 327 files are specific to that language, until another language 328 subdirectory tag appears. Files can appear more than once, if 329 they apply to more than one language. */ 330 static void 331 read_input_list (const char *listname) 332 { 333 FILE *list = fopen (listname, "r"); 334 if (!list) 335 fatal ("cannot open %s: %s", listname, xstrerror (errno)); 336 else 337 { 338 struct fileloc epos; 339 size_t bufsz = measure_input_list (list); 340 char *buf = XNEWVEC (char, bufsz); 341 char *here = buf; 342 char *committed = buf; 343 char *limit = buf + bufsz; 344 char *line; 345 bool is_language; 346 size_t langno = 0; 347 size_t nfiles = 0; 348 lang_bitmap curlangs = (1 << num_lang_dirs) - 1; 349 350 epos.file = input_file_by_name (listname); 351 epos.line = 0; 352 353 lang_dir_names = XNEWVEC (const char *, num_lang_dirs); 354 gt_files = XNEWVEC (const input_file *, num_gt_files); 355 356 for (;;) 357 { 358 next_line: 359 epos.line++; 360 committed = here; 361 is_language = read_input_line (list, &here, &line, &epos); 362 gcc_assert (here <= limit); 363 if (line == 0) 364 break; 365 else if (is_language) 366 { 367 size_t i; 368 gcc_assert (langno <= num_lang_dirs); 369 for (i = 0; i < langno; i++) 370 if (strcmp (lang_dir_names[i], line) == 0) 371 { 372 error_at_line (&epos, "duplicate language tag [%s]", 373 line); 374 curlangs = 1 << i; 375 here = committed; 376 goto next_line; 377 } 378 379 curlangs = 1 << langno; 380 lang_dir_names[langno++] = line; 381 } 382 else 383 { 384 size_t i; 385 input_file *inpf = input_file_by_name (line); 386 gcc_assert (nfiles <= num_gt_files); 387 for (i = 0; i < nfiles; i++) 388 /* Since the input_file-s are uniquely hash-consed, we 389 can just compare pointers! */ 390 if (gt_files[i] == inpf) 391 { 392 /* Throw away the string we just read, and add the 393 current language to the existing string's bitmap. */ 394 lang_bitmap bmap = get_lang_bitmap (inpf); 395 if (bmap & curlangs) 396 error_at_line (&epos, 397 "file %s specified more than once " 398 "for language %s", line, 399 langno == 400 0 ? "(all)" : lang_dir_names[langno - 401 1]); 402 403 bmap |= curlangs; 404 set_lang_bitmap (inpf, bmap); 405 here = committed; 406 goto next_line; 407 } 408 409 set_lang_bitmap (inpf, curlangs); 410 gt_files[nfiles++] = inpf; 411 } 412 } 413 /* Update the global counts now that we know accurately how many 414 things there are. (We do not bother resizing the arrays down.) */ 415 num_lang_dirs = langno; 416 /* Add the plugin files if provided. */ 417 if (plugin_files) 418 { 419 size_t i; 420 for (i = 0; i < nb_plugin_files; i++) 421 gt_files[nfiles++] = plugin_files[i]; 422 } 423 num_gt_files = nfiles; 424 } 425 426 /* Sanity check: any file that resides in a language subdirectory 427 (e.g. 'cp') ought to belong to the corresponding language. 428 ??? Still true if for instance ObjC++ is enabled and C++ isn't? 429 (Can you even do that? Should you be allowed to?) */ 430 { 431 size_t f; 432 for (f = 0; f < num_gt_files; f++) 433 { 434 lang_bitmap bitmap = get_lang_bitmap (gt_files[f]); 435 const char *basename = get_file_basename (gt_files[f]); 436 const char *slashpos = strchr (basename, '/'); 437 #ifdef HAVE_DOS_BASED_FILE_SYSTEM 438 const char *slashpos2 = strchr (basename, '\\'); 439 440 if (!slashpos || (slashpos2 && slashpos2 < slashpos)) 441 slashpos = slashpos2; 442 #endif 443 444 if (slashpos) 445 { 446 size_t l; 447 for (l = 0; l < num_lang_dirs; l++) 448 if ((size_t) (slashpos - basename) == strlen (lang_dir_names[l]) 449 && memcmp (basename, lang_dir_names[l], 450 strlen (lang_dir_names[l])) == 0) 451 { 452 if (!(bitmap & (1 << l))) 453 error ("%s is in language directory '%s' but is not " 454 "tagged for that language", 455 basename, lang_dir_names[l]); 456 break; 457 } 458 } 459 } 460 } 461 462 if (ferror (list)) 463 fatal ("error reading %s: %s", listname, xstrerror (errno)); 464 465 fclose (list); 466 } 467 468 469 470 /* The one and only TYPE_STRING. */ 471 472 struct type string_type = { 473 TYPE_STRING, 0, 0, 0, GC_USED, {0} 474 }; 475 476 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are 477 set early in main. */ 478 479 struct type scalar_nonchar = { 480 TYPE_SCALAR, 0, 0, 0, GC_USED, {0} 481 }; 482 483 struct type scalar_char = { 484 TYPE_SCALAR, 0, 0, 0, GC_USED, {0} 485 }; 486 487 /* Lists of various things. */ 488 489 pair_p typedefs; 490 type_p structures; 491 type_p param_structs; 492 pair_p variables; 493 494 static type_p find_param_structure (type_p t, type_p param[NUM_PARAM]); 495 static type_p adjust_field_tree_exp (type_p t, options_p opt); 496 static type_p adjust_field_rtx_def (type_p t, options_p opt); 497 498 /* Define S as a typedef to T at POS. */ 499 500 void 501 do_typedef (const char *s, type_p t, struct fileloc *pos) 502 { 503 pair_p p; 504 505 /* temporary kludge - gengtype doesn't handle conditionals or 506 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it 507 is coming from this file (main() sets them up with safe dummy 508 definitions). */ 509 if (!strcmp (s, "CUMULATIVE_ARGS") && pos->file != this_file) 510 return; 511 512 for (p = typedefs; p != NULL; p = p->next) 513 if (strcmp (p->name, s) == 0) 514 { 515 if (p->type != t) 516 { 517 error_at_line (pos, "type `%s' previously defined", s); 518 error_at_line (&p->line, "previously defined here"); 519 } 520 return; 521 } 522 523 p = XNEW (struct pair); 524 p->next = typedefs; 525 p->name = s; 526 p->type = t; 527 p->line = *pos; 528 p->opt = NULL; 529 typedefs = p; 530 } 531 532 /* Define S as a typename of a scalar. Cannot be used to define 533 typedefs of 'char'. Note: is also used for pointer-to-function 534 typedefs (which are therefore not treated as pointers). */ 535 536 void 537 do_scalar_typedef (const char *s, struct fileloc *pos) 538 { 539 do_typedef (s, &scalar_nonchar, pos); 540 } 541 542 /* Return the type previously defined for S. Use POS to report errors. */ 543 544 type_p 545 resolve_typedef (const char *s, struct fileloc *pos) 546 { 547 pair_p p; 548 for (p = typedefs; p != NULL; p = p->next) 549 if (strcmp (p->name, s) == 0) 550 return p->type; 551 error_at_line (pos, "unidentified type `%s'", s); 552 return &scalar_nonchar; /* treat as "int" */ 553 } 554 555 /* Create and return a new structure with tag NAME (or a union iff 556 ISUNION is nonzero), at POS with fields FIELDS and options O. */ 557 558 type_p 559 new_structure (const char *name, int isunion, struct fileloc *pos, 560 pair_p fields, options_p o) 561 { 562 type_p si; 563 type_p s = NULL; 564 lang_bitmap bitmap = get_lang_bitmap (pos->file); 565 566 for (si = structures; si != NULL; si = si->next) 567 if (strcmp (name, si->u.s.tag) == 0 && UNION_P (si) == isunion) 568 { 569 type_p ls = NULL; 570 if (si->kind == TYPE_LANG_STRUCT) 571 { 572 ls = si; 573 574 for (si = ls->u.s.lang_struct; si != NULL; si = si->next) 575 if (si->u.s.bitmap == bitmap) 576 s = si; 577 } 578 else if (si->u.s.line.file != NULL && si->u.s.bitmap != bitmap) 579 { 580 ls = si; 581 type_count++; 582 si = XCNEW (struct type); 583 memcpy (si, ls, sizeof (struct type)); 584 ls->kind = TYPE_LANG_STRUCT; 585 ls->u.s.lang_struct = si; 586 ls->u.s.fields = NULL; 587 si->next = NULL; 588 si->state_number = -type_count; 589 si->pointer_to = NULL; 590 si->u.s.lang_struct = ls; 591 } 592 else 593 s = si; 594 595 if (ls != NULL && s == NULL) 596 { 597 type_count++; 598 s = XCNEW (struct type); 599 s->state_number = -type_count; 600 s->next = ls->u.s.lang_struct; 601 ls->u.s.lang_struct = s; 602 s->u.s.lang_struct = ls; 603 } 604 break; 605 } 606 607 if (s == NULL) 608 { 609 type_count++; 610 s = XCNEW (struct type); 611 s->state_number = -type_count; 612 s->next = structures; 613 structures = s; 614 } 615 616 if (s->u.s.line.file != NULL 617 || (s->u.s.lang_struct && (s->u.s.lang_struct->u.s.bitmap & bitmap))) 618 { 619 error_at_line (pos, "duplicate definition of '%s %s'", 620 isunion ? "union" : "struct", s->u.s.tag); 621 error_at_line (&s->u.s.line, "previous definition here"); 622 } 623 624 s->kind = isunion ? TYPE_UNION : TYPE_STRUCT; 625 s->u.s.tag = name; 626 s->u.s.line = *pos; 627 s->u.s.fields = fields; 628 s->u.s.opt = o; 629 s->u.s.bitmap = bitmap; 630 if (s->u.s.lang_struct) 631 s->u.s.lang_struct->u.s.bitmap |= bitmap; 632 633 return s; 634 } 635 636 /* Return the previously-defined structure with tag NAME (or a union 637 iff ISUNION is nonzero), or a new empty structure or union if none 638 was defined previously. */ 639 640 type_p 641 find_structure (const char *name, int isunion) 642 { 643 type_p s; 644 645 for (s = structures; s != NULL; s = s->next) 646 if (strcmp (name, s->u.s.tag) == 0 && UNION_P (s) == isunion) 647 return s; 648 649 type_count++; 650 s = XCNEW (struct type); 651 s->next = structures; 652 s->state_number = -type_count; 653 structures = s; 654 s->kind = isunion ? TYPE_UNION : TYPE_STRUCT; 655 s->u.s.tag = name; 656 structures = s; 657 return s; 658 } 659 660 /* Return the previously-defined parameterized structure for structure 661 T and parameters PARAM, or a new parameterized empty structure or 662 union if none was defined previously. */ 663 664 static type_p 665 find_param_structure (type_p t, type_p param[NUM_PARAM]) 666 { 667 type_p res; 668 669 for (res = param_structs; res; res = res->next) 670 if (res->u.param_struct.stru == t 671 && memcmp (res->u.param_struct.param, param, 672 sizeof (type_p) * NUM_PARAM) == 0) 673 break; 674 if (res == NULL) 675 { 676 type_count++; 677 res = XCNEW (struct type); 678 res->kind = TYPE_PARAM_STRUCT; 679 res->next = param_structs; 680 res->state_number = -type_count; 681 param_structs = res; 682 res->u.param_struct.stru = t; 683 memcpy (res->u.param_struct.param, param, sizeof (type_p) * NUM_PARAM); 684 } 685 return res; 686 } 687 688 /* Return a scalar type with name NAME. */ 689 690 type_p 691 create_scalar_type (const char *name) 692 { 693 if (!strcmp (name, "char") || !strcmp (name, "unsigned char")) 694 return &scalar_char; 695 else 696 return &scalar_nonchar; 697 } 698 699 /* Return a pointer to T. */ 700 701 type_p 702 create_pointer (type_p t) 703 { 704 if (!t->pointer_to) 705 { 706 type_p r = XCNEW (struct type); 707 type_count++; 708 r->state_number = -type_count; 709 r->kind = TYPE_POINTER; 710 r->u.p = t; 711 t->pointer_to = r; 712 } 713 return t->pointer_to; 714 } 715 716 /* Return an array of length LEN. */ 717 718 type_p 719 create_array (type_p t, const char *len) 720 { 721 type_p v; 722 723 type_count++; 724 v = XCNEW (struct type); 725 v->kind = TYPE_ARRAY; 726 v->state_number = -type_count; 727 v->u.a.p = t; 728 v->u.a.len = len; 729 return v; 730 } 731 732 /* Return a string options structure with name NAME and info INFO. 733 NEXT is the next option in the chain. */ 734 options_p 735 create_string_option (options_p next, const char *name, const char *info) 736 { 737 options_p o = XNEW (struct options); 738 o->kind = OPTION_STRING; 739 o->next = next; 740 o->name = name; 741 o->info.string = info; 742 return o; 743 } 744 745 /* Create a type options structure with name NAME and info INFO. NEXT 746 is the next option in the chain. */ 747 options_p 748 create_type_option (options_p next, const char* name, type_p info) 749 { 750 options_p o = XNEW (struct options); 751 o->next = next; 752 o->name = name; 753 o->kind = OPTION_TYPE; 754 o->info.type = info; 755 return o; 756 } 757 758 /* Create a nested pointer options structure with name NAME and info 759 INFO. NEXT is the next option in the chain. */ 760 options_p 761 create_nested_option (options_p next, const char* name, 762 struct nested_ptr_data* info) 763 { 764 options_p o; 765 o = XNEW (struct options); 766 o->next = next; 767 o->name = name; 768 o->kind = OPTION_NESTED; 769 o->info.nested = info; 770 return o; 771 } 772 773 /* Return an options structure for a "nested_ptr" option. */ 774 options_p 775 create_nested_ptr_option (options_p next, type_p t, 776 const char *to, const char *from) 777 { 778 struct nested_ptr_data *d = XNEW (struct nested_ptr_data); 779 780 d->type = adjust_field_type (t, 0); 781 d->convert_to = to; 782 d->convert_from = from; 783 return create_nested_option (next, "nested_ptr", d); 784 } 785 786 /* Add a variable named S of type T with options O defined at POS, 787 to `variables'. */ 788 void 789 note_variable (const char *s, type_p t, options_p o, struct fileloc *pos) 790 { 791 pair_p n; 792 n = XNEW (struct pair); 793 n->name = s; 794 n->type = t; 795 n->line = *pos; 796 n->opt = o; 797 n->next = variables; 798 variables = n; 799 } 800 801 /* Most-general structure field creator. */ 802 static pair_p 803 create_field_all (pair_p next, type_p type, const char *name, options_p opt, 804 const input_file *inpf, int line) 805 { 806 pair_p field; 807 808 field = XNEW (struct pair); 809 field->next = next; 810 field->type = type; 811 field->name = name; 812 field->opt = opt; 813 field->line.file = inpf; 814 field->line.line = line; 815 return field; 816 } 817 818 /* Create a field that came from the source code we are scanning, 819 i.e. we have a 'struct fileloc', and possibly options; also, 820 adjust_field_type should be called. */ 821 pair_p 822 create_field_at (pair_p next, type_p type, const char *name, options_p opt, 823 struct fileloc *pos) 824 { 825 return create_field_all (next, adjust_field_type (type, opt), 826 name, opt, pos->file, pos->line); 827 } 828 829 /* Create a fake field with the given type and name. NEXT is the next 830 field in the chain. */ 831 #define create_field(next,type,name) \ 832 create_field_all(next,type,name, 0, this_file, __LINE__) 833 834 /* Like create_field, but the field is only valid when condition COND 835 is true. */ 836 837 static pair_p 838 create_optional_field_ (pair_p next, type_p type, const char *name, 839 const char *cond, int line) 840 { 841 static int id = 1; 842 pair_p union_fields; 843 type_p union_type; 844 845 /* Create a fake union type with a single nameless field of type TYPE. 846 The field has a tag of "1". This allows us to make the presence 847 of a field of type TYPE depend on some boolean "desc" being true. */ 848 union_fields = create_field (NULL, type, ""); 849 union_fields->opt = 850 create_string_option (union_fields->opt, "dot", ""); 851 union_fields->opt = 852 create_string_option (union_fields->opt, "tag", "1"); 853 union_type = 854 new_structure (xasprintf ("%s_%d", "fake_union", id++), 1, 855 &lexer_line, union_fields, NULL); 856 857 /* Create the field and give it the new fake union type. Add a "desc" 858 tag that specifies the condition under which the field is valid. */ 859 return create_field_all (next, union_type, name, 860 create_string_option (0, "desc", cond), 861 this_file, line); 862 } 863 864 #define create_optional_field(next,type,name,cond) \ 865 create_optional_field_(next,type,name,cond,__LINE__) 866 867 /* Reverse a linked list of 'struct pair's in place. */ 868 pair_p 869 nreverse_pairs (pair_p list) 870 { 871 pair_p prev = 0, p, next; 872 for (p = list; p; p = next) 873 { 874 next = p->next; 875 p->next = prev; 876 prev = p; 877 } 878 return prev; 879 } 880 881 882 /* We don't care how long a CONST_DOUBLE is. */ 883 #define CONST_DOUBLE_FORMAT "ww" 884 /* We don't want to see codes that are only for generator files. */ 885 #undef GENERATOR_FILE 886 887 enum rtx_code 888 { 889 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM , 890 #include "rtl.def" 891 #undef DEF_RTL_EXPR 892 NUM_RTX_CODE 893 }; 894 895 static const char *const rtx_name[NUM_RTX_CODE] = { 896 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME , 897 #include "rtl.def" 898 #undef DEF_RTL_EXPR 899 }; 900 901 static const char *const rtx_format[NUM_RTX_CODE] = { 902 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT , 903 #include "rtl.def" 904 #undef DEF_RTL_EXPR 905 }; 906 907 static int rtx_next_new[NUM_RTX_CODE]; 908 909 /* We also need codes and names for insn notes (not register notes). 910 Note that we do *not* bias the note values here. */ 911 enum insn_note 912 { 913 #define DEF_INSN_NOTE(NAME) NAME, 914 #include "insn-notes.def" 915 #undef DEF_INSN_NOTE 916 917 NOTE_INSN_MAX 918 }; 919 920 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the 921 default field for line number notes. */ 922 static const char *const note_insn_name[NOTE_INSN_MAX + 1] = { 923 #define DEF_INSN_NOTE(NAME) #NAME, 924 #include "insn-notes.def" 925 #undef DEF_INSN_NOTE 926 }; 927 928 #undef CONST_DOUBLE_FORMAT 929 #define GENERATOR_FILE 930 931 /* Generate the contents of the rtx_next array. This really doesn't belong 932 in gengtype at all, but it's needed for adjust_field_rtx_def. */ 933 934 static void 935 gen_rtx_next (void) 936 { 937 int i; 938 for (i = 0; i < NUM_RTX_CODE; i++) 939 { 940 int k; 941 942 rtx_next_new[i] = -1; 943 if (strncmp (rtx_format[i], "iuu", 3) == 0) 944 rtx_next_new[i] = 2; 945 else if (i == COND_EXEC || i == SET || i == EXPR_LIST || i == INSN_LIST) 946 rtx_next_new[i] = 1; 947 else 948 for (k = strlen (rtx_format[i]) - 1; k >= 0; k--) 949 if (rtx_format[i][k] == 'e' || rtx_format[i][k] == 'u') 950 rtx_next_new[i] = k; 951 } 952 } 953 954 /* Write out the contents of the rtx_next array. */ 955 static void 956 write_rtx_next (void) 957 { 958 outf_p f = get_output_file_with_visibility (NULL); 959 int i; 960 if (!f) 961 return; 962 963 oprintf (f, "\n/* Used to implement the RTX_NEXT macro. */\n"); 964 oprintf (f, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n"); 965 for (i = 0; i < NUM_RTX_CODE; i++) 966 if (rtx_next_new[i] == -1) 967 oprintf (f, " 0,\n"); 968 else 969 oprintf (f, 970 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n", rtx_next_new[i]); 971 oprintf (f, "};\n"); 972 } 973 974 /* Handle `special("rtx_def")'. This is a special case for field 975 `fld' of struct rtx_def, which is an array of unions whose values 976 are based in a complex way on the type of RTL. */ 977 978 static type_p 979 adjust_field_rtx_def (type_p t, options_p ARG_UNUSED (opt)) 980 { 981 pair_p flds = NULL; 982 options_p nodot; 983 int i; 984 type_p rtx_tp, rtvec_tp, tree_tp, mem_attrs_tp, note_union_tp, scalar_tp; 985 type_p basic_block_tp, reg_attrs_tp, constant_tp, symbol_union_tp; 986 987 if (t->kind != TYPE_UNION) 988 { 989 error_at_line (&lexer_line, 990 "special `rtx_def' must be applied to a union"); 991 return &string_type; 992 } 993 994 nodot = create_string_option (NULL, "dot", ""); 995 996 rtx_tp = create_pointer (find_structure ("rtx_def", 0)); 997 rtvec_tp = create_pointer (find_structure ("rtvec_def", 0)); 998 tree_tp = create_pointer (find_structure ("tree_node", 1)); 999 mem_attrs_tp = create_pointer (find_structure ("mem_attrs", 0)); 1000 reg_attrs_tp = 1001 create_pointer (find_structure ("reg_attrs", 0)); 1002 basic_block_tp = 1003 create_pointer (find_structure ("basic_block_def", 0)); 1004 constant_tp = 1005 create_pointer (find_structure ("constant_descriptor_rtx", 0)); 1006 scalar_tp = &scalar_nonchar; /* rtunion int */ 1007 1008 { 1009 pair_p note_flds = NULL; 1010 int c; 1011 1012 for (c = 0; c <= NOTE_INSN_MAX; c++) 1013 { 1014 switch (c) 1015 { 1016 case NOTE_INSN_MAX: 1017 case NOTE_INSN_DELETED_LABEL: 1018 case NOTE_INSN_DELETED_DEBUG_LABEL: 1019 note_flds = create_field (note_flds, &string_type, "rt_str"); 1020 break; 1021 1022 case NOTE_INSN_BLOCK_BEG: 1023 case NOTE_INSN_BLOCK_END: 1024 note_flds = create_field (note_flds, tree_tp, "rt_tree"); 1025 break; 1026 1027 case NOTE_INSN_VAR_LOCATION: 1028 case NOTE_INSN_CALL_ARG_LOCATION: 1029 note_flds = create_field (note_flds, rtx_tp, "rt_rtx"); 1030 break; 1031 1032 default: 1033 note_flds = create_field (note_flds, scalar_tp, "rt_int"); 1034 break; 1035 } 1036 /* NOTE_INSN_MAX is used as the default field for line 1037 number notes. */ 1038 if (c == NOTE_INSN_MAX) 1039 note_flds->opt = 1040 create_string_option (nodot, "default", ""); 1041 else 1042 note_flds->opt = 1043 create_string_option (nodot, "tag", note_insn_name[c]); 1044 } 1045 note_union_tp = new_structure ("rtx_def_note_subunion", 1, 1046 &lexer_line, note_flds, NULL); 1047 } 1048 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */ 1049 { 1050 pair_p sym_flds; 1051 sym_flds = create_field (NULL, tree_tp, "rt_tree"); 1052 sym_flds->opt = create_string_option (nodot, "default", ""); 1053 sym_flds = create_field (sym_flds, constant_tp, "rt_constant"); 1054 sym_flds->opt = create_string_option (nodot, "tag", "1"); 1055 symbol_union_tp = new_structure ("rtx_def_symbol_subunion", 1, 1056 &lexer_line, sym_flds, NULL); 1057 } 1058 for (i = 0; i < NUM_RTX_CODE; i++) 1059 { 1060 pair_p subfields = NULL; 1061 size_t aindex, nmindex; 1062 const char *sname; 1063 type_p substruct; 1064 char *ftag; 1065 1066 for (aindex = 0; aindex < strlen (rtx_format[i]); aindex++) 1067 { 1068 type_p t; 1069 const char *subname; 1070 1071 switch (rtx_format[i][aindex]) 1072 { 1073 case '*': 1074 case 'i': 1075 case 'n': 1076 case 'w': 1077 t = scalar_tp; 1078 subname = "rt_int"; 1079 break; 1080 1081 case '0': 1082 if (i == MEM && aindex == 1) 1083 t = mem_attrs_tp, subname = "rt_mem"; 1084 else if (i == JUMP_INSN && aindex == 8) 1085 t = rtx_tp, subname = "rt_rtx"; 1086 else if (i == CODE_LABEL && aindex == 5) 1087 t = scalar_tp, subname = "rt_int"; 1088 else if (i == CODE_LABEL && aindex == 4) 1089 t = rtx_tp, subname = "rt_rtx"; 1090 else if (i == LABEL_REF && (aindex == 1 || aindex == 2)) 1091 t = rtx_tp, subname = "rt_rtx"; 1092 else if (i == NOTE && aindex == 4) 1093 t = note_union_tp, subname = ""; 1094 else if (i == NOTE && aindex == 5) 1095 t = scalar_tp, subname = "rt_int"; 1096 else if (i == NOTE && aindex >= 7) 1097 t = scalar_tp, subname = "rt_int"; 1098 else if (i == ADDR_DIFF_VEC && aindex == 4) 1099 t = scalar_tp, subname = "rt_int"; 1100 else if (i == VALUE && aindex == 0) 1101 t = scalar_tp, subname = "rt_int"; 1102 else if (i == DEBUG_EXPR && aindex == 0) 1103 t = tree_tp, subname = "rt_tree"; 1104 else if (i == REG && aindex == 1) 1105 t = scalar_tp, subname = "rt_int"; 1106 else if (i == REG && aindex == 2) 1107 t = reg_attrs_tp, subname = "rt_reg"; 1108 else if (i == SCRATCH && aindex == 0) 1109 t = scalar_tp, subname = "rt_int"; 1110 else if (i == SYMBOL_REF && aindex == 1) 1111 t = scalar_tp, subname = "rt_int"; 1112 else if (i == SYMBOL_REF && aindex == 2) 1113 t = symbol_union_tp, subname = ""; 1114 else if (i == BARRIER && aindex >= 3) 1115 t = scalar_tp, subname = "rt_int"; 1116 else if (i == ENTRY_VALUE && aindex == 0) 1117 t = rtx_tp, subname = "rt_rtx"; 1118 else 1119 { 1120 error_at_line 1121 (&lexer_line, 1122 "rtx type `%s' has `0' in position %lu, can't handle", 1123 rtx_name[i], (unsigned long) aindex); 1124 t = &string_type; 1125 subname = "rt_int"; 1126 } 1127 break; 1128 1129 case 's': 1130 case 'S': 1131 case 'T': 1132 t = &string_type; 1133 subname = "rt_str"; 1134 break; 1135 1136 case 'e': 1137 case 'u': 1138 t = rtx_tp; 1139 subname = "rt_rtx"; 1140 break; 1141 1142 case 'E': 1143 case 'V': 1144 t = rtvec_tp; 1145 subname = "rt_rtvec"; 1146 break; 1147 1148 case 't': 1149 t = tree_tp; 1150 subname = "rt_tree"; 1151 break; 1152 1153 case 'B': 1154 t = basic_block_tp; 1155 subname = "rt_bb"; 1156 break; 1157 1158 default: 1159 error_at_line 1160 (&lexer_line, 1161 "rtx type `%s' has `%c' in position %lu, can't handle", 1162 rtx_name[i], rtx_format[i][aindex], 1163 (unsigned long) aindex); 1164 t = &string_type; 1165 subname = "rt_int"; 1166 break; 1167 } 1168 1169 subfields = create_field (subfields, t, 1170 xasprintf (".fld[%lu].%s", 1171 (unsigned long) aindex, 1172 subname)); 1173 subfields->opt = nodot; 1174 if (t == note_union_tp) 1175 subfields->opt = 1176 create_string_option (subfields->opt, "desc", 1177 "NOTE_KIND (&%0)"); 1178 if (t == symbol_union_tp) 1179 subfields->opt = 1180 create_string_option (subfields->opt, "desc", 1181 "CONSTANT_POOL_ADDRESS_P (&%0)"); 1182 } 1183 1184 if (i == SYMBOL_REF) 1185 { 1186 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P 1187 holds. */ 1188 type_p field_tp = find_structure ("block_symbol", 0); 1189 subfields 1190 = create_optional_field (subfields, field_tp, "block_sym", 1191 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)"); 1192 } 1193 1194 sname = xasprintf ("rtx_def_%s", rtx_name[i]); 1195 substruct = new_structure (sname, 0, &lexer_line, subfields, NULL); 1196 1197 ftag = xstrdup (rtx_name[i]); 1198 for (nmindex = 0; nmindex < strlen (ftag); nmindex++) 1199 ftag[nmindex] = TOUPPER (ftag[nmindex]); 1200 flds = create_field (flds, substruct, ""); 1201 flds->opt = create_string_option (nodot, "tag", ftag); 1202 } 1203 return new_structure ("rtx_def_subunion", 1, &lexer_line, flds, nodot); 1204 } 1205 1206 /* Handle `special("tree_exp")'. This is a special case for 1207 field `operands' of struct tree_exp, which although it claims to contain 1208 pointers to trees, actually sometimes contains pointers to RTL too. 1209 Passed T, the old type of the field, and OPT its options. Returns 1210 a new type for the field. */ 1211 1212 static type_p 1213 adjust_field_tree_exp (type_p t, options_p opt ATTRIBUTE_UNUSED) 1214 { 1215 pair_p flds; 1216 options_p nodot; 1217 1218 if (t->kind != TYPE_ARRAY) 1219 { 1220 error_at_line (&lexer_line, 1221 "special `tree_exp' must be applied to an array"); 1222 return &string_type; 1223 } 1224 1225 nodot = create_string_option (NULL, "dot", ""); 1226 1227 flds = create_field (NULL, t, ""); 1228 flds->opt = create_string_option (nodot, "length", 1229 "TREE_OPERAND_LENGTH ((tree) &%0)"); 1230 flds->opt = create_string_option (flds->opt, "default", ""); 1231 1232 return new_structure ("tree_exp_subunion", 1, &lexer_line, flds, nodot); 1233 } 1234 1235 /* Perform any special processing on a type T, about to become the type 1236 of a field. Return the appropriate type for the field. 1237 At present: 1238 - Converts pointer-to-char, with no length parameter, to TYPE_STRING; 1239 - Similarly for arrays of pointer-to-char; 1240 - Converts structures for which a parameter is provided to 1241 TYPE_PARAM_STRUCT; 1242 - Handles "special" options. 1243 */ 1244 1245 type_p 1246 adjust_field_type (type_p t, options_p opt) 1247 { 1248 int length_p = 0; 1249 const int pointer_p = t->kind == TYPE_POINTER; 1250 type_p params[NUM_PARAM]; 1251 int params_p = 0; 1252 int i; 1253 1254 for (i = 0; i < NUM_PARAM; i++) 1255 params[i] = NULL; 1256 1257 for (; opt; opt = opt->next) 1258 if (strcmp (opt->name, "length") == 0) 1259 length_p = 1; 1260 else if ((strcmp (opt->name, "param_is") == 0 1261 || (strncmp (opt->name, "param", 5) == 0 1262 && ISDIGIT (opt->name[5]) 1263 && strcmp (opt->name + 6, "_is") == 0)) 1264 && opt->kind == OPTION_TYPE) 1265 { 1266 int num = ISDIGIT (opt->name[5]) ? opt->name[5] - '0' : 0; 1267 1268 if (!UNION_OR_STRUCT_P (t) 1269 && (t->kind != TYPE_POINTER || !UNION_OR_STRUCT_P (t->u.p))) 1270 { 1271 error_at_line (&lexer_line, 1272 "option `%s' may only be applied to structures or structure pointers", 1273 opt->name); 1274 return t; 1275 } 1276 1277 params_p = 1; 1278 if (params[num] != NULL) 1279 error_at_line (&lexer_line, "duplicate `%s' option", opt->name); 1280 if (!ISDIGIT (opt->name[5])) 1281 params[num] = create_pointer (opt->info.type); 1282 else 1283 params[num] = opt->info.type; 1284 } 1285 else if (strcmp (opt->name, "special") == 0 1286 && opt->kind == OPTION_STRING) 1287 { 1288 const char *special_name = opt->info.string; 1289 if (strcmp (special_name, "tree_exp") == 0) 1290 t = adjust_field_tree_exp (t, opt); 1291 else if (strcmp (special_name, "rtx_def") == 0) 1292 t = adjust_field_rtx_def (t, opt); 1293 else 1294 error_at_line (&lexer_line, "unknown special `%s'", special_name); 1295 } 1296 1297 if (params_p) 1298 { 1299 type_p realt; 1300 1301 if (pointer_p) 1302 t = t->u.p; 1303 realt = find_param_structure (t, params); 1304 t = pointer_p ? create_pointer (realt) : realt; 1305 } 1306 1307 if (!length_p 1308 && pointer_p && t->u.p->kind == TYPE_SCALAR && t->u.p->u.scalar_is_char) 1309 return &string_type; 1310 if (t->kind == TYPE_ARRAY && t->u.a.p->kind == TYPE_POINTER 1311 && t->u.a.p->u.p->kind == TYPE_SCALAR 1312 && t->u.a.p->u.p->u.scalar_is_char) 1313 return create_array (&string_type, t->u.a.len); 1314 1315 return t; 1316 } 1317 1318 1319 static void set_gc_used_type (type_p, enum gc_used_enum, type_p *); 1320 static void set_gc_used (pair_p); 1321 1322 /* Handle OPT for set_gc_used_type. */ 1323 1324 static void 1325 process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef, 1326 int *pass_param, int *length, int *skip, 1327 type_p *nested_ptr) 1328 { 1329 options_p o; 1330 for (o = opt; o; o = o->next) 1331 if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO 1332 && o->kind == OPTION_TYPE) 1333 set_gc_used_type (o->info.type, 1334 GC_POINTED_TO, NULL); 1335 else if (strcmp (o->name, "maybe_undef") == 0) 1336 *maybe_undef = 1; 1337 else if (strcmp (o->name, "use_params") == 0) 1338 *pass_param = 1; 1339 else if (strcmp (o->name, "length") == 0) 1340 *length = 1; 1341 else if (strcmp (o->name, "skip") == 0) 1342 *skip = 1; 1343 else if (strcmp (o->name, "nested_ptr") == 0 1344 && o->kind == OPTION_NESTED) 1345 *nested_ptr = ((const struct nested_ptr_data *) o->info.nested)->type; 1346 } 1347 1348 1349 /* Set the gc_used field of T to LEVEL, and handle the types it references. */ 1350 static void 1351 set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM]) 1352 { 1353 if (t->gc_used >= level) 1354 return; 1355 1356 t->gc_used = level; 1357 1358 switch (t->kind) 1359 { 1360 case TYPE_STRUCT: 1361 case TYPE_UNION: 1362 { 1363 pair_p f; 1364 int dummy; 1365 type_p dummy2; 1366 1367 process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, &dummy, 1368 &dummy2); 1369 1370 for (f = t->u.s.fields; f; f = f->next) 1371 { 1372 int maybe_undef = 0; 1373 int pass_param = 0; 1374 int length = 0; 1375 int skip = 0; 1376 type_p nested_ptr = NULL; 1377 process_gc_options (f->opt, level, &maybe_undef, &pass_param, 1378 &length, &skip, &nested_ptr); 1379 1380 if (nested_ptr && f->type->kind == TYPE_POINTER) 1381 set_gc_used_type (nested_ptr, GC_POINTED_TO, 1382 pass_param ? param : NULL); 1383 else if (length && f->type->kind == TYPE_POINTER) 1384 set_gc_used_type (f->type->u.p, GC_USED, NULL); 1385 else if (maybe_undef && f->type->kind == TYPE_POINTER) 1386 set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO, NULL); 1387 else if (pass_param && f->type->kind == TYPE_POINTER && param) 1388 set_gc_used_type (find_param_structure (f->type->u.p, param), 1389 GC_POINTED_TO, NULL); 1390 else if (skip) 1391 ; /* target type is not used through this field */ 1392 else 1393 set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL); 1394 } 1395 break; 1396 } 1397 1398 case TYPE_POINTER: 1399 set_gc_used_type (t->u.p, GC_POINTED_TO, NULL); 1400 break; 1401 1402 case TYPE_ARRAY: 1403 set_gc_used_type (t->u.a.p, GC_USED, param); 1404 break; 1405 1406 case TYPE_LANG_STRUCT: 1407 for (t = t->u.s.lang_struct; t; t = t->next) 1408 set_gc_used_type (t, level, param); 1409 break; 1410 1411 case TYPE_PARAM_STRUCT: 1412 { 1413 int i; 1414 for (i = 0; i < NUM_PARAM; i++) 1415 if (t->u.param_struct.param[i] != 0) 1416 set_gc_used_type (t->u.param_struct.param[i], GC_USED, NULL); 1417 } 1418 if (t->u.param_struct.stru->gc_used == GC_POINTED_TO) 1419 level = GC_POINTED_TO; 1420 else 1421 level = GC_USED; 1422 t->u.param_struct.stru->gc_used = GC_UNUSED; 1423 set_gc_used_type (t->u.param_struct.stru, level, 1424 t->u.param_struct.param); 1425 break; 1426 1427 default: 1428 break; 1429 } 1430 } 1431 1432 /* Set the gc_used fields of all the types pointed to by VARIABLES. */ 1433 1434 static void 1435 set_gc_used (pair_p variables) 1436 { 1437 int nbvars = 0; 1438 pair_p p; 1439 for (p = variables; p; p = p->next) 1440 { 1441 set_gc_used_type (p->type, GC_USED, NULL); 1442 nbvars++; 1443 }; 1444 if (verbosity_level >= 2) 1445 printf ("%s used %d GTY-ed variables\n", progname, nbvars); 1446 } 1447 1448 /* File mapping routines. For each input file, there is one output .c file 1449 (but some output files have many input files), and there is one .h file 1450 for the whole build. */ 1451 1452 /* Output file handling. */ 1453 1454 /* Create and return an outf_p for a new file for NAME, to be called 1455 ONAME. */ 1456 1457 static outf_p 1458 create_file (const char *name, const char *oname) 1459 { 1460 static const char *const hdr[] = { 1461 " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n", 1462 "\n", 1463 "This file is part of GCC.\n", 1464 "\n", 1465 "GCC is free software; you can redistribute it and/or modify it under\n", 1466 "the terms of the GNU General Public License as published by the Free\n", 1467 "Software Foundation; either version 3, or (at your option) any later\n", 1468 "version.\n", 1469 "\n", 1470 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n", 1471 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n", 1472 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n", 1473 "for more details.\n", 1474 "\n", 1475 "You should have received a copy of the GNU General Public License\n", 1476 "along with GCC; see the file COPYING3. If not see\n", 1477 "<http://www.gnu.org/licenses/>. */\n", 1478 "\n", 1479 "/* This file is machine generated. Do not edit. */\n" 1480 }; 1481 outf_p f; 1482 size_t i; 1483 1484 gcc_assert (name != NULL); 1485 gcc_assert (oname != NULL); 1486 f = XCNEW (struct outf); 1487 f->next = output_files; 1488 f->name = oname; 1489 output_files = f; 1490 1491 oprintf (f, "/* Type information for %s.\n", name); 1492 for (i = 0; i < ARRAY_SIZE (hdr); i++) 1493 oprintf (f, "%s", hdr[i]); 1494 return f; 1495 } 1496 1497 /* Print, like fprintf, to O. 1498 N.B. You might think this could be implemented more efficiently 1499 with vsnprintf(). Unfortunately, there are C libraries that 1500 provide that function but without the C99 semantics for its return 1501 value, making it impossible to know how much space is required. */ 1502 void 1503 oprintf (outf_p o, const char *format, ...) 1504 { 1505 char *s; 1506 size_t slength; 1507 va_list ap; 1508 1509 /* In plugin mode, the O could be a NULL pointer, so avoid crashing 1510 in that case. */ 1511 if (!o) 1512 return; 1513 1514 va_start (ap, format); 1515 slength = vasprintf (&s, format, ap); 1516 if (s == NULL || (int) slength < 0) 1517 fatal ("out of memory"); 1518 va_end (ap); 1519 1520 if (o->bufused + slength > o->buflength) 1521 { 1522 size_t new_len = o->buflength; 1523 if (new_len == 0) 1524 new_len = 1024; 1525 do 1526 { 1527 new_len *= 2; 1528 } 1529 while (o->bufused + slength >= new_len); 1530 o->buf = XRESIZEVEC (char, o->buf, new_len); 1531 o->buflength = new_len; 1532 } 1533 memcpy (o->buf + o->bufused, s, slength); 1534 o->bufused += slength; 1535 free (s); 1536 } 1537 1538 /* Open the global header file and the language-specific header files. */ 1539 1540 static void 1541 open_base_files (void) 1542 { 1543 size_t i; 1544 1545 if (nb_plugin_files > 0 && plugin_files) 1546 return; 1547 1548 header_file = create_file ("GCC", "gtype-desc.h"); 1549 1550 base_files = XNEWVEC (outf_p, num_lang_dirs); 1551 1552 for (i = 0; i < num_lang_dirs; i++) 1553 base_files[i] = create_file (lang_dir_names[i], 1554 xasprintf ("gtype-%s.h", lang_dir_names[i])); 1555 1556 /* gtype-desc.c is a little special, so we create it here. */ 1557 { 1558 /* The order of files here matters very much. */ 1559 static const char *const ifiles[] = { 1560 "config.h", "system.h", "coretypes.h", "tm.h", 1561 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h", 1562 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h", 1563 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h", 1564 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h", 1565 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h", 1566 "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h", 1567 "target.h", "ipa-prop.h", "lto-streamer.h", "target-globals.h", 1568 "ipa-inline.h", "dwarf2out.h", NULL 1569 }; 1570 const char *const *ifp; 1571 outf_p gtype_desc_c; 1572 1573 gtype_desc_c = create_file ("GCC", "gtype-desc.c"); 1574 for (ifp = ifiles; *ifp; ifp++) 1575 oprintf (gtype_desc_c, "#include \"%s\"\n", *ifp); 1576 1577 /* Make sure we handle "cfun" specially. */ 1578 oprintf (gtype_desc_c, "\n/* See definition in function.h. */\n"); 1579 oprintf (gtype_desc_c, "#undef cfun\n"); 1580 } 1581 } 1582 1583 /* For INPF an input file, return the real basename of INPF, with all 1584 the directory components skipped. */ 1585 1586 static const char * 1587 get_file_realbasename (const input_file *inpf) 1588 { 1589 return lbasename (get_input_file_name (inpf)); 1590 } 1591 1592 /* For INPF a filename, return the relative path to INPF from 1593 $(srcdir) if the latter is a prefix in INPF, NULL otherwise. */ 1594 1595 const char * 1596 get_file_srcdir_relative_path (const input_file *inpf) 1597 { 1598 const char *f = get_input_file_name (inpf); 1599 if (strlen (f) > srcdir_len 1600 && IS_DIR_SEPARATOR (f[srcdir_len]) 1601 && strncmp (f, srcdir, srcdir_len) == 0) 1602 return f + srcdir_len + 1; 1603 else 1604 return NULL; 1605 } 1606 1607 /* For INPF an input_file, return the relative path to INPF from 1608 $(srcdir) if the latter is a prefix in INPF, or the real basename 1609 of INPF otherwise. */ 1610 1611 static const char * 1612 get_file_basename (const input_file *inpf) 1613 { 1614 const char *srcdir_path = get_file_srcdir_relative_path (inpf); 1615 1616 return (srcdir_path != NULL) ? srcdir_path : get_file_realbasename (inpf); 1617 } 1618 1619 /* For F a filename, return the lang_dir_names relative index of the language 1620 directory that is a prefix in F, if any, -1 otherwise. */ 1621 1622 static int 1623 get_prefix_langdir_index (const char *f) 1624 { 1625 size_t f_len = strlen (f); 1626 size_t lang_index; 1627 1628 for (lang_index = 0; lang_index < num_lang_dirs; lang_index++) 1629 { 1630 const char *langdir = lang_dir_names[lang_index]; 1631 size_t langdir_len = strlen (langdir); 1632 1633 if (f_len > langdir_len 1634 && IS_DIR_SEPARATOR (f[langdir_len]) 1635 && memcmp (f, langdir, langdir_len) == 0) 1636 return lang_index; 1637 } 1638 1639 return -1; 1640 } 1641 1642 /* For INPF an input file, return the name of language directory where 1643 F is located, if any, NULL otherwise. */ 1644 1645 static const char * 1646 get_file_langdir (const input_file *inpf) 1647 { 1648 /* Get the relative path to INPF from $(srcdir) and find the 1649 language by comparing the prefix with language directory names. 1650 If INPF is not even srcdir relative, no point in looking 1651 further. */ 1652 1653 int lang_index; 1654 const char *srcdir_relative_path = get_file_srcdir_relative_path (inpf); 1655 const char *r; 1656 1657 if (!srcdir_relative_path) 1658 return NULL; 1659 1660 lang_index = get_prefix_langdir_index (srcdir_relative_path); 1661 if (lang_index < 0 && strncmp (srcdir_relative_path, "c-family", 8) == 0) 1662 r = "c-family"; 1663 else if (lang_index >= 0) 1664 r = lang_dir_names[lang_index]; 1665 else 1666 r = NULL; 1667 1668 return r; 1669 } 1670 1671 /* The gt- output file name for INPF. */ 1672 1673 static const char * 1674 get_file_gtfilename (const input_file *inpf) 1675 { 1676 /* Cook up an initial version of the gt- file name from the file real 1677 basename and the language name, if any. */ 1678 1679 const char *basename = get_file_realbasename (inpf); 1680 const char *langdir = get_file_langdir (inpf); 1681 1682 char *result = 1683 (langdir ? xasprintf ("gt-%s-%s", langdir, basename) 1684 : xasprintf ("gt-%s", basename)); 1685 1686 /* Then replace all non alphanumerics characters by '-' and change the 1687 extension to ".h". We expect the input filename extension was at least 1688 one character long. */ 1689 1690 char *s = result; 1691 1692 for (; *s != '.'; s++) 1693 if (!ISALNUM (*s) && *s != '-') 1694 *s = '-'; 1695 1696 memcpy (s, ".h", sizeof (".h")); 1697 1698 return result; 1699 } 1700 1701 /* Each input_file has its associated output file outf_p. The 1702 association is computed by the function 1703 get_output_file_with_visibility. The associated file is cached 1704 inside input_file in its inpoutf field, so is really computed only 1705 once. Associated output file paths (i.e. output_name-s) are 1706 computed by a rule based regexp machinery, using the files_rules 1707 array of struct file_rule_st. A for_name is also computed, giving 1708 the source file name for which the output_file is generated; it is 1709 often the last component of the input_file path. */ 1710 1711 1712 /* 1713 Regexpr machinery to compute the output_name and for_name-s of each 1714 input_file. We have a sequence of file rules which gives the POSIX 1715 extended regular expression to match an input file path, and two 1716 transformed strings for the corresponding output_name and the 1717 corresponding for_name. The transformed string contain dollars: $0 1718 is replaced by the entire match, $1 is replaced by the substring 1719 matching the first parenthesis in the regexp, etc. And $$ is replaced 1720 by a single verbatim dollar. The rule order is important. The 1721 general case is last, and the particular cases should come before. 1722 An action routine can, when needed, update the out_name & for_name 1723 and/or return the appropriate output file. It is invoked only when a 1724 rule is triggered. When a rule is triggered, the output_name and 1725 for_name are computed using their transform string in while $$, $0, 1726 $1, ... are suitably replaced. If there is an action, it is called. 1727 In some few cases, the action can directly return the outf_p, but 1728 usually it just updates the output_name and for_name so should free 1729 them before replacing them. The get_output_file_with_visibility 1730 function creates an outf_p only once per each output_name, so it 1731 scans the output_files list for previously seen output file names. 1732 */ 1733 1734 /* Signature of actions in file rules. */ 1735 typedef outf_p (frul_actionrout_t) (input_file*, char**, char**); 1736 1737 1738 struct file_rule_st { 1739 const char* frul_srcexpr; /* Source string for regexp. */ 1740 int frul_rflags; /* Flags passed to regcomp, usually 1741 * REG_EXTENDED. */ 1742 regex_t* frul_re; /* Compiled regular expression 1743 obtained by regcomp. */ 1744 const char* frul_tr_out; /* Transformation string for making 1745 * the output_name, with $1 ... $9 for 1746 * subpatterns and $0 for the whole 1747 * matched filename. */ 1748 const char* frul_tr_for; /* Tranformation string for making the 1749 for_name. */ 1750 frul_actionrout_t* frul_action; /* The action, if non null, is 1751 * called once the rule matches, on 1752 * the transformed out_name & 1753 * for_name. It could change them 1754 * and/or give the output file. */ 1755 }; 1756 1757 /* File rule action handling *.h files. */ 1758 static outf_p header_dot_h_frul (input_file*, char**, char**); 1759 1760 /* File rule action handling *.c files. */ 1761 static outf_p source_dot_c_frul (input_file*, char**, char**); 1762 1763 #define NULL_REGEX (regex_t*)0 1764 1765 /* The prefix in our regexp-s matching the directory. */ 1766 #define DIR_PREFIX_REGEX "^(([^/]*/)*)" 1767 1768 #define NULL_FRULACT (frul_actionrout_t*)0 1769 1770 /* The array of our rules governing file name generation. Rules order 1771 matters, so change with extreme care! */ 1772 1773 struct file_rule_st files_rules[] = { 1774 /* The general rule assumes that files in subdirectories belong to a 1775 particular front-end, and files not in subdirectories are shared. 1776 The following rules deal with exceptions - files that are in 1777 subdirectories and yet are shared, and files that are top-level, 1778 but are not shared. */ 1779 1780 /* the c-family/ source directory is special. */ 1781 { DIR_PREFIX_REGEX "c-family/([[:alnum:]_-]*)\\.c$", 1782 REG_EXTENDED, NULL_REGEX, 1783 "gt-c-family-$3.h", "c-family/$3.c", NULL_FRULACT}, 1784 1785 { DIR_PREFIX_REGEX "c-family/([[:alnum:]_-]*)\\.h$", 1786 REG_EXTENDED, NULL_REGEX, 1787 "gt-c-family-$3.h", "c-family/$3.h", NULL_FRULACT}, 1788 1789 /* Both c-lang.h & c-tree.h gives gt-c-decl.h for c-decl.c ! */ 1790 { DIR_PREFIX_REGEX "c-lang\\.h$", 1791 REG_EXTENDED, NULL_REGEX, "gt-c-decl.h", "c-decl.c", NULL_FRULACT}, 1792 1793 { DIR_PREFIX_REGEX "c-tree\\.h$", 1794 REG_EXTENDED, NULL_REGEX, "gt-c-decl.h", "c-decl.c", NULL_FRULACT}, 1795 1796 /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.c ! */ 1797 { DIR_PREFIX_REGEX "cp/cp-tree\\.h$", 1798 REG_EXTENDED, NULL_REGEX, 1799 "gt-cp-tree.h", "cp/tree.c", NULL_FRULACT }, 1800 1801 /* cp/decl.h & cp/decl.c gives gt-cp-decl.h for cp/decl.c ! */ 1802 { DIR_PREFIX_REGEX "cp/decl\\.[ch]$", 1803 REG_EXTENDED, NULL_REGEX, 1804 "gt-cp-decl.h", "cp/decl.c", NULL_FRULACT }, 1805 1806 /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.c ! */ 1807 { DIR_PREFIX_REGEX "cp/name-lookup\\.h$", 1808 REG_EXTENDED, NULL_REGEX, 1809 "gt-cp-name-lookup.h", "cp/name-lookup.c", NULL_FRULACT }, 1810 1811 /* cp/parser.h gives gt-cp-parser.h for cp/parser.c ! */ 1812 { DIR_PREFIX_REGEX "cp/parser\\.h$", 1813 REG_EXTENDED, NULL_REGEX, 1814 "gt-cp-parser.h", "cp/parser.c", NULL_FRULACT }, 1815 1816 /* objc/objc-act.h gives gt-objc-objc-act.h for objc/objc-act.c ! */ 1817 { DIR_PREFIX_REGEX "objc/objc-act\\.h$", 1818 REG_EXTENDED, NULL_REGEX, 1819 "gt-objc-objc-act.h", "objc/objc-act.c", NULL_FRULACT }, 1820 1821 /* objc/objc-map.h gives gt-objc-objc-map.h for objc/objc-map.c ! */ 1822 { DIR_PREFIX_REGEX "objc/objc-map\\.h$", 1823 REG_EXTENDED, NULL_REGEX, 1824 "gt-objc-objc-map.h", "objc/objc-map.c", NULL_FRULACT }, 1825 1826 /* General cases. For header *.h and source *.c files, we need 1827 * special actions to handle the language. */ 1828 1829 /* Source *.c files are using get_file_gtfilename to compute their 1830 output_name and get_file_basename to compute their for_name 1831 thru the source_dot_c_frul action. */ 1832 { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.c$", 1833 REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.c", source_dot_c_frul}, 1834 /* Common header files get "gtype-desc.c" as their output_name, 1835 * while language specific header files are handled specially. So 1836 * we need the header_dot_h_frul action. */ 1837 { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.h$", 1838 REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.h", header_dot_h_frul}, 1839 1840 { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.in$", 1841 REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.in", NULL_FRULACT}, 1842 1843 /* Mandatory null last entry signaling end of rules. */ 1844 {NULL, 0, NULL_REGEX, NULL, NULL, NULL_FRULACT} 1845 }; 1846 1847 /* Special file rules action for handling *.h header files. It gives 1848 "gtype-desc.c" for common headers and corresponding output 1849 files for language-specific header files. */ 1850 static outf_p 1851 header_dot_h_frul (input_file* inpf, char**poutname, 1852 char**pforname ATTRIBUTE_UNUSED) 1853 { 1854 const char *basename = 0; 1855 int lang_index = 0; 1856 DBGPRINTF ("inpf %p inpname %s outname %s forname %s", 1857 (void*) inpf, get_input_file_name (inpf), 1858 *poutname, *pforname); 1859 basename = get_file_basename (inpf); 1860 lang_index = get_prefix_langdir_index (basename); 1861 DBGPRINTF ("basename %s lang_index %d", basename, lang_index); 1862 1863 if (lang_index >= 0) 1864 { 1865 /* The header is language specific. Given output_name & 1866 for_name remains unchanged. The base_files array gives the 1867 outf_p. */ 1868 DBGPRINTF ("header_dot_h found language specific @ %p '%s'", 1869 (void*) base_files[lang_index], 1870 (base_files[lang_index])->name); 1871 return base_files[lang_index]; 1872 } 1873 else 1874 { 1875 /* The header is common to all front-end languages. So 1876 output_name is "gtype-desc.c" file. The calling function 1877 get_output_file_with_visibility will find its outf_p. */ 1878 free (*poutname); 1879 *poutname = xstrdup ("gtype-desc.c"); 1880 DBGPRINTF ("special 'gtype-desc.c' for inpname %s", 1881 get_input_file_name (inpf)); 1882 return NULL; 1883 } 1884 } 1885 1886 1887 /* Special file rules action for handling *.c source files using 1888 * get_file_gtfilename to compute their output_name and 1889 * get_file_basename to compute their for_name. The output_name is 1890 * gt-<LANG>-<BASE>.h for language specific source files, and 1891 * gt-<BASE>.h for common source files. */ 1892 static outf_p 1893 source_dot_c_frul (input_file* inpf, char**poutname, char**pforname) 1894 { 1895 char *newbasename = CONST_CAST (char*, get_file_basename (inpf)); 1896 char *newoutname = CONST_CAST (char*, get_file_gtfilename (inpf)); 1897 DBGPRINTF ("inpf %p inpname %s original outname %s forname %s", 1898 (void*) inpf, get_input_file_name (inpf), 1899 *poutname, *pforname); 1900 DBGPRINTF ("newoutname %s", newoutname); 1901 DBGPRINTF ("newbasename %s", newbasename); 1902 free (*poutname); 1903 free (*pforname); 1904 *poutname = newoutname; 1905 *pforname = newbasename; 1906 return NULL; 1907 } 1908 1909 /* Utility function for get_output_file_with_visibility which returns 1910 * a malloc-ed substituted string using TRS on matching of the FILNAM 1911 * file name, using the PMATCH array. */ 1912 static char* 1913 matching_file_name_substitute (const char *filnam, regmatch_t pmatch[10], 1914 const char *trs) 1915 { 1916 struct obstack str_obstack; 1917 char *str = NULL; 1918 char *rawstr = NULL; 1919 const char *pt = NULL; 1920 DBGPRINTF ("filnam %s", filnam); 1921 obstack_init (&str_obstack); 1922 for (pt = trs; *pt; pt++) { 1923 char c = *pt; 1924 if (c == '$') 1925 { 1926 if (pt[1] == '$') 1927 { 1928 /* A double dollar $$ is substituted by a single verbatim 1929 dollar, but who really uses dollar signs in file 1930 paths? */ 1931 obstack_1grow (&str_obstack, '$'); 1932 } 1933 else if (ISDIGIT (pt[1])) 1934 { 1935 /* Handle $0 $1 ... $9 by appropriate substitution. */ 1936 int dolnum = pt[1] - '0'; 1937 int so = pmatch[dolnum].rm_so; 1938 int eo = pmatch[dolnum].rm_eo; 1939 DBGPRINTF ("so=%d eo=%d dolnum=%d", so, eo, dolnum); 1940 if (so>=0 && eo>=so) 1941 obstack_grow (&str_obstack, filnam + so, eo - so); 1942 } 1943 else 1944 { 1945 /* This can happen only when files_rules is buggy! */ 1946 gcc_unreachable(); 1947 } 1948 /* Always skip the character after the dollar. */ 1949 pt++; 1950 } 1951 else 1952 obstack_1grow (&str_obstack, c); 1953 } 1954 obstack_1grow (&str_obstack, '\0'); 1955 rawstr = XOBFINISH (&str_obstack, char *); 1956 str = xstrdup (rawstr); 1957 obstack_free (&str_obstack, NULL); 1958 DBGPRINTF ("matched replacement %s", str); 1959 rawstr = NULL; 1960 return str; 1961 } 1962 1963 1964 /* An output file, suitable for definitions, that can see declarations 1965 made in INPF and is linked into every language that uses INPF. 1966 Since the result is cached inside INPF, that argument cannot be 1967 declared constant, but is "almost" constant. */ 1968 1969 outf_p 1970 get_output_file_with_visibility (input_file *inpf) 1971 { 1972 outf_p r; 1973 char *for_name = NULL; 1974 char *output_name = NULL; 1975 const char* inpfname; 1976 1977 /* This can happen when we need a file with visibility on a 1978 structure that we've never seen. We have to just hope that it's 1979 globally visible. */ 1980 if (inpf == NULL) 1981 inpf = system_h_file; 1982 1983 /* The result is cached in INPF, so return it if already known. */ 1984 if (inpf->inpoutf) 1985 return inpf->inpoutf; 1986 1987 /* In plugin mode, return NULL unless the input_file is one of the 1988 plugin_files. */ 1989 if (plugin_files) 1990 { 1991 size_t i; 1992 for (i = 0; i < nb_plugin_files; i++) 1993 if (inpf == plugin_files[i]) 1994 { 1995 inpf->inpoutf = plugin_output; 1996 return plugin_output; 1997 } 1998 1999 return NULL; 2000 } 2001 2002 inpfname = get_input_file_name (inpf); 2003 2004 /* Try each rule in sequence in files_rules until one is triggered. */ 2005 { 2006 int rulix = 0; 2007 DBGPRINTF ("passing input file @ %p named %s thru the files_rules", 2008 (void*) inpf, inpfname); 2009 2010 for (; files_rules[rulix].frul_srcexpr != NULL; rulix++) 2011 { 2012 DBGPRINTF ("rulix#%d srcexpr %s", 2013 rulix, files_rules[rulix].frul_srcexpr); 2014 2015 if (!files_rules[rulix].frul_re) 2016 { 2017 /* Compile the regexpr lazily. */ 2018 int err = 0; 2019 files_rules[rulix].frul_re = XCNEW (regex_t); 2020 err = regcomp (files_rules[rulix].frul_re, 2021 files_rules[rulix].frul_srcexpr, 2022 files_rules[rulix].frul_rflags); 2023 if (err) 2024 { 2025 /* The regular expression compilation fails only when 2026 file_rules is buggy. */ 2027 gcc_unreachable (); 2028 } 2029 } 2030 2031 output_name = NULL; 2032 for_name = NULL; 2033 2034 /* Match the regexpr and trigger the rule if matched. */ 2035 { 2036 /* We have exactly ten pmatch-s, one for each $0, $1, $2, 2037 $3, ... $9. */ 2038 regmatch_t pmatch[10]; 2039 memset (pmatch, 0, sizeof (pmatch)); 2040 if (!regexec (files_rules[rulix].frul_re, 2041 inpfname, 10, pmatch, 0)) 2042 { 2043 DBGPRINTF ("input @ %p filename %s matched rulix#%d pattern %s", 2044 (void*) inpf, inpfname, rulix, 2045 files_rules[rulix].frul_srcexpr); 2046 for_name = 2047 matching_file_name_substitute (inpfname, pmatch, 2048 files_rules[rulix].frul_tr_for); 2049 DBGPRINTF ("for_name %s", for_name); 2050 output_name = 2051 matching_file_name_substitute (inpfname, pmatch, 2052 files_rules[rulix].frul_tr_out); 2053 DBGPRINTF ("output_name %s", output_name); 2054 if (files_rules[rulix].frul_action) 2055 { 2056 /* Invoke our action routine. */ 2057 outf_p of = NULL; 2058 DBGPRINTF ("before action rulix#%d output_name %s for_name %s", 2059 rulix, output_name, for_name); 2060 of = 2061 (files_rules[rulix].frul_action) (inpf, 2062 &output_name, &for_name); 2063 DBGPRINTF ("after action rulix#%d of=%p output_name %s for_name %s", 2064 rulix, (void*)of, output_name, for_name); 2065 /* If the action routine returned something, give it back 2066 immediately and cache it in inpf. */ 2067 if (of) 2068 { 2069 inpf->inpoutf = of; 2070 return of; 2071 } 2072 } 2073 /* The rule matched, and had no action, or that action did 2074 not return any output file but could have changed the 2075 output_name or for_name. We break out of the loop on the 2076 files_rules. */ 2077 break; 2078 } 2079 else 2080 { 2081 /* The regexpr did not match. */ 2082 DBGPRINTF ("rulix#%d did not match %s pattern %s", 2083 rulix, inpfname, files_rules[rulix].frul_srcexpr); 2084 continue; 2085 } 2086 } 2087 } 2088 } 2089 if (!output_name || !for_name) 2090 { 2091 /* This is impossible, and could only happen if the files_rules is 2092 incomplete or buggy. */ 2093 gcc_unreachable (); 2094 } 2095 2096 /* Look through to see if we've ever seen this output filename 2097 before. If found, cache the result in inpf. */ 2098 for (r = output_files; r; r = r->next) 2099 if (filename_cmp (r->name, output_name) == 0) 2100 { 2101 inpf->inpoutf = r; 2102 DBGPRINTF ("found r @ %p for output_name %s for_name %s", (void*)r, 2103 output_name, for_name); 2104 return r; 2105 } 2106 2107 /* If not found, create it, and cache it in inpf. */ 2108 r = create_file (for_name, output_name); 2109 2110 gcc_assert (r && r->name); 2111 DBGPRINTF ("created r @ %p for output_name %s for_name %s", (void*) r, 2112 output_name, for_name); 2113 inpf->inpoutf = r; 2114 return r; 2115 2116 2117 } 2118 2119 /* The name of an output file, suitable for definitions, that can see 2120 declarations made in INPF and is linked into every language that 2121 uses INPF. */ 2122 2123 const char * 2124 get_output_file_name (input_file* inpf) 2125 { 2126 outf_p o = get_output_file_with_visibility (inpf); 2127 if (o) 2128 return o->name; 2129 return NULL; 2130 } 2131 2132 /* Check if existing file is equal to the in memory buffer. */ 2133 2134 static bool 2135 is_file_equal (outf_p of) 2136 { 2137 FILE *newfile = fopen (of->name, "r"); 2138 size_t i; 2139 bool equal; 2140 if (newfile == NULL) 2141 return false; 2142 2143 equal = true; 2144 for (i = 0; i < of->bufused; i++) 2145 { 2146 int ch; 2147 ch = fgetc (newfile); 2148 if (ch == EOF || ch != (unsigned char) of->buf[i]) 2149 { 2150 equal = false; 2151 break; 2152 } 2153 } 2154 fclose (newfile); 2155 return equal; 2156 } 2157 2158 /* Copy the output to its final destination, 2159 but don't unnecessarily change modification times. */ 2160 2161 static void 2162 close_output_files (void) 2163 { 2164 int nbwrittenfiles = 0; 2165 outf_p of; 2166 2167 for (of = output_files; of; of = of->next) 2168 { 2169 2170 if (!is_file_equal (of)) 2171 { 2172 FILE *newfile = NULL; 2173 char *backupname = NULL; 2174 /* Back up the old version of the output file gt-FOO.c as 2175 BACKUPDIR/gt-FOO.c~ if we have a backup directory. */ 2176 if (backup_dir) 2177 { 2178 backupname = concat (backup_dir, "/", 2179 lbasename (of->name), "~", NULL); 2180 if (!access (of->name, F_OK) && rename (of->name, backupname)) 2181 fatal ("failed to back up %s as %s: %s", 2182 of->name, backupname, xstrerror (errno)); 2183 } 2184 2185 newfile = fopen (of->name, "w"); 2186 if (newfile == NULL) 2187 fatal ("opening output file %s: %s", of->name, xstrerror (errno)); 2188 if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused) 2189 fatal ("writing output file %s: %s", of->name, xstrerror (errno)); 2190 if (fclose (newfile) != 0) 2191 fatal ("closing output file %s: %s", of->name, xstrerror (errno)); 2192 nbwrittenfiles++; 2193 if (verbosity_level >= 2 && backupname) 2194 printf ("%s wrote #%-3d %s backed-up in %s\n", 2195 progname, nbwrittenfiles, of->name, backupname); 2196 else if (verbosity_level >= 1) 2197 printf ("%s write #%-3d %s\n", progname, nbwrittenfiles, of->name); 2198 free (backupname); 2199 } 2200 else 2201 { 2202 /* output file remains unchanged. */ 2203 if (verbosity_level >= 2) 2204 printf ("%s keep %s\n", progname, of->name); 2205 } 2206 free (of->buf); 2207 of->buf = NULL; 2208 of->bufused = of->buflength = 0; 2209 } 2210 if (verbosity_level >= 1) 2211 printf ("%s wrote %d files.\n", progname, nbwrittenfiles); 2212 } 2213 2214 struct flist 2215 { 2216 struct flist *next; 2217 int started_p; 2218 const input_file* file; 2219 outf_p f; 2220 }; 2221 2222 struct walk_type_data; 2223 2224 /* For scalars and strings, given the item in 'val'. 2225 For structures, given a pointer to the item in 'val'. 2226 For misc. pointers, given the item in 'val'. 2227 */ 2228 typedef void (*process_field_fn) (type_p f, const struct walk_type_data * p); 2229 typedef void (*func_name_fn) (type_p s, const struct walk_type_data * p); 2230 2231 /* Parameters for write_types. */ 2232 2233 struct write_types_data 2234 { 2235 const char *prefix; 2236 const char *param_prefix; 2237 const char *subfield_marker_routine; 2238 const char *marker_routine; 2239 const char *reorder_note_routine; 2240 const char *comment; 2241 int skip_hooks; /* skip hook generation if non zero */ 2242 }; 2243 2244 static void output_escaped_param (struct walk_type_data *d, 2245 const char *, const char *); 2246 static void output_mangled_typename (outf_p, const_type_p); 2247 static void walk_type (type_p t, struct walk_type_data *d); 2248 static void write_func_for_structure (type_p orig_s, type_p s, type_p *param, 2249 const struct write_types_data *wtd); 2250 static void write_types_process_field 2251 (type_p f, const struct walk_type_data *d); 2252 static void write_types (outf_p output_header, 2253 type_p structures, 2254 type_p param_structs, 2255 const struct write_types_data *wtd); 2256 static void write_types_local_process_field 2257 (type_p f, const struct walk_type_data *d); 2258 static void write_local_func_for_structure 2259 (const_type_p orig_s, type_p s, type_p *param); 2260 static void write_local (outf_p output_header, 2261 type_p structures, type_p param_structs); 2262 static void write_enum_defn (type_p structures, type_p param_structs); 2263 static int contains_scalar_p (type_p t); 2264 static void put_mangled_filename (outf_p, const input_file *); 2265 static void finish_root_table (struct flist *flp, const char *pfx, 2266 const char *tname, const char *lastname, 2267 const char *name); 2268 static void write_root (outf_p, pair_p, type_p, const char *, int, 2269 struct fileloc *, const char *, bool); 2270 static void write_array (outf_p f, pair_p v, 2271 const struct write_types_data *wtd); 2272 static void write_roots (pair_p, bool); 2273 2274 /* Parameters for walk_type. */ 2275 2276 struct walk_type_data 2277 { 2278 process_field_fn process_field; 2279 const void *cookie; 2280 outf_p of; 2281 options_p opt; 2282 const char *val; 2283 const char *prev_val[4]; 2284 int indent; 2285 int counter; 2286 const struct fileloc *line; 2287 lang_bitmap bitmap; 2288 type_p *param; 2289 int used_length; 2290 type_p orig_s; 2291 const char *reorder_fn; 2292 bool needs_cast_p; 2293 bool fn_wants_lvalue; 2294 }; 2295 2296 /* Print a mangled name representing T to OF. */ 2297 2298 static void 2299 output_mangled_typename (outf_p of, const_type_p t) 2300 { 2301 if (t == NULL) 2302 oprintf (of, "Z"); 2303 else 2304 switch (t->kind) 2305 { 2306 case TYPE_NONE: 2307 gcc_unreachable (); 2308 break; 2309 case TYPE_POINTER: 2310 oprintf (of, "P"); 2311 output_mangled_typename (of, t->u.p); 2312 break; 2313 case TYPE_SCALAR: 2314 oprintf (of, "I"); 2315 break; 2316 case TYPE_STRING: 2317 oprintf (of, "S"); 2318 break; 2319 case TYPE_STRUCT: 2320 case TYPE_UNION: 2321 case TYPE_LANG_STRUCT: 2322 oprintf (of, "%lu%s", (unsigned long) strlen (t->u.s.tag), 2323 t->u.s.tag); 2324 break; 2325 case TYPE_PARAM_STRUCT: 2326 { 2327 int i; 2328 for (i = 0; i < NUM_PARAM; i++) 2329 if (t->u.param_struct.param[i] != NULL) 2330 output_mangled_typename (of, t->u.param_struct.param[i]); 2331 output_mangled_typename (of, t->u.param_struct.stru); 2332 } 2333 break; 2334 case TYPE_ARRAY: 2335 gcc_unreachable (); 2336 } 2337 } 2338 2339 /* Print PARAM to D->OF processing escapes. D->VAL references the 2340 current object, D->PREV_VAL the object containing the current 2341 object, ONAME is the name of the option and D->LINE is used to 2342 print error messages. */ 2343 2344 static void 2345 output_escaped_param (struct walk_type_data *d, const char *param, 2346 const char *oname) 2347 { 2348 const char *p; 2349 2350 for (p = param; *p; p++) 2351 if (*p != '%') 2352 oprintf (d->of, "%c", *p); 2353 else 2354 switch (*++p) 2355 { 2356 case 'h': 2357 oprintf (d->of, "(%s)", d->prev_val[2]); 2358 break; 2359 case '0': 2360 oprintf (d->of, "(%s)", d->prev_val[0]); 2361 break; 2362 case '1': 2363 oprintf (d->of, "(%s)", d->prev_val[1]); 2364 break; 2365 case 'a': 2366 { 2367 const char *pp = d->val + strlen (d->val); 2368 while (pp[-1] == ']') 2369 while (*pp != '[') 2370 pp--; 2371 oprintf (d->of, "%s", pp); 2372 } 2373 break; 2374 default: 2375 error_at_line (d->line, "`%s' option contains bad escape %c%c", 2376 oname, '%', *p); 2377 } 2378 } 2379 2380 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL, 2381 which is of type T. Write code to D->OF to constrain execution (at 2382 the point that D->PROCESS_FIELD is called) to the appropriate 2383 cases. Call D->PROCESS_FIELD on subobjects before calling it on 2384 pointers to those objects. D->PREV_VAL lists the objects 2385 containing the current object, D->OPT is a list of options to 2386 apply, D->INDENT is the current indentation level, D->LINE is used 2387 to print error messages, D->BITMAP indicates which languages to 2388 print the structure for, and D->PARAM is the current parameter 2389 (from an enclosing param_is option). */ 2390 2391 static void 2392 walk_type (type_p t, struct walk_type_data *d) 2393 { 2394 const char *length = NULL; 2395 const char *desc = NULL; 2396 int maybe_undef_p = 0; 2397 int use_param_num = -1; 2398 int use_params_p = 0; 2399 int atomic_p = 0; 2400 options_p oo; 2401 const struct nested_ptr_data *nested_ptr_d = NULL; 2402 2403 d->needs_cast_p = false; 2404 for (oo = d->opt; oo; oo = oo->next) 2405 if (strcmp (oo->name, "length") == 0 && oo->kind == OPTION_STRING) 2406 length = oo->info.string; 2407 else if (strcmp (oo->name, "maybe_undef") == 0) 2408 maybe_undef_p = 1; 2409 else if (strncmp (oo->name, "use_param", 9) == 0 2410 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9]))) 2411 use_param_num = oo->name[9] == '\0' ? 0 : oo->name[9] - '0'; 2412 else if (strcmp (oo->name, "use_params") == 0) 2413 use_params_p = 1; 2414 else if (strcmp (oo->name, "desc") == 0 && oo->kind == OPTION_STRING) 2415 desc = oo->info.string; 2416 else if (strcmp (oo->name, "mark_hook") == 0) 2417 ; 2418 else if (strcmp (oo->name, "nested_ptr") == 0 2419 && oo->kind == OPTION_NESTED) 2420 nested_ptr_d = (const struct nested_ptr_data *) oo->info.nested; 2421 else if (strcmp (oo->name, "dot") == 0) 2422 ; 2423 else if (strcmp (oo->name, "tag") == 0) 2424 ; 2425 else if (strcmp (oo->name, "special") == 0) 2426 ; 2427 else if (strcmp (oo->name, "skip") == 0) 2428 ; 2429 else if (strcmp (oo->name, "atomic") == 0) 2430 atomic_p = 1; 2431 else if (strcmp (oo->name, "default") == 0) 2432 ; 2433 else if (strcmp (oo->name, "param_is") == 0) 2434 ; 2435 else if (strncmp (oo->name, "param", 5) == 0 2436 && ISDIGIT (oo->name[5]) && strcmp (oo->name + 6, "_is") == 0) 2437 ; 2438 else if (strcmp (oo->name, "chain_next") == 0) 2439 ; 2440 else if (strcmp (oo->name, "chain_prev") == 0) 2441 ; 2442 else if (strcmp (oo->name, "chain_circular") == 0) 2443 ; 2444 else if (strcmp (oo->name, "reorder") == 0) 2445 ; 2446 else if (strcmp (oo->name, "variable_size") == 0) 2447 ; 2448 else 2449 error_at_line (d->line, "unknown option `%s'\n", oo->name); 2450 2451 if (d->used_length) 2452 length = NULL; 2453 2454 if (use_params_p) 2455 { 2456 int pointer_p = t->kind == TYPE_POINTER; 2457 2458 if (pointer_p) 2459 t = t->u.p; 2460 if (!UNION_OR_STRUCT_P (t)) 2461 error_at_line (d->line, "`use_params' option on unimplemented type"); 2462 else 2463 t = find_param_structure (t, d->param); 2464 if (pointer_p) 2465 t = create_pointer (t); 2466 } 2467 2468 if (use_param_num != -1) 2469 { 2470 if (d->param != NULL && d->param[use_param_num] != NULL) 2471 { 2472 type_p nt = d->param[use_param_num]; 2473 2474 if (t->kind == TYPE_ARRAY) 2475 nt = create_array (nt, t->u.a.len); 2476 else if (length != NULL && t->kind == TYPE_POINTER) 2477 nt = create_pointer (nt); 2478 d->needs_cast_p = (t->kind != TYPE_POINTER 2479 && (nt->kind == TYPE_POINTER 2480 || nt->kind == TYPE_STRING)); 2481 t = nt; 2482 } 2483 else 2484 error_at_line (d->line, "no parameter defined for `%s'", d->val); 2485 } 2486 2487 if (maybe_undef_p 2488 && (t->kind != TYPE_POINTER || !UNION_OR_STRUCT_P (t->u.p))) 2489 { 2490 error_at_line (d->line, 2491 "field `%s' has invalid option `maybe_undef_p'\n", 2492 d->val); 2493 return; 2494 } 2495 2496 if (atomic_p && (t->kind != TYPE_POINTER)) 2497 { 2498 error_at_line (d->line, "field `%s' has invalid option `atomic'\n", d->val); 2499 return; 2500 } 2501 2502 switch (t->kind) 2503 { 2504 case TYPE_SCALAR: 2505 case TYPE_STRING: 2506 d->process_field (t, d); 2507 break; 2508 2509 case TYPE_POINTER: 2510 { 2511 if (maybe_undef_p && t->u.p->u.s.line.file == NULL) 2512 { 2513 oprintf (d->of, "%*sgcc_assert (!%s);\n", d->indent, "", d->val); 2514 break; 2515 } 2516 2517 /* If a pointer type is marked as "atomic", we process the 2518 field itself, but we don't walk the data that they point to. 2519 2520 There are two main cases where we walk types: to mark 2521 pointers that are reachable, and to relocate pointers when 2522 writing a PCH file. In both cases, an atomic pointer is 2523 itself marked or relocated, but the memory that it points 2524 to is left untouched. In the case of PCH, that memory will 2525 be read/written unchanged to the PCH file. */ 2526 if (atomic_p) 2527 { 2528 oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val); 2529 d->indent += 2; 2530 d->process_field (t, d); 2531 d->indent -= 2; 2532 oprintf (d->of, "%*s}\n", d->indent, ""); 2533 break; 2534 } 2535 2536 if (!length) 2537 { 2538 if (!UNION_OR_STRUCT_P (t->u.p) 2539 && t->u.p->kind != TYPE_PARAM_STRUCT) 2540 { 2541 error_at_line (d->line, 2542 "field `%s' is pointer to unimplemented type", 2543 d->val); 2544 break; 2545 } 2546 2547 if (nested_ptr_d) 2548 { 2549 const char *oldprevval2 = d->prev_val[2]; 2550 2551 if (!UNION_OR_STRUCT_P (nested_ptr_d->type)) 2552 { 2553 error_at_line (d->line, 2554 "field `%s' has invalid " 2555 "option `nested_ptr'\n", d->val); 2556 return; 2557 } 2558 2559 d->prev_val[2] = d->val; 2560 oprintf (d->of, "%*s{\n", d->indent, ""); 2561 d->indent += 2; 2562 d->val = xasprintf ("x%d", d->counter++); 2563 oprintf (d->of, "%*s%s %s * %s%s =\n", d->indent, "", 2564 (nested_ptr_d->type->kind == TYPE_UNION 2565 ? "union" : "struct"), 2566 nested_ptr_d->type->u.s.tag, 2567 d->fn_wants_lvalue ? "" : "const ", d->val); 2568 oprintf (d->of, "%*s", d->indent + 2, ""); 2569 output_escaped_param (d, nested_ptr_d->convert_from, 2570 "nested_ptr"); 2571 oprintf (d->of, ";\n"); 2572 2573 d->process_field (nested_ptr_d->type, d); 2574 2575 if (d->fn_wants_lvalue) 2576 { 2577 oprintf (d->of, "%*s%s = ", d->indent, "", 2578 d->prev_val[2]); 2579 d->prev_val[2] = d->val; 2580 output_escaped_param (d, nested_ptr_d->convert_to, 2581 "nested_ptr"); 2582 oprintf (d->of, ";\n"); 2583 } 2584 2585 d->indent -= 2; 2586 oprintf (d->of, "%*s}\n", d->indent, ""); 2587 d->val = d->prev_val[2]; 2588 d->prev_val[2] = oldprevval2; 2589 } 2590 else 2591 d->process_field (t->u.p, d); 2592 } 2593 else 2594 { 2595 int loopcounter = d->counter++; 2596 const char *oldval = d->val; 2597 const char *oldprevval3 = d->prev_val[3]; 2598 char *newval; 2599 2600 oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val); 2601 d->indent += 2; 2602 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter); 2603 oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent, 2604 "", loopcounter, loopcounter); 2605 output_escaped_param (d, length, "length"); 2606 oprintf (d->of, "); i%d++) {\n", loopcounter); 2607 d->indent += 2; 2608 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter); 2609 d->used_length = 1; 2610 d->prev_val[3] = oldval; 2611 walk_type (t->u.p, d); 2612 free (newval); 2613 d->val = oldval; 2614 d->prev_val[3] = oldprevval3; 2615 d->used_length = 0; 2616 d->indent -= 2; 2617 oprintf (d->of, "%*s}\n", d->indent, ""); 2618 d->process_field (t, d); 2619 d->indent -= 2; 2620 oprintf (d->of, "%*s}\n", d->indent, ""); 2621 } 2622 } 2623 break; 2624 2625 case TYPE_ARRAY: 2626 { 2627 int loopcounter = d->counter++; 2628 const char *oldval = d->val; 2629 char *newval; 2630 2631 /* If it's an array of scalars, we optimize by not generating 2632 any code. */ 2633 if (t->u.a.p->kind == TYPE_SCALAR) 2634 break; 2635 2636 /* When walking an array, compute the length and store it in a 2637 local variable before walking the array elements, instead of 2638 recomputing the length expression each time through the loop. 2639 This is necessary to handle tcc_vl_exp objects like CALL_EXPR, 2640 where the length is stored in the first array element, 2641 because otherwise that operand can get overwritten on the 2642 first iteration. */ 2643 oprintf (d->of, "%*s{\n", d->indent, ""); 2644 d->indent += 2; 2645 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter); 2646 oprintf (d->of, "%*ssize_t l%d = (size_t)(", 2647 d->indent, "", loopcounter); 2648 if (length) 2649 output_escaped_param (d, length, "length"); 2650 else 2651 oprintf (d->of, "%s", t->u.a.len); 2652 oprintf (d->of, ");\n"); 2653 2654 oprintf (d->of, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n", 2655 d->indent, "", 2656 loopcounter, loopcounter, loopcounter, loopcounter); 2657 d->indent += 2; 2658 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter); 2659 d->used_length = 1; 2660 walk_type (t->u.a.p, d); 2661 free (newval); 2662 d->used_length = 0; 2663 d->val = oldval; 2664 d->indent -= 2; 2665 oprintf (d->of, "%*s}\n", d->indent, ""); 2666 d->indent -= 2; 2667 oprintf (d->of, "%*s}\n", d->indent, ""); 2668 } 2669 break; 2670 2671 case TYPE_STRUCT: 2672 case TYPE_UNION: 2673 { 2674 pair_p f; 2675 const char *oldval = d->val; 2676 const char *oldprevval1 = d->prev_val[1]; 2677 const char *oldprevval2 = d->prev_val[2]; 2678 const int union_p = t->kind == TYPE_UNION; 2679 int seen_default_p = 0; 2680 options_p o; 2681 2682 if (!t->u.s.line.file) 2683 error_at_line (d->line, "incomplete structure `%s'", t->u.s.tag); 2684 2685 if ((d->bitmap & t->u.s.bitmap) != d->bitmap) 2686 { 2687 error_at_line (d->line, 2688 "structure `%s' defined for mismatching languages", 2689 t->u.s.tag); 2690 error_at_line (&t->u.s.line, "one structure defined here"); 2691 } 2692 2693 /* Some things may also be defined in the structure's options. */ 2694 for (o = t->u.s.opt; o; o = o->next) 2695 if (!desc && strcmp (o->name, "desc") == 0 2696 && o->kind == OPTION_STRING) 2697 desc = o->info.string; 2698 2699 d->prev_val[2] = oldval; 2700 d->prev_val[1] = oldprevval2; 2701 if (union_p) 2702 { 2703 if (desc == NULL) 2704 { 2705 error_at_line (d->line, 2706 "missing `desc' option for union `%s'", 2707 t->u.s.tag); 2708 desc = "1"; 2709 } 2710 oprintf (d->of, "%*sswitch (", d->indent, ""); 2711 output_escaped_param (d, desc, "desc"); 2712 oprintf (d->of, ")\n"); 2713 d->indent += 2; 2714 oprintf (d->of, "%*s{\n", d->indent, ""); 2715 } 2716 for (f = t->u.s.fields; f; f = f->next) 2717 { 2718 options_p oo; 2719 const char *dot = "."; 2720 const char *tagid = NULL; 2721 int skip_p = 0; 2722 int default_p = 0; 2723 int use_param_p = 0; 2724 char *newval; 2725 2726 d->reorder_fn = NULL; 2727 for (oo = f->opt; oo; oo = oo->next) 2728 if (strcmp (oo->name, "dot") == 0 2729 && oo->kind == OPTION_STRING) 2730 dot = oo->info.string; 2731 else if (strcmp (oo->name, "tag") == 0 2732 && oo->kind == OPTION_STRING) 2733 tagid = oo->info.string; 2734 else if (strcmp (oo->name, "skip") == 0) 2735 skip_p = 1; 2736 else if (strcmp (oo->name, "default") == 0) 2737 default_p = 1; 2738 else if (strcmp (oo->name, "reorder") == 0 2739 && oo->kind == OPTION_STRING) 2740 d->reorder_fn = oo->info.string; 2741 else if (strncmp (oo->name, "use_param", 9) == 0 2742 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9]))) 2743 use_param_p = 1; 2744 2745 if (skip_p) 2746 continue; 2747 2748 if (union_p && tagid) 2749 { 2750 oprintf (d->of, "%*scase %s:\n", d->indent, "", tagid); 2751 d->indent += 2; 2752 } 2753 else if (union_p && default_p) 2754 { 2755 oprintf (d->of, "%*sdefault:\n", d->indent, ""); 2756 d->indent += 2; 2757 seen_default_p = 1; 2758 } 2759 else if (!union_p && (default_p || tagid)) 2760 error_at_line (d->line, 2761 "can't use `%s' outside a union on field `%s'", 2762 default_p ? "default" : "tag", f->name); 2763 else if (union_p && !(default_p || tagid) 2764 && f->type->kind == TYPE_SCALAR) 2765 { 2766 fprintf (stderr, 2767 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n", 2768 get_input_file_name (d->line->file), d->line->line, 2769 f->name); 2770 continue; 2771 } 2772 else if (union_p && !(default_p || tagid)) 2773 error_at_line (d->line, 2774 "field `%s' is missing `tag' or `default' option", 2775 f->name); 2776 2777 d->line = &f->line; 2778 d->val = newval = xasprintf ("%s%s%s", oldval, dot, f->name); 2779 d->opt = f->opt; 2780 d->used_length = false; 2781 2782 if (union_p && use_param_p && d->param == NULL) 2783 oprintf (d->of, "%*sgcc_unreachable ();\n", d->indent, ""); 2784 else 2785 walk_type (f->type, d); 2786 2787 free (newval); 2788 2789 if (union_p) 2790 { 2791 oprintf (d->of, "%*sbreak;\n", d->indent, ""); 2792 d->indent -= 2; 2793 } 2794 } 2795 d->reorder_fn = NULL; 2796 2797 d->val = oldval; 2798 d->prev_val[1] = oldprevval1; 2799 d->prev_val[2] = oldprevval2; 2800 2801 if (union_p && !seen_default_p) 2802 { 2803 oprintf (d->of, "%*sdefault:\n", d->indent, ""); 2804 oprintf (d->of, "%*s break;\n", d->indent, ""); 2805 } 2806 if (union_p) 2807 { 2808 oprintf (d->of, "%*s}\n", d->indent, ""); 2809 d->indent -= 2; 2810 } 2811 } 2812 break; 2813 2814 case TYPE_LANG_STRUCT: 2815 { 2816 type_p nt; 2817 for (nt = t->u.s.lang_struct; nt; nt = nt->next) 2818 if ((d->bitmap & nt->u.s.bitmap) == d->bitmap) 2819 break; 2820 if (nt == NULL) 2821 error_at_line (d->line, "structure `%s' differs between languages", 2822 t->u.s.tag); 2823 else 2824 walk_type (nt, d); 2825 } 2826 break; 2827 2828 case TYPE_PARAM_STRUCT: 2829 { 2830 type_p *oldparam = d->param; 2831 2832 d->param = t->u.param_struct.param; 2833 walk_type (t->u.param_struct.stru, d); 2834 d->param = oldparam; 2835 } 2836 break; 2837 2838 default: 2839 gcc_unreachable (); 2840 } 2841 } 2842 2843 /* process_field routine for marking routines. */ 2844 2845 static void 2846 write_types_process_field (type_p f, const struct walk_type_data *d) 2847 { 2848 const struct write_types_data *wtd; 2849 const char *cast = d->needs_cast_p ? "(void *)" : ""; 2850 wtd = (const struct write_types_data *) d->cookie; 2851 2852 switch (f->kind) 2853 { 2854 case TYPE_NONE: 2855 gcc_unreachable (); 2856 case TYPE_POINTER: 2857 oprintf (d->of, "%*s%s (%s%s", d->indent, "", 2858 wtd->subfield_marker_routine, cast, d->val); 2859 if (wtd->param_prefix) 2860 { 2861 oprintf (d->of, ", %s", d->prev_val[3]); 2862 if (d->orig_s) 2863 { 2864 oprintf (d->of, ", gt_%s_", wtd->param_prefix); 2865 output_mangled_typename (d->of, d->orig_s); 2866 } 2867 else 2868 oprintf (d->of, ", gt_%sa_%s", wtd->param_prefix, d->prev_val[0]); 2869 2870 if (f->u.p->kind == TYPE_PARAM_STRUCT 2871 && f->u.p->u.s.line.file != NULL) 2872 { 2873 oprintf (d->of, ", gt_e_"); 2874 output_mangled_typename (d->of, f); 2875 } 2876 else if (UNION_OR_STRUCT_P (f) && f->u.p->u.s.line.file != NULL) 2877 { 2878 oprintf (d->of, ", gt_ggc_e_"); 2879 output_mangled_typename (d->of, f); 2880 } 2881 else 2882 oprintf (d->of, ", gt_types_enum_last"); 2883 } 2884 oprintf (d->of, ");\n"); 2885 if (d->reorder_fn && wtd->reorder_note_routine) 2886 oprintf (d->of, "%*s%s (%s%s, %s, %s);\n", d->indent, "", 2887 wtd->reorder_note_routine, cast, d->val, 2888 d->prev_val[3], d->reorder_fn); 2889 break; 2890 2891 case TYPE_STRING: 2892 case TYPE_STRUCT: 2893 case TYPE_UNION: 2894 case TYPE_LANG_STRUCT: 2895 case TYPE_PARAM_STRUCT: 2896 oprintf (d->of, "%*sgt_%s_", d->indent, "", wtd->prefix); 2897 output_mangled_typename (d->of, f); 2898 oprintf (d->of, " (%s%s);\n", cast, d->val); 2899 if (d->reorder_fn && wtd->reorder_note_routine) 2900 oprintf (d->of, "%*s%s (%s%s, %s%s, %s);\n", d->indent, "", 2901 wtd->reorder_note_routine, cast, d->val, cast, d->val, 2902 d->reorder_fn); 2903 break; 2904 2905 case TYPE_SCALAR: 2906 break; 2907 2908 case TYPE_ARRAY: 2909 gcc_unreachable (); 2910 } 2911 } 2912 2913 /* A subroutine of write_func_for_structure. Write the enum tag for S. */ 2914 2915 static void 2916 output_type_enum (outf_p of, type_p s) 2917 { 2918 if (s->kind == TYPE_PARAM_STRUCT && s->u.param_struct.line.file != NULL) 2919 { 2920 oprintf (of, ", gt_e_"); 2921 output_mangled_typename (of, s); 2922 } 2923 else if (UNION_OR_STRUCT_P (s) && s->u.s.line.file != NULL) 2924 { 2925 oprintf (of, ", gt_ggc_e_"); 2926 output_mangled_typename (of, s); 2927 } 2928 else 2929 oprintf (of, ", gt_types_enum_last"); 2930 } 2931 2932 /* Return an output file that is suitable for definitions which can 2933 reference struct S */ 2934 2935 static outf_p 2936 get_output_file_for_structure (const_type_p s, type_p *param) 2937 { 2938 const input_file *fn; 2939 int i; 2940 2941 gcc_assert (UNION_OR_STRUCT_P (s)); 2942 fn = s->u.s.line.file; 2943 2944 /* This is a hack, and not the good kind either. */ 2945 for (i = NUM_PARAM - 1; i >= 0; i--) 2946 if (param && param[i] && param[i]->kind == TYPE_POINTER 2947 && UNION_OR_STRUCT_P (param[i]->u.p)) 2948 fn = param[i]->u.p->u.s.line.file; 2949 2950 /* The call to get_output_file_with_visibility may update fn by 2951 caching its result inside, so we need the CONST_CAST. */ 2952 return get_output_file_with_visibility (CONST_CAST (input_file*, fn)); 2953 } 2954 2955 /* For S, a structure that's part of ORIG_S, and using parameters 2956 PARAM, write out a routine that: 2957 - Takes a parameter, a void * but actually of type *S 2958 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each 2959 field of S or its substructures and (in some cases) things 2960 that are pointed to by S. 2961 */ 2962 2963 static void 2964 write_func_for_structure (type_p orig_s, type_p s, type_p *param, 2965 const struct write_types_data *wtd) 2966 { 2967 const char *chain_next = NULL; 2968 const char *chain_prev = NULL; 2969 const char *chain_circular = NULL; 2970 const char *mark_hook_name = NULL; 2971 options_p opt; 2972 struct walk_type_data d; 2973 2974 memset (&d, 0, sizeof (d)); 2975 d.of = get_output_file_for_structure (s, param); 2976 for (opt = s->u.s.opt; opt; opt = opt->next) 2977 if (strcmp (opt->name, "chain_next") == 0 2978 && opt->kind == OPTION_STRING) 2979 chain_next = opt->info.string; 2980 else if (strcmp (opt->name, "chain_prev") == 0 2981 && opt->kind == OPTION_STRING) 2982 chain_prev = opt->info.string; 2983 else if (strcmp (opt->name, "chain_circular") == 0 2984 && opt->kind == OPTION_STRING) 2985 chain_circular = opt->info.string; 2986 else if (strcmp (opt->name, "mark_hook") == 0 2987 && opt->kind == OPTION_STRING) 2988 mark_hook_name = opt->info.string; 2989 if (chain_prev != NULL && chain_next == NULL) 2990 error_at_line (&s->u.s.line, "chain_prev without chain_next"); 2991 if (chain_circular != NULL && chain_next != NULL) 2992 error_at_line (&s->u.s.line, "chain_circular with chain_next"); 2993 if (chain_circular != NULL) 2994 chain_next = chain_circular; 2995 2996 d.process_field = write_types_process_field; 2997 d.cookie = wtd; 2998 d.orig_s = orig_s; 2999 d.opt = s->u.s.opt; 3000 d.line = &s->u.s.line; 3001 d.bitmap = s->u.s.bitmap; 3002 d.param = param; 3003 d.prev_val[0] = "*x"; 3004 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */ 3005 d.prev_val[3] = "x"; 3006 d.val = "(*x)"; 3007 3008 oprintf (d.of, "\n"); 3009 oprintf (d.of, "void\n"); 3010 if (param == NULL) 3011 oprintf (d.of, "gt_%sx_%s", wtd->prefix, orig_s->u.s.tag); 3012 else 3013 { 3014 oprintf (d.of, "gt_%s_", wtd->prefix); 3015 output_mangled_typename (d.of, orig_s); 3016 } 3017 oprintf (d.of, " (void *x_p)\n"); 3018 oprintf (d.of, "{\n"); 3019 oprintf (d.of, " %s %s * %sx = (%s %s *)x_p;\n", 3020 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag, 3021 chain_next == NULL ? "const " : "", 3022 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag); 3023 if (chain_next != NULL) 3024 oprintf (d.of, " %s %s * xlimit = x;\n", 3025 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag); 3026 if (chain_next == NULL) 3027 { 3028 oprintf (d.of, " if (%s (x", wtd->marker_routine); 3029 if (wtd->param_prefix) 3030 { 3031 oprintf (d.of, ", x, gt_%s_", wtd->param_prefix); 3032 output_mangled_typename (d.of, orig_s); 3033 output_type_enum (d.of, orig_s); 3034 } 3035 oprintf (d.of, "))\n"); 3036 } 3037 else 3038 { 3039 if (chain_circular != NULL) 3040 oprintf (d.of, " if (!%s (xlimit", wtd->marker_routine); 3041 else 3042 oprintf (d.of, " while (%s (xlimit", wtd->marker_routine); 3043 if (wtd->param_prefix) 3044 { 3045 oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix); 3046 output_mangled_typename (d.of, orig_s); 3047 output_type_enum (d.of, orig_s); 3048 } 3049 oprintf (d.of, "))\n"); 3050 if (chain_circular != NULL) 3051 oprintf (d.of, " return;\n do\n"); 3052 if (mark_hook_name && !wtd->skip_hooks) 3053 { 3054 oprintf (d.of, " {\n"); 3055 oprintf (d.of, " %s (xlimit);\n ", mark_hook_name); 3056 } 3057 oprintf (d.of, " xlimit = ("); 3058 d.prev_val[2] = "*xlimit"; 3059 output_escaped_param (&d, chain_next, "chain_next"); 3060 oprintf (d.of, ");\n"); 3061 if (mark_hook_name && !wtd->skip_hooks) 3062 oprintf (d.of, " }\n"); 3063 if (chain_prev != NULL) 3064 { 3065 oprintf (d.of, " if (x != xlimit)\n"); 3066 oprintf (d.of, " for (;;)\n"); 3067 oprintf (d.of, " {\n"); 3068 oprintf (d.of, " %s %s * const xprev = (", 3069 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag); 3070 3071 d.prev_val[2] = "*x"; 3072 output_escaped_param (&d, chain_prev, "chain_prev"); 3073 oprintf (d.of, ");\n"); 3074 oprintf (d.of, " if (xprev == NULL) break;\n"); 3075 oprintf (d.of, " x = xprev;\n"); 3076 oprintf (d.of, " (void) %s (xprev", wtd->marker_routine); 3077 if (wtd->param_prefix) 3078 { 3079 oprintf (d.of, ", xprev, gt_%s_", wtd->param_prefix); 3080 output_mangled_typename (d.of, orig_s); 3081 output_type_enum (d.of, orig_s); 3082 } 3083 oprintf (d.of, ");\n"); 3084 oprintf (d.of, " }\n"); 3085 } 3086 if (chain_circular != NULL) 3087 { 3088 oprintf (d.of, " while (%s (xlimit", wtd->marker_routine); 3089 if (wtd->param_prefix) 3090 { 3091 oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix); 3092 output_mangled_typename (d.of, orig_s); 3093 output_type_enum (d.of, orig_s); 3094 } 3095 oprintf (d.of, "));\n"); 3096 if (mark_hook_name && !wtd->skip_hooks) 3097 oprintf (d.of, " %s (xlimit);\n", mark_hook_name); 3098 oprintf (d.of, " do\n"); 3099 } 3100 else 3101 oprintf (d.of, " while (x != xlimit)\n"); 3102 } 3103 oprintf (d.of, " {\n"); 3104 if (mark_hook_name && chain_next == NULL && !wtd->skip_hooks) 3105 { 3106 oprintf (d.of, " %s (x);\n", mark_hook_name); 3107 } 3108 d.prev_val[2] = "*x"; 3109 d.indent = 6; 3110 walk_type (s, &d); 3111 3112 if (chain_next != NULL) 3113 { 3114 oprintf (d.of, " x = ("); 3115 output_escaped_param (&d, chain_next, "chain_next"); 3116 oprintf (d.of, ");\n"); 3117 } 3118 3119 oprintf (d.of, " }\n"); 3120 if (chain_circular != NULL) 3121 oprintf (d.of, " while (x != xlimit);\n"); 3122 oprintf (d.of, "}\n"); 3123 } 3124 3125 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */ 3126 3127 static void 3128 write_types (outf_p output_header, type_p structures, type_p param_structs, 3129 const struct write_types_data *wtd) 3130 { 3131 int nbfun = 0; /* Count the emitted functions. */ 3132 type_p s; 3133 3134 oprintf (output_header, "\n/* %s*/\n", wtd->comment); 3135 /* We first emit the macros and the declarations. Functions' code is 3136 emitted afterwards. This is needed in plugin mode. */ 3137 oprintf (output_header, "/* macros and declarations */\n"); 3138 for (s = structures; s; s = s->next) 3139 if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO) 3140 { 3141 options_p opt; 3142 3143 if (s->gc_used == GC_MAYBE_POINTED_TO && s->u.s.line.file == NULL) 3144 continue; 3145 3146 oprintf (output_header, "#define gt_%s_", wtd->prefix); 3147 output_mangled_typename (output_header, s); 3148 oprintf (output_header, "(X) do { \\\n"); 3149 oprintf (output_header, 3150 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd->prefix, 3151 s->u.s.tag); 3152 oprintf (output_header, " } while (0)\n"); 3153 3154 for (opt = s->u.s.opt; opt; opt = opt->next) 3155 if (strcmp (opt->name, "ptr_alias") == 0 3156 && opt->kind == OPTION_TYPE) 3157 { 3158 const_type_p const t = (const_type_p) opt->info.type; 3159 if (t->kind == TYPE_STRUCT 3160 || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT) 3161 oprintf (output_header, 3162 "#define gt_%sx_%s gt_%sx_%s\n", 3163 wtd->prefix, s->u.s.tag, wtd->prefix, t->u.s.tag); 3164 else 3165 error_at_line (&s->u.s.line, 3166 "structure alias is not a structure"); 3167 break; 3168 } 3169 if (opt) 3170 continue; 3171 3172 /* Declare the marker procedure only once. */ 3173 oprintf (output_header, 3174 "extern void gt_%sx_%s (void *);\n", 3175 wtd->prefix, s->u.s.tag); 3176 3177 if (s->u.s.line.file == NULL) 3178 { 3179 fprintf (stderr, "warning: structure `%s' used but not defined\n", 3180 s->u.s.tag); 3181 continue; 3182 } 3183 } 3184 3185 for (s = param_structs; s; s = s->next) 3186 if (s->gc_used == GC_POINTED_TO) 3187 { 3188 type_p stru = s->u.param_struct.stru; 3189 3190 /* Declare the marker procedure. */ 3191 oprintf (output_header, "extern void gt_%s_", wtd->prefix); 3192 output_mangled_typename (output_header, s); 3193 oprintf (output_header, " (void *);\n"); 3194 3195 if (stru->u.s.line.file == NULL) 3196 { 3197 fprintf (stderr, "warning: structure `%s' used but not defined\n", 3198 s->u.s.tag); 3199 continue; 3200 } 3201 } 3202 3203 /* At last we emit the functions code. */ 3204 oprintf (output_header, "\n/* functions code */\n"); 3205 for (s = structures; s; s = s->next) 3206 if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO) 3207 { 3208 options_p opt; 3209 3210 if (s->gc_used == GC_MAYBE_POINTED_TO && s->u.s.line.file == NULL) 3211 continue; 3212 for (opt = s->u.s.opt; opt; opt = opt->next) 3213 if (strcmp (opt->name, "ptr_alias") == 0) 3214 break; 3215 if (opt) 3216 continue; 3217 3218 if (s->kind == TYPE_LANG_STRUCT) 3219 { 3220 type_p ss; 3221 for (ss = s->u.s.lang_struct; ss; ss = ss->next) 3222 { 3223 nbfun++; 3224 DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'", 3225 nbfun, (void*) ss, ss->u.s.tag); 3226 write_func_for_structure (s, ss, NULL, wtd); 3227 } 3228 } 3229 else 3230 { 3231 nbfun++; 3232 DBGPRINTF ("writing func #%d struct s @ %p '%s'", 3233 nbfun, (void*) s, s->u.s.tag); 3234 write_func_for_structure (s, s, NULL, wtd); 3235 } 3236 } 3237 else 3238 { 3239 /* Structure s is not possibly pointed to, so can be ignored. */ 3240 DBGPRINTF ("ignored s @ %p '%s' gc_used#%d", 3241 (void*)s, s->u.s.tag, 3242 (int) s->gc_used); 3243 } 3244 3245 for (s = param_structs; s; s = s->next) 3246 if (s->gc_used == GC_POINTED_TO) 3247 { 3248 type_p *param = s->u.param_struct.param; 3249 type_p stru = s->u.param_struct.stru; 3250 if (stru->u.s.line.file == NULL) 3251 continue; 3252 if (stru->kind == TYPE_LANG_STRUCT) 3253 { 3254 type_p ss; 3255 for (ss = stru->u.s.lang_struct; ss; ss = ss->next) 3256 { 3257 nbfun++; 3258 DBGPRINTF ("writing func #%d param lang_struct ss @ %p '%s'", 3259 nbfun, (void*) ss, ss->u.s.tag); 3260 write_func_for_structure (s, ss, param, wtd); 3261 } 3262 } 3263 else 3264 { 3265 nbfun++; 3266 DBGPRINTF ("writing func #%d param struct s @ %p stru @ %p '%s'", 3267 nbfun, (void*) s, 3268 (void*) stru, stru->u.s.tag); 3269 write_func_for_structure (s, stru, param, wtd); 3270 } 3271 } 3272 else 3273 { 3274 /* Param structure s is not pointed to, so should be ignored. */ 3275 DBGPRINTF ("ignored s @ %p", (void*)s); 3276 } 3277 if (verbosity_level >= 2) 3278 printf ("%s emitted %d routines for %s\n", 3279 progname, nbfun, wtd->comment); 3280 } 3281 3282 static const struct write_types_data ggc_wtd = { 3283 "ggc_m", NULL, "ggc_mark", "ggc_test_and_set_mark", NULL, 3284 "GC marker procedures. ", 3285 FALSE 3286 }; 3287 3288 static const struct write_types_data pch_wtd = { 3289 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object", 3290 "gt_pch_note_reorder", 3291 "PCH type-walking procedures. ", 3292 TRUE 3293 }; 3294 3295 /* Write out the local pointer-walking routines. */ 3296 3297 /* process_field routine for local pointer-walking. */ 3298 3299 static void 3300 write_types_local_process_field (type_p f, const struct walk_type_data *d) 3301 { 3302 switch (f->kind) 3303 { 3304 case TYPE_POINTER: 3305 case TYPE_STRUCT: 3306 case TYPE_UNION: 3307 case TYPE_LANG_STRUCT: 3308 case TYPE_PARAM_STRUCT: 3309 case TYPE_STRING: 3310 oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "", 3311 d->prev_val[3]); 3312 oprintf (d->of, "%*s op (&(%s), cookie);\n", d->indent, "", d->val); 3313 break; 3314 3315 case TYPE_SCALAR: 3316 break; 3317 3318 default: 3319 gcc_unreachable (); 3320 } 3321 } 3322 3323 /* For S, a structure that's part of ORIG_S, and using parameters 3324 PARAM, write out a routine that: 3325 - Is of type gt_note_pointers 3326 - Calls PROCESS_FIELD on each field of S or its substructures. 3327 */ 3328 3329 static void 3330 write_local_func_for_structure (const_type_p orig_s, type_p s, type_p *param) 3331 { 3332 struct walk_type_data d; 3333 3334 memset (&d, 0, sizeof (d)); 3335 d.of = get_output_file_for_structure (s, param); 3336 d.process_field = write_types_local_process_field; 3337 d.opt = s->u.s.opt; 3338 d.line = &s->u.s.line; 3339 d.bitmap = s->u.s.bitmap; 3340 d.param = param; 3341 d.prev_val[0] = d.prev_val[2] = "*x"; 3342 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */ 3343 d.prev_val[3] = "x"; 3344 d.val = "(*x)"; 3345 d.fn_wants_lvalue = true; 3346 3347 oprintf (d.of, "\n"); 3348 oprintf (d.of, "void\n"); 3349 oprintf (d.of, "gt_pch_p_"); 3350 output_mangled_typename (d.of, orig_s); 3351 oprintf (d.of, " (ATTRIBUTE_UNUSED void *this_obj,\n" 3352 "\tvoid *x_p,\n" 3353 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n" 3354 "\tATTRIBUTE_UNUSED void *cookie)\n"); 3355 oprintf (d.of, "{\n"); 3356 oprintf (d.of, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n", 3357 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag, 3358 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag); 3359 d.indent = 2; 3360 walk_type (s, &d); 3361 oprintf (d.of, "}\n"); 3362 } 3363 3364 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */ 3365 3366 static void 3367 write_local (outf_p output_header, type_p structures, type_p param_structs) 3368 { 3369 type_p s; 3370 3371 if (!output_header) 3372 return; 3373 oprintf (output_header, "\n/* Local pointer-walking routines. */\n"); 3374 for (s = structures; s; s = s->next) 3375 if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO) 3376 { 3377 options_p opt; 3378 3379 if (s->u.s.line.file == NULL) 3380 continue; 3381 for (opt = s->u.s.opt; opt; opt = opt->next) 3382 if (strcmp (opt->name, "ptr_alias") == 0 3383 && opt->kind == OPTION_TYPE) 3384 { 3385 const_type_p const t = (const_type_p) opt->info.type; 3386 if (t->kind == TYPE_STRUCT 3387 || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT) 3388 { 3389 oprintf (output_header, "#define gt_pch_p_"); 3390 output_mangled_typename (output_header, s); 3391 oprintf (output_header, " gt_pch_p_"); 3392 output_mangled_typename (output_header, t); 3393 oprintf (output_header, "\n"); 3394 } 3395 else 3396 error_at_line (&s->u.s.line, 3397 "structure alias is not a structure"); 3398 break; 3399 } 3400 if (opt) 3401 continue; 3402 3403 /* Declare the marker procedure only once. */ 3404 oprintf (output_header, "extern void gt_pch_p_"); 3405 output_mangled_typename (output_header, s); 3406 oprintf (output_header, 3407 "\n (void *, void *, gt_pointer_operator, void *);\n"); 3408 3409 if (s->kind == TYPE_LANG_STRUCT) 3410 { 3411 type_p ss; 3412 for (ss = s->u.s.lang_struct; ss; ss = ss->next) 3413 write_local_func_for_structure (s, ss, NULL); 3414 } 3415 else 3416 write_local_func_for_structure (s, s, NULL); 3417 } 3418 3419 for (s = param_structs; s; s = s->next) 3420 if (s->gc_used == GC_POINTED_TO) 3421 { 3422 type_p *param = s->u.param_struct.param; 3423 type_p stru = s->u.param_struct.stru; 3424 3425 /* Declare the marker procedure. */ 3426 oprintf (output_header, "extern void gt_pch_p_"); 3427 output_mangled_typename (output_header, s); 3428 oprintf (output_header, 3429 "\n (void *, void *, gt_pointer_operator, void *);\n"); 3430 3431 if (stru->u.s.line.file == NULL) 3432 { 3433 fprintf (stderr, "warning: structure `%s' used but not defined\n", 3434 s->u.s.tag); 3435 continue; 3436 } 3437 3438 if (stru->kind == TYPE_LANG_STRUCT) 3439 { 3440 type_p ss; 3441 for (ss = stru->u.s.lang_struct; ss; ss = ss->next) 3442 write_local_func_for_structure (s, ss, param); 3443 } 3444 else 3445 write_local_func_for_structure (s, stru, param); 3446 } 3447 } 3448 3449 /* Nonzero if S is a type for which typed GC allocators should be output. */ 3450 3451 #define USED_BY_TYPED_GC_P(s) \ 3452 (((s->kind == TYPE_POINTER) \ 3453 && ((s->u.p->gc_used == GC_POINTED_TO) \ 3454 || (s->u.p->gc_used == GC_USED))) \ 3455 || (UNION_OR_STRUCT_P (s) && \ 3456 (((s)->gc_used == GC_POINTED_TO) \ 3457 || ((s)->gc_used == GC_MAYBE_POINTED_TO \ 3458 && s->u.s.line.file != NULL) \ 3459 || ((s)->gc_used == GC_USED \ 3460 && strncmp (s->u.s.tag, "anonymous", strlen ("anonymous")))))) 3461 3462 3463 /* Write out the 'enum' definition for gt_types_enum. */ 3464 3465 static void 3466 write_enum_defn (type_p structures, type_p param_structs) 3467 { 3468 type_p s; 3469 int nbstruct = 0; 3470 int nbparamstruct = 0; 3471 3472 if (!header_file) 3473 return; 3474 oprintf (header_file, "\n/* Enumeration of types known. */\n"); 3475 oprintf (header_file, "enum gt_types_enum {\n"); 3476 for (s = structures; s; s = s->next) 3477 if (USED_BY_TYPED_GC_P (s)) 3478 { 3479 nbstruct++; 3480 DBGPRINTF ("write_enum_defn s @ %p nbstruct %d", 3481 (void*) s, nbstruct); 3482 if (UNION_OR_STRUCT_P (s)) 3483 DBGPRINTF ("write_enum_defn s %p #%d is unionorstruct tagged %s", 3484 (void*) s, nbstruct, s->u.s.tag); 3485 oprintf (header_file, " gt_ggc_e_"); 3486 output_mangled_typename (header_file, s); 3487 oprintf (header_file, ",\n"); 3488 } 3489 for (s = param_structs; s; s = s->next) 3490 if (s->gc_used == GC_POINTED_TO) 3491 { 3492 nbparamstruct++; 3493 DBGPRINTF ("write_enum_defn s %p nbparamstruct %d", 3494 (void*) s, nbparamstruct); 3495 oprintf (header_file, " gt_e_"); 3496 output_mangled_typename (header_file, s); 3497 oprintf (header_file, ",\n"); 3498 } 3499 oprintf (header_file, " gt_types_enum_last\n"); 3500 oprintf (header_file, "};\n"); 3501 if (verbosity_level >= 2) 3502 printf ("%s handled %d GTY-ed structures & %d parameterized structures.\n", 3503 progname, nbstruct, nbparamstruct); 3504 3505 } 3506 3507 /* Might T contain any non-pointer elements? */ 3508 3509 static int 3510 contains_scalar_p (type_p t) 3511 { 3512 switch (t->kind) 3513 { 3514 case TYPE_STRING: 3515 case TYPE_POINTER: 3516 return 0; 3517 case TYPE_ARRAY: 3518 return contains_scalar_p (t->u.a.p); 3519 default: 3520 /* Could also check for structures that have no non-pointer 3521 fields, but there aren't enough of those to worry about. */ 3522 return 1; 3523 } 3524 } 3525 3526 /* Mangle INPF and print it to F. */ 3527 3528 static void 3529 put_mangled_filename (outf_p f, const input_file *inpf) 3530 { 3531 /* The call to get_output_file_name may indirectly update fn since 3532 get_output_file_with_visibility caches its result inside, so we 3533 need the CONST_CAST. */ 3534 const char *name = get_output_file_name (CONST_CAST (input_file*, inpf)); 3535 if (!f || !name) 3536 return; 3537 for (; *name != 0; name++) 3538 if (ISALNUM (*name)) 3539 oprintf (f, "%c", *name); 3540 else 3541 oprintf (f, "%c", '_'); 3542 } 3543 3544 /* Finish off the currently-created root tables in FLP. PFX, TNAME, 3545 LASTNAME, and NAME are all strings to insert in various places in 3546 the resulting code. */ 3547 3548 static void 3549 finish_root_table (struct flist *flp, const char *pfx, const char *lastname, 3550 const char *tname, const char *name) 3551 { 3552 struct flist *fli2; 3553 3554 for (fli2 = flp; fli2; fli2 = fli2->next) 3555 if (fli2->started_p) 3556 { 3557 oprintf (fli2->f, " %s\n", lastname); 3558 oprintf (fli2->f, "};\n\n"); 3559 } 3560 3561 for (fli2 = flp; fli2 && base_files; fli2 = fli2->next) 3562 if (fli2->started_p) 3563 { 3564 lang_bitmap bitmap = get_lang_bitmap (fli2->file); 3565 int fnum; 3566 3567 for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1) 3568 if (bitmap & 1) 3569 { 3570 oprintf (base_files[fnum], 3571 "extern const struct %s gt_%s_", tname, pfx); 3572 put_mangled_filename (base_files[fnum], fli2->file); 3573 oprintf (base_files[fnum], "[];\n"); 3574 } 3575 } 3576 3577 { 3578 size_t fnum; 3579 for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++) 3580 oprintf (base_files[fnum], 3581 "EXPORTED_CONST struct %s * const %s[] = {\n", tname, name); 3582 } 3583 3584 3585 for (fli2 = flp; fli2; fli2 = fli2->next) 3586 if (fli2->started_p) 3587 { 3588 lang_bitmap bitmap = get_lang_bitmap (fli2->file); 3589 int fnum; 3590 3591 fli2->started_p = 0; 3592 3593 for (fnum = 0; base_files && bitmap != 0; fnum++, bitmap >>= 1) 3594 if (bitmap & 1) 3595 { 3596 oprintf (base_files[fnum], " gt_%s_", pfx); 3597 put_mangled_filename (base_files[fnum], fli2->file); 3598 oprintf (base_files[fnum], ",\n"); 3599 } 3600 } 3601 3602 { 3603 size_t fnum; 3604 for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++) 3605 { 3606 oprintf (base_files[fnum], " NULL\n"); 3607 oprintf (base_files[fnum], "};\n"); 3608 } 3609 } 3610 } 3611 3612 /* Write the first three fields (pointer, count and stride) for 3613 root NAME to F. V and LINE are as for write_root. 3614 3615 Return true if the entry could be written; return false on error. */ 3616 3617 static bool 3618 start_root_entry (outf_p f, pair_p v, const char *name, struct fileloc *line) 3619 { 3620 type_p ap; 3621 3622 if (!v) 3623 { 3624 error_at_line (line, "`%s' is too complex to be a root", name); 3625 return false; 3626 } 3627 3628 oprintf (f, " {\n"); 3629 oprintf (f, " &%s,\n", name); 3630 oprintf (f, " 1"); 3631 3632 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p) 3633 if (ap->u.a.len[0]) 3634 oprintf (f, " * (%s)", ap->u.a.len); 3635 else if (ap == v->type) 3636 oprintf (f, " * ARRAY_SIZE (%s)", v->name); 3637 oprintf (f, ",\n"); 3638 oprintf (f, " sizeof (%s", v->name); 3639 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p) 3640 oprintf (f, "[0]"); 3641 oprintf (f, "),\n"); 3642 return true; 3643 } 3644 3645 /* A subroutine of write_root for writing the roots for field FIELD_NAME, 3646 which has type FIELD_TYPE. Parameters F to EMIT_PCH are the parameters 3647 of the caller. */ 3648 3649 static void 3650 write_field_root (outf_p f, pair_p v, type_p type, const char *name, 3651 int has_length, struct fileloc *line, const char *if_marked, 3652 bool emit_pch, type_p field_type, const char *field_name) 3653 { 3654 struct pair newv; 3655 /* If the field reference is relative to V, rather than to some 3656 subcomponent of V, we can mark any subarrays with a single stride. 3657 We're effectively treating the field as a global variable in its 3658 own right. */ 3659 if (v && type == v->type) 3660 { 3661 newv = *v; 3662 newv.type = field_type; 3663 newv.name = ACONCAT ((v->name, ".", field_name, NULL)); 3664 v = &newv; 3665 } 3666 /* Otherwise, any arrays nested in the structure are too complex to 3667 handle. */ 3668 else if (field_type->kind == TYPE_ARRAY) 3669 v = NULL; 3670 write_root (f, v, field_type, ACONCAT ((name, ".", field_name, NULL)), 3671 has_length, line, if_marked, emit_pch); 3672 } 3673 3674 /* Write out to F the table entry and any marker routines needed to 3675 mark NAME as TYPE. V can be one of three values: 3676 3677 - null, if NAME is too complex to represent using a single 3678 count and stride. In this case, it is an error for NAME to 3679 contain any gc-ed data. 3680 3681 - the outermost array that contains NAME, if NAME is part of an array. 3682 3683 - the C variable that contains NAME, if NAME is not part of an array. 3684 3685 LINE is the line of the C source that declares the root variable. 3686 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED 3687 is nonzero iff we are building the root table for hash table caches. */ 3688 3689 static void 3690 write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, 3691 struct fileloc *line, const char *if_marked, bool emit_pch) 3692 { 3693 switch (type->kind) 3694 { 3695 case TYPE_STRUCT: 3696 { 3697 pair_p fld; 3698 for (fld = type->u.s.fields; fld; fld = fld->next) 3699 { 3700 int skip_p = 0; 3701 const char *desc = NULL; 3702 options_p o; 3703 3704 for (o = fld->opt; o; o = o->next) 3705 if (strcmp (o->name, "skip") == 0) 3706 skip_p = 1; 3707 else if (strcmp (o->name, "desc") == 0 3708 && o->kind == OPTION_STRING) 3709 desc = o->info.string; 3710 else if (strcmp (o->name, "param_is") == 0) 3711 ; 3712 else 3713 error_at_line (line, 3714 "field `%s' of global `%s' has unknown option `%s'", 3715 fld->name, name, o->name); 3716 3717 if (skip_p) 3718 continue; 3719 else if (desc && fld->type->kind == TYPE_UNION) 3720 { 3721 pair_p validf = NULL; 3722 pair_p ufld; 3723 3724 for (ufld = fld->type->u.s.fields; ufld; ufld = ufld->next) 3725 { 3726 const char *tag = NULL; 3727 options_p oo; 3728 for (oo = ufld->opt; oo; oo = oo->next) 3729 if (strcmp (oo->name, "tag") == 0 3730 && oo->kind == OPTION_STRING) 3731 tag = oo->info.string; 3732 if (tag == NULL || strcmp (tag, desc) != 0) 3733 continue; 3734 if (validf != NULL) 3735 error_at_line (line, 3736 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'", 3737 name, fld->name, validf->name, 3738 name, fld->name, ufld->name, tag); 3739 validf = ufld; 3740 } 3741 if (validf != NULL) 3742 write_field_root (f, v, type, name, 0, line, if_marked, 3743 emit_pch, validf->type, 3744 ACONCAT ((fld->name, ".", 3745 validf->name, NULL))); 3746 } 3747 else if (desc) 3748 error_at_line (line, 3749 "global `%s.%s' has `desc' option but is not union", 3750 name, fld->name); 3751 else 3752 write_field_root (f, v, type, name, 0, line, if_marked, 3753 emit_pch, fld->type, fld->name); 3754 } 3755 } 3756 break; 3757 3758 case TYPE_ARRAY: 3759 { 3760 char *newname; 3761 newname = xasprintf ("%s[0]", name); 3762 write_root (f, v, type->u.a.p, newname, has_length, line, if_marked, 3763 emit_pch); 3764 free (newname); 3765 } 3766 break; 3767 3768 case TYPE_POINTER: 3769 { 3770 type_p tp; 3771 3772 if (!start_root_entry (f, v, name, line)) 3773 return; 3774 3775 tp = type->u.p; 3776 3777 if (!has_length && UNION_OR_STRUCT_P (tp)) 3778 { 3779 oprintf (f, " >_ggc_mx_%s,\n", tp->u.s.tag); 3780 if (emit_pch) 3781 oprintf (f, " >_pch_nx_%s", tp->u.s.tag); 3782 else 3783 oprintf (f, " NULL"); 3784 } 3785 else if (!has_length && tp->kind == TYPE_PARAM_STRUCT) 3786 { 3787 oprintf (f, " >_ggc_m_"); 3788 output_mangled_typename (f, tp); 3789 if (emit_pch) 3790 { 3791 oprintf (f, ",\n >_pch_n_"); 3792 output_mangled_typename (f, tp); 3793 } 3794 else 3795 oprintf (f, ",\n NULL"); 3796 } 3797 else if (has_length 3798 && (tp->kind == TYPE_POINTER || UNION_OR_STRUCT_P (tp))) 3799 { 3800 oprintf (f, " >_ggc_ma_%s,\n", name); 3801 if (emit_pch) 3802 oprintf (f, " >_pch_na_%s", name); 3803 else 3804 oprintf (f, " NULL"); 3805 } 3806 else 3807 { 3808 error_at_line (line, 3809 "global `%s' is pointer to unimplemented type", 3810 name); 3811 } 3812 if (if_marked) 3813 oprintf (f, ",\n &%s", if_marked); 3814 oprintf (f, "\n },\n"); 3815 } 3816 break; 3817 3818 case TYPE_STRING: 3819 { 3820 if (!start_root_entry (f, v, name, line)) 3821 return; 3822 3823 oprintf (f, " (gt_pointer_walker) >_ggc_m_S,\n"); 3824 oprintf (f, " (gt_pointer_walker) >_pch_n_S\n"); 3825 oprintf (f, " },\n"); 3826 } 3827 break; 3828 3829 case TYPE_SCALAR: 3830 break; 3831 3832 default: 3833 error_at_line (line, "global `%s' is unimplemented type", name); 3834 } 3835 } 3836 3837 /* This generates a routine to walk an array. */ 3838 3839 static void 3840 write_array (outf_p f, pair_p v, const struct write_types_data *wtd) 3841 { 3842 struct walk_type_data d; 3843 char *prevval3; 3844 3845 memset (&d, 0, sizeof (d)); 3846 d.of = f; 3847 d.cookie = wtd; 3848 d.indent = 2; 3849 d.line = &v->line; 3850 d.opt = v->opt; 3851 d.bitmap = get_lang_bitmap (v->line.file); 3852 d.param = NULL; 3853 3854 d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name); 3855 3856 if (wtd->param_prefix) 3857 { 3858 oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name); 3859 oprintf (f, " (void *, void *, gt_pointer_operator, void *);\n"); 3860 oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n", 3861 wtd->param_prefix, v->name); 3862 oprintf (d.of, 3863 " ATTRIBUTE_UNUSED void *x_p,\n" 3864 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n" 3865 " ATTRIBUTE_UNUSED void * cookie)\n"); 3866 oprintf (d.of, "{\n"); 3867 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name; 3868 d.process_field = write_types_local_process_field; 3869 walk_type (v->type, &d); 3870 oprintf (f, "}\n\n"); 3871 } 3872 3873 d.opt = v->opt; 3874 oprintf (f, "static void gt_%sa_%s (void *);\n", wtd->prefix, v->name); 3875 oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n", 3876 wtd->prefix, v->name); 3877 oprintf (f, "{\n"); 3878 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name; 3879 d.process_field = write_types_process_field; 3880 walk_type (v->type, &d); 3881 free (prevval3); 3882 oprintf (f, "}\n\n"); 3883 } 3884 3885 /* Output a table describing the locations and types of VARIABLES. */ 3886 3887 static void 3888 write_roots (pair_p variables, bool emit_pch) 3889 { 3890 pair_p v; 3891 struct flist *flp = NULL; 3892 3893 for (v = variables; v; v = v->next) 3894 { 3895 outf_p f = 3896 get_output_file_with_visibility (CONST_CAST (input_file*, 3897 v->line.file)); 3898 struct flist *fli; 3899 const char *length = NULL; 3900 int deletable_p = 0; 3901 options_p o; 3902 for (o = v->opt; o; o = o->next) 3903 if (strcmp (o->name, "length") == 0 3904 && o->kind == OPTION_STRING) 3905 length = o->info.string; 3906 else if (strcmp (o->name, "deletable") == 0) 3907 deletable_p = 1; 3908 else if (strcmp (o->name, "param_is") == 0) 3909 ; 3910 else if (strncmp (o->name, "param", 5) == 0 3911 && ISDIGIT (o->name[5]) && strcmp (o->name + 6, "_is") == 0) 3912 ; 3913 else if (strcmp (o->name, "if_marked") == 0) 3914 ; 3915 else 3916 error_at_line (&v->line, 3917 "global `%s' has unknown option `%s'", 3918 v->name, o->name); 3919 3920 for (fli = flp; fli; fli = fli->next) 3921 if (fli->f == f && f) 3922 break; 3923 if (fli == NULL) 3924 { 3925 fli = XNEW (struct flist); 3926 fli->f = f; 3927 fli->next = flp; 3928 fli->started_p = 0; 3929 fli->file = v->line.file; 3930 gcc_assert (fli->file); 3931 flp = fli; 3932 3933 oprintf (f, "\n/* GC roots. */\n\n"); 3934 } 3935 3936 if (!deletable_p 3937 && length 3938 && v->type->kind == TYPE_POINTER 3939 && (v->type->u.p->kind == TYPE_POINTER 3940 || v->type->u.p->kind == TYPE_STRUCT)) 3941 { 3942 write_array (f, v, &ggc_wtd); 3943 write_array (f, v, &pch_wtd); 3944 } 3945 } 3946 3947 for (v = variables; v; v = v->next) 3948 { 3949 outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, 3950 v->line.file)); 3951 struct flist *fli; 3952 int skip_p = 0; 3953 int length_p = 0; 3954 options_p o; 3955 3956 for (o = v->opt; o; o = o->next) 3957 if (strcmp (o->name, "length") == 0) 3958 length_p = 1; 3959 else if (strcmp (o->name, "deletable") == 0 3960 || strcmp (o->name, "if_marked") == 0) 3961 skip_p = 1; 3962 3963 if (skip_p) 3964 continue; 3965 3966 for (fli = flp; fli; fli = fli->next) 3967 if (fli->f == f) 3968 break; 3969 if (!fli->started_p) 3970 { 3971 fli->started_p = 1; 3972 3973 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_"); 3974 put_mangled_filename (f, v->line.file); 3975 oprintf (f, "[] = {\n"); 3976 } 3977 3978 write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch); 3979 } 3980 3981 finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab", 3982 "gt_ggc_rtab"); 3983 3984 for (v = variables; v; v = v->next) 3985 { 3986 outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, 3987 v->line.file)); 3988 struct flist *fli; 3989 int skip_p = 1; 3990 options_p o; 3991 3992 for (o = v->opt; o; o = o->next) 3993 if (strcmp (o->name, "deletable") == 0) 3994 skip_p = 0; 3995 else if (strcmp (o->name, "if_marked") == 0) 3996 skip_p = 1; 3997 3998 if (skip_p) 3999 continue; 4000 4001 for (fli = flp; fli; fli = fli->next) 4002 if (fli->f == f) 4003 break; 4004 if (!fli->started_p) 4005 { 4006 fli->started_p = 1; 4007 4008 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_"); 4009 put_mangled_filename (f, v->line.file); 4010 oprintf (f, "[] = {\n"); 4011 } 4012 4013 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n", 4014 v->name, v->name); 4015 } 4016 4017 finish_root_table (flp, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab", 4018 "gt_ggc_deletable_rtab"); 4019 4020 for (v = variables; v; v = v->next) 4021 { 4022 outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, 4023 v->line.file)); 4024 struct flist *fli; 4025 const char *if_marked = NULL; 4026 int length_p = 0; 4027 options_p o; 4028 4029 for (o = v->opt; o; o = o->next) 4030 if (strcmp (o->name, "length") == 0) 4031 length_p = 1; 4032 else if (strcmp (o->name, "if_marked") == 0 4033 && o->kind == OPTION_STRING) 4034 if_marked = o->info.string; 4035 if (if_marked == NULL) 4036 continue; 4037 if (v->type->kind != TYPE_POINTER 4038 || v->type->u.p->kind != TYPE_PARAM_STRUCT 4039 || v->type->u.p->u.param_struct.stru != find_structure ("htab", 0)) 4040 { 4041 error_at_line (&v->line, 4042 "if_marked option used but not hash table"); 4043 continue; 4044 } 4045 4046 for (fli = flp; fli; fli = fli->next) 4047 if (fli->f == f) 4048 break; 4049 if (!fli->started_p) 4050 { 4051 fli->started_p = 1; 4052 4053 oprintf (f, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_"); 4054 put_mangled_filename (f, v->line.file); 4055 oprintf (f, "[] = {\n"); 4056 } 4057 4058 write_root (f, v, v->type->u.p->u.param_struct.param[0], 4059 v->name, length_p, &v->line, if_marked, emit_pch); 4060 } 4061 4062 finish_root_table (flp, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab", 4063 "gt_ggc_cache_rtab"); 4064 4065 if (!emit_pch) 4066 return; 4067 4068 for (v = variables; v; v = v->next) 4069 { 4070 outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, 4071 v->line.file)); 4072 struct flist *fli; 4073 int length_p = 0; 4074 int if_marked_p = 0; 4075 options_p o; 4076 4077 for (o = v->opt; o; o = o->next) 4078 if (strcmp (o->name, "length") == 0) 4079 length_p = 1; 4080 else if (strcmp (o->name, "if_marked") == 0) 4081 if_marked_p = 1; 4082 4083 if (!if_marked_p) 4084 continue; 4085 4086 for (fli = flp; fli; fli = fli->next) 4087 if (fli->f == f) 4088 break; 4089 if (!fli->started_p) 4090 { 4091 fli->started_p = 1; 4092 4093 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_"); 4094 put_mangled_filename (f, v->line.file); 4095 oprintf (f, "[] = {\n"); 4096 } 4097 4098 write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch); 4099 } 4100 4101 finish_root_table (flp, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab", 4102 "gt_pch_cache_rtab"); 4103 4104 for (v = variables; v; v = v->next) 4105 { 4106 outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, 4107 v->line.file)); 4108 struct flist *fli; 4109 int skip_p = 0; 4110 options_p o; 4111 4112 for (o = v->opt; o; o = o->next) 4113 if (strcmp (o->name, "deletable") == 0 4114 || strcmp (o->name, "if_marked") == 0) 4115 skip_p = 1; 4116 4117 if (skip_p) 4118 continue; 4119 4120 if (!contains_scalar_p (v->type)) 4121 continue; 4122 4123 for (fli = flp; fli; fli = fli->next) 4124 if (fli->f == f) 4125 break; 4126 if (!fli->started_p) 4127 { 4128 fli->started_p = 1; 4129 4130 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_"); 4131 put_mangled_filename (f, v->line.file); 4132 oprintf (f, "[] = {\n"); 4133 } 4134 4135 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n", 4136 v->name, v->name); 4137 } 4138 4139 finish_root_table (flp, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab", 4140 "gt_pch_scalar_rtab"); 4141 } 4142 /* Record the definition of the vec_prefix structure, as defined in vec.h: 4143 4144 struct vec_prefix GTY(()) { 4145 unsigned num; 4146 unsigned alloc; 4147 }; */ 4148 static type_p 4149 vec_prefix_type (void) 4150 { 4151 static type_p prefix_type = NULL; 4152 if (prefix_type == NULL) 4153 { 4154 pair_p fields; 4155 static struct fileloc pos = { NULL, 0 }; 4156 type_p len_ty = create_scalar_type ("unsigned"); 4157 pos.file = input_file_by_name (__FILE__); pos.line = __LINE__; 4158 fields = create_field_at (0, len_ty, "alloc", 0, &pos); 4159 fields = create_field_at (fields, len_ty, "num", 0, &pos); 4160 prefix_type = new_structure ("vec_prefix", 0, &pos, fields, 0); 4161 prefix_type->u.s.bitmap = -1; 4162 } 4163 return prefix_type; 4164 } 4165 4166 /* Record the definition of a generic VEC structure, as if we had expanded 4167 the macros in vec.h: 4168 4169 typedef struct VEC_<type>_base GTY(()) { 4170 struct vec_prefix prefix; 4171 <type> GTY((length ("%h.prefix.num"))) vec[1]; 4172 } VEC_<type>_base 4173 4174 where the GTY(()) tags are only present if is_scalar is _false_. */ 4175 4176 void 4177 note_def_vec (const char *type_name, bool is_scalar, struct fileloc *pos) 4178 { 4179 pair_p fields; 4180 type_p t; 4181 options_p o; 4182 const char *name = concat ("VEC_", type_name, "_base", (char *) 0); 4183 4184 if (is_scalar) 4185 { 4186 t = create_scalar_type (type_name); 4187 o = 0; 4188 } 4189 else 4190 { 4191 t = resolve_typedef (type_name, pos); 4192 o = create_string_option (0, "length", "%h.prefix.num"); 4193 } 4194 /* We assemble the field list in reverse order. */ 4195 fields = create_field_at (0, create_array (t, "1"), "vec", o, pos); 4196 fields = create_field_at (fields, vec_prefix_type (), "prefix", 0, pos); 4197 4198 do_typedef (name, new_structure (name, 0, pos, fields, 0), pos); 4199 } 4200 4201 /* Record the definition of an allocation-specific VEC structure, as if 4202 we had expanded the macros in vec.h: 4203 4204 typedef struct VEC_<type>_<astrat> { 4205 VEC_<type>_base base; 4206 } VEC_<type>_<astrat>; 4207 */ 4208 void 4209 note_def_vec_alloc (const char *type, const char *astrat, struct fileloc *pos) 4210 { 4211 const char *astratname = concat ("VEC_", type, "_", astrat, (char *) 0); 4212 const char *basename = concat ("VEC_", type, "_base", (char *) 0); 4213 4214 pair_p field = create_field_at (0, resolve_typedef (basename, pos), 4215 "base", 0, pos); 4216 4217 do_typedef (astratname, new_structure (astratname, 0, pos, field, 0), pos); 4218 } 4219 4220 /* Returns the specifier keyword for a string or union type S, empty string 4221 otherwise. */ 4222 4223 static const char * 4224 get_type_specifier (const type_p s) 4225 { 4226 if (s->kind == TYPE_STRUCT || s->kind == TYPE_LANG_STRUCT) 4227 return "struct "; 4228 if (s->kind == TYPE_UNION) 4229 return "union "; 4230 return ""; 4231 } 4232 4233 /* TRUE if type S has the GTY variable_size annotation. */ 4234 4235 static bool 4236 variable_size_p (const type_p s) 4237 { 4238 options_p o; 4239 for (o = s->u.s.opt; o; o = o->next) 4240 if (strcmp (o->name, "variable_size") == 0) 4241 return true; 4242 return false; 4243 } 4244 4245 enum alloc_quantity 4246 { single, vector }; 4247 enum alloc_zone 4248 { any_zone, specific_zone }; 4249 4250 /* Writes one typed allocator definition into output F for type 4251 identifier TYPE_NAME with optional type specifier TYPE_SPECIFIER. 4252 The allocator name will contain ALLOCATOR_TYPE. If VARIABLE_SIZE 4253 is true, the allocator will have an extra parameter specifying 4254 number of bytes to allocate. If QUANTITY is set to VECTOR, a 4255 vector allocator will be output, if ZONE is set to SPECIFIC_ZONE, 4256 the allocator will be zone-specific. */ 4257 4258 static void 4259 write_typed_alloc_def (outf_p f, 4260 bool variable_size, const char *type_specifier, 4261 const char *type_name, const char *allocator_type, 4262 enum alloc_quantity quantity, enum alloc_zone zone) 4263 { 4264 bool two_args = variable_size && (quantity == vector); 4265 bool third_arg = ((zone == specific_zone) 4266 && (variable_size || (quantity == vector))); 4267 gcc_assert (f != NULL); 4268 oprintf (f, "#define ggc_alloc_%s%s", allocator_type, type_name); 4269 oprintf (f, "(%s%s%s%s%s) ", 4270 (variable_size ? "SIZE" : ""), 4271 (two_args ? ", " : ""), 4272 (quantity == vector) ? "n" : "", 4273 (third_arg ? ", " : ""), (zone == specific_zone) ? "z" : ""); 4274 oprintf (f, "((%s%s *)", type_specifier, type_name); 4275 oprintf (f, "(ggc_internal_%salloc_stat (", allocator_type); 4276 if (zone == specific_zone) 4277 oprintf (f, "z, "); 4278 if (variable_size) 4279 oprintf (f, "SIZE"); 4280 else 4281 oprintf (f, "sizeof (%s%s)", type_specifier, type_name); 4282 if (quantity == vector) 4283 oprintf (f, ", n"); 4284 oprintf (f, " MEM_STAT_INFO)))\n"); 4285 } 4286 4287 /* Writes a typed allocator definition into output F for a struct or 4288 union S, with a given ALLOCATOR_TYPE and QUANTITY for ZONE. */ 4289 4290 static void 4291 write_typed_struct_alloc_def (outf_p f, 4292 const type_p s, const char *allocator_type, 4293 enum alloc_quantity quantity, 4294 enum alloc_zone zone) 4295 { 4296 gcc_assert (UNION_OR_STRUCT_P (s)); 4297 write_typed_alloc_def (f, variable_size_p (s), get_type_specifier (s), 4298 s->u.s.tag, allocator_type, quantity, zone); 4299 } 4300 4301 /* Writes a typed allocator definition into output F for a typedef P, 4302 with a given ALLOCATOR_TYPE and QUANTITY for ZONE. */ 4303 4304 static void 4305 write_typed_typedef_alloc_def (outf_p f, 4306 const pair_p p, const char *allocator_type, 4307 enum alloc_quantity quantity, 4308 enum alloc_zone zone) 4309 { 4310 write_typed_alloc_def (f, variable_size_p (p->type), "", p->name, 4311 allocator_type, quantity, zone); 4312 } 4313 4314 /* Writes typed allocator definitions into output F for the types in 4315 STRUCTURES and TYPEDEFS that are used by GC. */ 4316 4317 static void 4318 write_typed_alloc_defns (outf_p f, 4319 const type_p structures, const pair_p typedefs) 4320 { 4321 type_p s; 4322 pair_p p; 4323 4324 gcc_assert (f != NULL); 4325 oprintf (f, 4326 "\n/* Allocators for known structs and unions. */\n\n"); 4327 for (s = structures; s; s = s->next) 4328 { 4329 if (!USED_BY_TYPED_GC_P (s)) 4330 continue; 4331 gcc_assert (UNION_OR_STRUCT_P (s)); 4332 /* In plugin mode onput output ggc_alloc macro definitions 4333 relevant to plugin input files. */ 4334 if (nb_plugin_files > 0 4335 && ((s->u.s.line.file == NULL) || !s->u.s.line.file->inpisplugin)) 4336 continue; 4337 write_typed_struct_alloc_def (f, s, "", single, any_zone); 4338 write_typed_struct_alloc_def (f, s, "cleared_", single, any_zone); 4339 write_typed_struct_alloc_def (f, s, "vec_", vector, any_zone); 4340 write_typed_struct_alloc_def (f, s, "cleared_vec_", vector, any_zone); 4341 write_typed_struct_alloc_def (f, s, "zone_", single, specific_zone); 4342 write_typed_struct_alloc_def (f, s, "zone_cleared_", single, 4343 specific_zone); 4344 write_typed_struct_alloc_def (f, s, "zone_vec_", vector, specific_zone); 4345 write_typed_struct_alloc_def (f, s, "zone_cleared_vec_", vector, 4346 specific_zone); 4347 } 4348 4349 oprintf (f, "\n/* Allocators for known typedefs. */\n"); 4350 for (p = typedefs; p; p = p->next) 4351 { 4352 s = p->type; 4353 if (!USED_BY_TYPED_GC_P (s) || (strcmp (p->name, s->u.s.tag) == 0)) 4354 continue; 4355 /* In plugin mode onput output ggc_alloc macro definitions 4356 relevant to plugin input files. */ 4357 if (nb_plugin_files > 0) 4358 { 4359 struct fileloc* filoc = type_fileloc(s); 4360 if (!filoc || !filoc->file->inpisplugin) 4361 continue; 4362 }; 4363 write_typed_typedef_alloc_def (f, p, "", single, any_zone); 4364 write_typed_typedef_alloc_def (f, p, "cleared_", single, any_zone); 4365 write_typed_typedef_alloc_def (f, p, "vec_", vector, any_zone); 4366 write_typed_typedef_alloc_def (f, p, "cleared_vec_", vector, any_zone); 4367 write_typed_typedef_alloc_def (f, p, "zone_", single, specific_zone); 4368 write_typed_typedef_alloc_def (f, p, "zone_cleared_", single, 4369 specific_zone); 4370 write_typed_typedef_alloc_def (f, p, "zone_cleared_vec_", vector, 4371 specific_zone); 4372 } 4373 } 4374 4375 /* Prints not-as-ugly version of a typename of T to OF. Trades the uniquness 4376 guaranteee for somewhat increased readability. If name conflicts do happen, 4377 this funcion will have to be adjusted to be more like 4378 output_mangled_typename. */ 4379 4380 static void 4381 output_typename (outf_p of, const_type_p t) 4382 { 4383 switch (t->kind) 4384 { 4385 case TYPE_STRING: 4386 oprintf (of, "str"); 4387 break; 4388 case TYPE_SCALAR: 4389 oprintf (of, "scalar"); 4390 break; 4391 case TYPE_POINTER: 4392 output_typename (of, t->u.p); 4393 break; 4394 case TYPE_STRUCT: 4395 case TYPE_UNION: 4396 case TYPE_LANG_STRUCT: 4397 oprintf (of, "%s", t->u.s.tag); 4398 break; 4399 case TYPE_PARAM_STRUCT: 4400 { 4401 int i; 4402 for (i = 0; i < NUM_PARAM; i++) 4403 if (t->u.param_struct.param[i] != NULL) 4404 { 4405 output_typename (of, t->u.param_struct.param[i]); 4406 oprintf (of, "_"); 4407 } 4408 output_typename (of, t->u.param_struct.stru); 4409 break; 4410 } 4411 default: 4412 gcc_unreachable (); 4413 } 4414 } 4415 4416 /* Writes a typed GC allocator for type S that is suitable as a callback for 4417 the splay tree implementation in libiberty. */ 4418 4419 static void 4420 write_splay_tree_allocator_def (const_type_p s) 4421 { 4422 outf_p of = get_output_file_with_visibility (NULL); 4423 oprintf (of, "void * ggc_alloc_splay_tree_"); 4424 output_typename (of, s); 4425 oprintf (of, " (int sz, void * nl)\n"); 4426 oprintf (of, "{\n"); 4427 oprintf (of, " return ggc_splay_alloc ("); 4428 oprintf (of, "gt_e_"); 4429 output_mangled_typename (of, s); 4430 oprintf (of, ", sz, nl);\n"); 4431 oprintf (of, "}\n\n"); 4432 } 4433 4434 /* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks 4435 for the splay tree implementation in libiberty. */ 4436 4437 static void 4438 write_splay_tree_allocators (const_type_p param_structs) 4439 { 4440 const_type_p s; 4441 4442 oprintf (header_file, "\n/* Splay tree callback allocators. */\n"); 4443 for (s = param_structs; s; s = s->next) 4444 if (s->gc_used == GC_POINTED_TO) 4445 { 4446 oprintf (header_file, "extern void * ggc_alloc_splay_tree_"); 4447 output_typename (header_file, s); 4448 oprintf (header_file, " (int, void *);\n"); 4449 write_splay_tree_allocator_def (s); 4450 } 4451 } 4452 4453 static void dump_pair (int indent, pair_p p); 4454 static void dump_type (int indent, type_p p); 4455 static void dump_type_list (int indent, type_p p); 4456 4457 #define INDENT 2 4458 4459 /* Dumps the value of typekind KIND. */ 4460 4461 static void 4462 dump_typekind (int indent, enum typekind kind) 4463 { 4464 printf ("%*ckind = ", indent, ' '); 4465 switch (kind) 4466 { 4467 case TYPE_SCALAR: 4468 printf ("TYPE_SCALAR"); 4469 break; 4470 case TYPE_STRING: 4471 printf ("TYPE_STRING"); 4472 break; 4473 case TYPE_STRUCT: 4474 printf ("TYPE_STRUCT"); 4475 break; 4476 case TYPE_UNION: 4477 printf ("TYPE_UNION"); 4478 break; 4479 case TYPE_POINTER: 4480 printf ("TYPE_POINTER"); 4481 break; 4482 case TYPE_ARRAY: 4483 printf ("TYPE_ARRAY"); 4484 break; 4485 case TYPE_LANG_STRUCT: 4486 printf ("TYPE_LANG_STRUCT"); 4487 break; 4488 case TYPE_PARAM_STRUCT: 4489 printf ("TYPE_PARAM_STRUCT"); 4490 break; 4491 default: 4492 gcc_unreachable (); 4493 } 4494 printf ("\n"); 4495 } 4496 4497 /* Dumps the value of GC_USED flag. */ 4498 4499 static void 4500 dump_gc_used (int indent, enum gc_used_enum gc_used) 4501 { 4502 printf ("%*cgc_used = ", indent, ' '); 4503 switch (gc_used) 4504 { 4505 case GC_UNUSED: 4506 printf ("GC_UNUSED"); 4507 break; 4508 case GC_USED: 4509 printf ("GC_USED"); 4510 break; 4511 case GC_MAYBE_POINTED_TO: 4512 printf ("GC_MAYBE_POINTED_TO"); 4513 break; 4514 case GC_POINTED_TO: 4515 printf ("GC_POINTED_TO"); 4516 break; 4517 default: 4518 gcc_unreachable (); 4519 } 4520 printf ("\n"); 4521 } 4522 4523 /* Dumps the type options OPT. */ 4524 4525 static void 4526 dump_options (int indent, options_p opt) 4527 { 4528 options_p o; 4529 printf ("%*coptions = ", indent, ' '); 4530 o = opt; 4531 while (o) 4532 { 4533 switch (o->kind) 4534 { 4535 case OPTION_STRING: 4536 printf ("%s:string %s ", o->name, o->info.string); 4537 break; 4538 case OPTION_TYPE: 4539 printf ("%s:type ", o->name); 4540 dump_type (indent+1, o->info.type); 4541 break; 4542 case OPTION_NESTED: 4543 printf ("%s:nested ", o->name); 4544 break; 4545 case OPTION_NONE: 4546 gcc_unreachable (); 4547 } 4548 o = o->next; 4549 } 4550 printf ("\n"); 4551 } 4552 4553 /* Dumps the source file location in LINE. */ 4554 4555 static void 4556 dump_fileloc (int indent, struct fileloc line) 4557 { 4558 printf ("%*cfileloc: file = %s, line = %d\n", indent, ' ', 4559 get_input_file_name (line.file), 4560 line.line); 4561 } 4562 4563 /* Recursively dumps the struct, union, or a language-specific 4564 struct T. */ 4565 4566 static void 4567 dump_type_u_s (int indent, type_p t) 4568 { 4569 pair_p fields; 4570 4571 gcc_assert (t->kind == TYPE_STRUCT || t->kind == TYPE_UNION 4572 || t->kind == TYPE_LANG_STRUCT); 4573 printf ("%*cu.s.tag = %s\n", indent, ' ', t->u.s.tag); 4574 dump_fileloc (indent, t->u.s.line); 4575 printf ("%*cu.s.fields =\n", indent, ' '); 4576 fields = t->u.s.fields; 4577 while (fields) 4578 { 4579 dump_pair (indent + INDENT, fields); 4580 fields = fields->next; 4581 } 4582 printf ("%*cend of fields of type %p\n", indent, ' ', (void *) t); 4583 dump_options (indent, t->u.s.opt); 4584 printf ("%*cu.s.bitmap = %X\n", indent, ' ', t->u.s.bitmap); 4585 if (t->kind == TYPE_LANG_STRUCT) 4586 { 4587 printf ("%*cu.s.lang_struct:\n", indent, ' '); 4588 dump_type_list (indent + INDENT, t->u.s.lang_struct); 4589 } 4590 } 4591 4592 /* Recursively dumps the array T. */ 4593 4594 static void 4595 dump_type_u_a (int indent, type_p t) 4596 { 4597 gcc_assert (t->kind == TYPE_ARRAY); 4598 printf ("%*clen = %s, u.a.p:\n", indent, ' ', t->u.a.len); 4599 dump_type_list (indent + INDENT, t->u.a.p); 4600 } 4601 4602 /* Recursively dumps the parameterized struct T. */ 4603 4604 static void 4605 dump_type_u_param_struct (int indent, type_p t) 4606 { 4607 int i; 4608 gcc_assert (t->kind == TYPE_PARAM_STRUCT); 4609 printf ("%*cu.param_struct.stru:\n", indent, ' '); 4610 dump_type_list (indent, t->u.param_struct.stru); 4611 dump_fileloc (indent, t->u.param_struct.line); 4612 for (i = 0; i < NUM_PARAM; i++) 4613 { 4614 if (t->u.param_struct.param[i] == NULL) 4615 continue; 4616 printf ("%*cu.param_struct.param[%d]:\n", indent, ' ', i); 4617 dump_type (indent + INDENT, t->u.param_struct.param[i]); 4618 } 4619 } 4620 4621 /* Recursively dumps the type list T. */ 4622 4623 static void 4624 dump_type_list (int indent, type_p t) 4625 { 4626 type_p p = t; 4627 while (p) 4628 { 4629 dump_type (indent, p); 4630 p = p->next; 4631 } 4632 } 4633 4634 static htab_t seen_types; 4635 4636 /* Recursively dumps the type T if it was not dumped previously. */ 4637 4638 static void 4639 dump_type (int indent, type_p t) 4640 { 4641 PTR *slot; 4642 4643 printf ("%*cType at %p: ", indent, ' ', (void *) t); 4644 slot = htab_find_slot (seen_types, t, INSERT); 4645 if (*slot != NULL) 4646 { 4647 printf ("already seen.\n"); 4648 return; 4649 } 4650 *slot = t; 4651 printf ("\n"); 4652 4653 dump_typekind (indent, t->kind); 4654 printf ("%*cpointer_to = %p\n", indent + INDENT, ' ', 4655 (void *) t->pointer_to); 4656 dump_gc_used (indent + INDENT, t->gc_used); 4657 switch (t->kind) 4658 { 4659 case TYPE_SCALAR: 4660 printf ("%*cscalar_is_char = %s\n", indent + INDENT, ' ', 4661 t->u.scalar_is_char ? "true" : "false"); 4662 break; 4663 case TYPE_STRING: 4664 break; 4665 case TYPE_STRUCT: 4666 case TYPE_UNION: 4667 case TYPE_LANG_STRUCT: 4668 dump_type_u_s (indent + INDENT, t); 4669 break; 4670 case TYPE_POINTER: 4671 printf ("%*cp:\n", indent + INDENT, ' '); 4672 dump_type (indent + INDENT, t->u.p); 4673 break; 4674 case TYPE_ARRAY: 4675 dump_type_u_a (indent + INDENT, t); 4676 break; 4677 case TYPE_PARAM_STRUCT: 4678 dump_type_u_param_struct (indent + INDENT, t); 4679 break; 4680 default: 4681 gcc_unreachable (); 4682 } 4683 printf ("%*cEnd of type at %p\n", indent, ' ', (void *) t); 4684 } 4685 4686 /* Dumps the pair P. */ 4687 4688 static void 4689 dump_pair (int indent, pair_p p) 4690 { 4691 printf ("%*cpair: name = %s\n", indent, ' ', p->name); 4692 dump_type (indent, p->type); 4693 dump_fileloc (indent, p->line); 4694 dump_options (indent, p->opt); 4695 printf ("%*cEnd of pair %s\n", indent, ' ', p->name); 4696 } 4697 4698 /* Dumps the list of pairs PP. */ 4699 4700 static void 4701 dump_pair_list (const char *name, pair_p pp) 4702 { 4703 pair_p p; 4704 printf ("%s:\n", name); 4705 for (p = pp; p != NULL; p = p->next) 4706 dump_pair (0, p); 4707 printf ("End of %s\n\n", name); 4708 } 4709 4710 /* Dumps the STRUCTURES. */ 4711 4712 static void 4713 dump_structures (const char *name, type_p structures) 4714 { 4715 printf ("%s:\n", name); 4716 dump_type_list (0, structures); 4717 printf ("End of %s\n\n", name); 4718 } 4719 4720 /* Dumps the internal structures of gengtype. This is useful to debug 4721 gengtype itself, or to understand what it does, e.g. for plugin 4722 developers. */ 4723 4724 static void 4725 dump_everything (void) 4726 { 4727 seen_types = htab_create (100, htab_hash_pointer, htab_eq_pointer, NULL); 4728 dump_pair_list ("typedefs", typedefs); 4729 dump_structures ("structures", structures); 4730 dump_structures ("param_structs", param_structs); 4731 dump_pair_list ("variables", variables); 4732 htab_delete (seen_types); 4733 } 4734 4735 4736 4737 /* Option specification for getopt_long. */ 4738 static const struct option gengtype_long_options[] = { 4739 {"help", no_argument, NULL, 'h'}, 4740 {"version", no_argument, NULL, 'V'}, 4741 {"verbose", no_argument, NULL, 'v'}, 4742 {"dump", no_argument, NULL, 'd'}, 4743 {"debug", no_argument, NULL, 'D'}, 4744 {"plugin", required_argument, NULL, 'P'}, 4745 {"srcdir", required_argument, NULL, 'S'}, 4746 {"backupdir", required_argument, NULL, 'B'}, 4747 {"inputs", required_argument, NULL, 'I'}, 4748 {"read-state", required_argument, NULL, 'r'}, 4749 {"write-state", required_argument, NULL, 'w'}, 4750 /* Terminating NULL placeholder. */ 4751 {NULL, no_argument, NULL, 0}, 4752 }; 4753 4754 4755 static void 4756 print_usage (void) 4757 { 4758 printf ("Usage: %s\n", progname); 4759 printf ("\t -h | --help " " \t# Give this help.\n"); 4760 printf ("\t -D | --debug " 4761 " \t# Give debug output to debug %s itself.\n", progname); 4762 printf ("\t -V | --version " " \t# Give version information.\n"); 4763 printf ("\t -v | --verbose \t# Increase verbosity. Can be given several times.\n"); 4764 printf ("\t -d | --dump " " \t# Dump state for debugging.\n"); 4765 printf ("\t -P | --plugin <output-file> <plugin-src> ... " 4766 " \t# Generate for plugin.\n"); 4767 printf ("\t -S | --srcdir <GCC-directory> " 4768 " \t# Specify the GCC source directory.\n"); 4769 printf ("\t -B | --backupdir <directory> " 4770 " \t# Specify the backup directory for updated files.\n"); 4771 printf ("\t -I | --inputs <input-list> " 4772 " \t# Specify the file with source files list.\n"); 4773 printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n"); 4774 printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n"); 4775 } 4776 4777 static void 4778 print_version (void) 4779 { 4780 printf ("%s %s%s\n", progname, pkgversion_string, version_string); 4781 printf ("Report bugs: %s\n", bug_report_url); 4782 } 4783 4784 /* Parse the program options using getopt_long... */ 4785 static void 4786 parse_program_options (int argc, char **argv) 4787 { 4788 int opt = -1; 4789 while ((opt = getopt_long (argc, argv, "hVvdP:S:B:I:w:r:D", 4790 gengtype_long_options, NULL)) >= 0) 4791 { 4792 switch (opt) 4793 { 4794 case 'h': /* --help */ 4795 print_usage (); 4796 break; 4797 case 'V': /* --version */ 4798 print_version (); 4799 break; 4800 case 'd': /* --dump */ 4801 do_dump = 1; 4802 break; 4803 case 'D': /* --debug */ 4804 do_debug = 1; 4805 break; 4806 case 'v': /* --verbose */ 4807 verbosity_level++; 4808 break; 4809 case 'P': /* --plugin */ 4810 if (optarg) 4811 plugin_output_filename = optarg; 4812 else 4813 fatal ("missing plugin output file name"); 4814 break; 4815 case 'S': /* --srcdir */ 4816 if (optarg) 4817 srcdir = optarg; 4818 else 4819 fatal ("missing source directory"); 4820 srcdir_len = strlen (srcdir); 4821 break; 4822 case 'B': /* --backupdir */ 4823 if (optarg) 4824 backup_dir = optarg; 4825 else 4826 fatal ("missing backup directory"); 4827 break; 4828 case 'I': /* --inputs */ 4829 if (optarg) 4830 inputlist = optarg; 4831 else 4832 fatal ("missing input list"); 4833 break; 4834 case 'r': /* --read-state */ 4835 if (optarg) 4836 read_state_filename = optarg; 4837 else 4838 fatal ("missing read state file"); 4839 DBGPRINTF ("read state %s\n", optarg); 4840 break; 4841 case 'w': /* --write-state */ 4842 DBGPRINTF ("write state %s\n", optarg); 4843 if (optarg) 4844 write_state_filename = optarg; 4845 else 4846 fatal ("missing write state file"); 4847 break; 4848 default: 4849 fprintf (stderr, "%s: unknown flag '%c'\n", progname, opt); 4850 print_usage (); 4851 fatal ("unexpected flag"); 4852 } 4853 }; 4854 if (plugin_output_filename) 4855 { 4856 /* In plugin mode we require some input files. */ 4857 int i = 0; 4858 if (optind >= argc) 4859 fatal ("no source files given in plugin mode"); 4860 nb_plugin_files = argc - optind; 4861 plugin_files = XNEWVEC (input_file*, nb_plugin_files); 4862 for (i = 0; i < (int) nb_plugin_files; i++) 4863 { 4864 char *name = argv[i + optind]; 4865 plugin_files[i] = input_file_by_name (name); 4866 } 4867 } 4868 } 4869 4870 4871 4872 /******* Manage input files. ******/ 4873 4874 /* Hash table of unique input file names. */ 4875 static htab_t input_file_htab; 4876 4877 /* Find or allocate a new input_file by hash-consing it. */ 4878 input_file* 4879 input_file_by_name (const char* name) 4880 { 4881 PTR* slot; 4882 input_file* f = NULL; 4883 int namlen = 0; 4884 if (!name) 4885 return NULL; 4886 namlen = strlen (name); 4887 f = XCNEWVAR (input_file, sizeof (input_file)+namlen+2); 4888 f->inpbitmap = 0; 4889 f->inpoutf = NULL; 4890 f->inpisplugin = false; 4891 strcpy (f->inpname, name); 4892 slot = htab_find_slot (input_file_htab, f, INSERT); 4893 gcc_assert (slot != NULL); 4894 if (*slot) 4895 { 4896 /* Already known input file. */ 4897 free (f); 4898 return (input_file*)(*slot); 4899 } 4900 /* New input file. */ 4901 *slot = f; 4902 return f; 4903 } 4904 4905 /* Hash table support routines for input_file-s. */ 4906 static hashval_t 4907 htab_hash_inputfile (const void *p) 4908 { 4909 const input_file *inpf = (const input_file *) p; 4910 gcc_assert (inpf); 4911 return htab_hash_string (get_input_file_name (inpf)); 4912 } 4913 4914 static int 4915 htab_eq_inputfile (const void *x, const void *y) 4916 { 4917 const input_file *inpfx = (const input_file *) x; 4918 const input_file *inpfy = (const input_file *) y; 4919 gcc_assert (inpfx != NULL && inpfy != NULL); 4920 return !filename_cmp (get_input_file_name (inpfx), get_input_file_name (inpfy)); 4921 } 4922 4923 4924 int 4925 main (int argc, char **argv) 4926 { 4927 size_t i; 4928 static struct fileloc pos = { NULL, 0 }; 4929 outf_p output_header; 4930 4931 /* Mandatory common initializations. */ 4932 progname = "gengtype"; /* For fatal and messages. */ 4933 /* Create the hash-table used to hash-cons input files. */ 4934 input_file_htab = 4935 htab_create (800, htab_hash_inputfile, htab_eq_inputfile, NULL); 4936 /* Initialize our special input files. */ 4937 this_file = input_file_by_name (__FILE__); 4938 system_h_file = input_file_by_name ("system.h"); 4939 /* Set the scalar_is_char union number for predefined scalar types. */ 4940 scalar_nonchar.u.scalar_is_char = FALSE; 4941 scalar_char.u.scalar_is_char = TRUE; 4942 4943 parse_program_options (argc, argv); 4944 4945 #if ENABLE_CHECKING 4946 if (do_debug) 4947 { 4948 time_t now = (time_t) 0; 4949 time (&now); 4950 DBGPRINTF ("gengtype started pid %d at %s", 4951 (int) getpid (), ctime (&now)); 4952 } 4953 #endif /* ENABLE_CHECKING */ 4954 4955 /* Parse the input list and the input files. */ 4956 DBGPRINTF ("inputlist %s", inputlist); 4957 if (read_state_filename) 4958 { 4959 if (inputlist) 4960 fatal ("input list %s cannot be given with a read state file %s", 4961 inputlist, read_state_filename); 4962 read_state (read_state_filename); 4963 DBGPRINT_COUNT_TYPE ("structures after read_state", structures); 4964 DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs); 4965 } 4966 else if (inputlist) 4967 { 4968 /* These types are set up with #define or else outside of where 4969 we can see them. We should initialize them before calling 4970 read_input_list. */ 4971 #define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \ 4972 Call;} while(0) 4973 POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos)); 4974 POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos)); 4975 POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos)); 4976 POS_HERE (do_scalar_typedef ("double_int", &pos)); 4977 POS_HERE (do_scalar_typedef ("uint64_t", &pos)); 4978 POS_HERE (do_scalar_typedef ("uint8", &pos)); 4979 POS_HERE (do_scalar_typedef ("jword", &pos)); 4980 POS_HERE (do_scalar_typedef ("JCF_u2", &pos)); 4981 POS_HERE (do_scalar_typedef ("void", &pos)); 4982 POS_HERE (do_typedef ("PTR", 4983 create_pointer (resolve_typedef ("void", &pos)), 4984 &pos)); 4985 #undef POS_HERE 4986 read_input_list (inputlist); 4987 for (i = 0; i < num_gt_files; i++) 4988 { 4989 parse_file (get_input_file_name (gt_files[i])); 4990 DBGPRINTF ("parsed file #%d %s", 4991 (int) i, get_input_file_name (gt_files[i])); 4992 } 4993 if (verbosity_level >= 1) 4994 printf ("%s parsed %d files with %d GTY types\n", 4995 progname, (int) num_gt_files, type_count); 4996 4997 DBGPRINT_COUNT_TYPE ("structures after parsing", structures); 4998 DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs); 4999 5000 } 5001 else 5002 fatal ("either an input list or a read state file should be given"); 5003 if (hit_error) 5004 return 1; 5005 5006 5007 if (plugin_output_filename) 5008 { 5009 size_t ix = 0; 5010 /* In plugin mode, we should have read a state file, and have 5011 given at least one plugin file. */ 5012 if (!read_state_filename) 5013 fatal ("No read state given in plugin mode for %s", 5014 plugin_output_filename); 5015 5016 if (nb_plugin_files == 0 || !plugin_files) 5017 fatal ("No plugin files given in plugin mode for %s", 5018 plugin_output_filename); 5019 5020 /* Parse our plugin files and augment the state. */ 5021 for (ix = 0; ix < nb_plugin_files; ix++) 5022 { 5023 input_file* pluginput = plugin_files [ix]; 5024 pluginput->inpisplugin = true; 5025 parse_file (get_input_file_name (pluginput)); 5026 } 5027 if (hit_error) 5028 return 1; 5029 5030 plugin_output = create_file ("GCC", plugin_output_filename); 5031 DBGPRINTF ("created plugin_output %p named %s", 5032 (void *) plugin_output, plugin_output->name); 5033 } 5034 else 5035 { /* No plugin files, we are in normal mode. */ 5036 if (!srcdir) 5037 fatal ("gengtype needs a source directory in normal mode"); 5038 } 5039 if (hit_error) 5040 return 1; 5041 5042 gen_rtx_next (); 5043 5044 /* The call to set_gc_used may indirectly call find_param_structure 5045 hence enlarge the param_structs list of types. */ 5046 set_gc_used (variables); 5047 5048 /* The state at this point is read from the state input file or by 5049 parsing source files and optionally augmented by parsing plugin 5050 source files. Write it now. */ 5051 if (write_state_filename) 5052 { 5053 DBGPRINT_COUNT_TYPE ("structures before write_state", structures); 5054 DBGPRINT_COUNT_TYPE ("param_structs before write_state", param_structs); 5055 5056 if (hit_error) 5057 fatal ("didn't write state file %s after errors", 5058 write_state_filename); 5059 5060 DBGPRINTF ("before write_state %s", write_state_filename); 5061 write_state (write_state_filename); 5062 5063 if (do_dump) 5064 dump_everything (); 5065 5066 /* After having written the state file we return immediately to 5067 avoid generating any output file. */ 5068 if (hit_error) 5069 return 1; 5070 else 5071 return 0; 5072 } 5073 5074 5075 open_base_files (); 5076 5077 write_enum_defn (structures, param_structs); 5078 output_header = plugin_output ? plugin_output : header_file; 5079 write_typed_alloc_defns (output_header, structures, typedefs); 5080 DBGPRINT_COUNT_TYPE ("structures before write_types outputheader", 5081 structures); 5082 DBGPRINT_COUNT_TYPE ("param_structs before write_types outputheader", 5083 param_structs); 5084 5085 write_types (output_header, structures, param_structs, &ggc_wtd); 5086 if (plugin_files == NULL) 5087 { 5088 DBGPRINT_COUNT_TYPE ("structures before write_types headerfil", 5089 structures); 5090 DBGPRINT_COUNT_TYPE ("param_structs before write_types headerfil", 5091 param_structs); 5092 write_types (header_file, structures, param_structs, &pch_wtd); 5093 write_local (header_file, structures, param_structs); 5094 } 5095 write_splay_tree_allocators (param_structs); 5096 write_roots (variables, plugin_files == NULL); 5097 write_rtx_next (); 5098 close_output_files (); 5099 5100 if (do_dump) 5101 dump_everything (); 5102 5103 /* Don't bother about free-ing any input or plugin file, etc. */ 5104 5105 if (hit_error) 5106 return 1; 5107 return 0; 5108 } 5109