c++: Implement C++23 P2266R1, Simpler implicit move [PR101165]
[official-gcc.git] / gcc / gengtype.cc
blob42363439bd8bd73ad5215b12145d1b44eedc9cca
1 /* Process source files and output type information.
2 Copyright (C) 2002-2022 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 #ifdef HOST_GENERATOR_FILE
21 #include "config.h"
22 #define GENERATOR_FILE 1
23 #else
24 #include "bconfig.h"
25 #endif
26 #include "system.h"
27 #include "errors.h" /* for fatal */
28 #include "getopt.h"
29 #include "version.h" /* for version_string & pkgversion_string. */
30 #include "xregex.h"
31 #include "obstack.h"
32 #include "gengtype.h"
33 #include "filenames.h"
35 /* Data types, macros, etc. used only in this file. */
38 /* The list of output files. */
39 outf_p output_files;
41 /* The output header file that is included into pretty much every
42 source file. */
43 outf_p header_file;
46 /* The name of the file containing the list of input files. */
47 static char *inputlist;
49 /* The plugin input files and their number; in that case only
50 a single file is produced. */
51 static input_file **plugin_files;
52 static size_t nb_plugin_files;
54 /* The generated plugin output file and name. */
55 static outf_p plugin_output;
56 static char *plugin_output_filename;
58 /* Our source directory and its length. */
59 const char *srcdir;
60 size_t srcdir_len;
62 /* Variables used for reading and writing the state. */
63 const char *read_state_filename;
64 const char *write_state_filename;
66 /* Variables to help debugging. */
67 int do_dump;
68 int do_debug;
70 /* Level for verbose messages. */
71 int verbosity_level;
73 /* We have a type count and use it to set the state_number of newly
74 allocated types to some unique negative number. */
75 static int type_count;
77 /* The backup directory should be in the same file system as the
78 generated files, otherwise the rename(2) system call would fail.
79 If NULL, no backup is made when overwriting a generated file. */
80 static const char* backup_dir; /* (-B) program option. */
83 static outf_p create_file (const char *, const char *);
85 static const char *get_file_basename (const input_file *);
86 static const char *get_file_realbasename (const input_file *);
88 static int get_prefix_langdir_index (const char *);
89 static const char *get_file_langdir (const input_file *);
91 static void dump_pair (int indent, pair_p p);
92 static void dump_type (int indent, type_p p);
93 static void dump_type_list (int indent, type_p p);
96 /* Nonzero iff an error has occurred. */
97 bool hit_error = false;
99 static void gen_rtx_next (void);
100 static void write_rtx_next (void);
101 static void open_base_files (void);
102 static void close_output_files (void);
104 /* Report an error at POS, printing MSG. */
106 void
107 error_at_line (const struct fileloc *pos, const char *msg, ...)
109 va_list ap;
111 gcc_assert (pos != NULL && pos->file != NULL);
112 va_start (ap, msg);
114 fprintf (stderr, "%s:%d: ", get_input_file_name (pos->file), pos->line);
115 vfprintf (stderr, msg, ap);
116 fputc ('\n', stderr);
117 hit_error = true;
119 va_end (ap);
122 /* Locate the ultimate base class of struct S. */
124 static const_type_p
125 get_ultimate_base_class (const_type_p s)
127 while (s->u.s.base_class)
128 s = s->u.s.base_class;
129 return s;
132 static type_p
133 get_ultimate_base_class (type_p s)
135 while (s->u.s.base_class)
136 s = s->u.s.base_class;
137 return s;
140 /* Input file handling. */
142 /* Table of all input files. */
143 const input_file **gt_files;
144 size_t num_gt_files;
146 /* Table of headers to be included in gtype-desc.cc that are generated
147 during the build. These are identified as "./<filename>.h". */
148 const char **build_headers;
149 size_t num_build_headers;
151 /* A number of places use the name of this "gengtype.cc" file for a
152 location for things that we can't rely on the source to define.
153 Make sure we can still use pointer comparison on filenames. */
154 input_file* this_file;
155 /* The "system.h" file is likewise specially useful. */
156 input_file* system_h_file;
158 /* Vector of per-language directories. */
159 const char **lang_dir_names;
160 size_t num_lang_dirs;
162 /* An array of output files suitable for definitions. There is one
163 BASE_FILES entry for each language. */
164 static outf_p *base_files;
166 /* Utility debugging function, printing the various type counts within
167 a list of types. Called through the DBGPRINT_COUNT_TYPE macro. */
168 void
169 dbgprint_count_type_at (const char *fil, int lin, const char *msg, type_p t)
171 int nb_types = 0, nb_scalar = 0, nb_string = 0;
172 int nb_struct = 0, nb_union = 0, nb_array = 0, nb_pointer = 0;
173 int nb_lang_struct = 0;
174 int nb_user_struct = 0, nb_undefined = 0;
175 int nb_callback = 0;
176 type_p p = NULL;
177 for (p = t; p; p = p->next)
179 nb_types++;
180 switch (p->kind)
182 case TYPE_UNDEFINED:
183 nb_undefined++;
184 break;
185 case TYPE_SCALAR:
186 nb_scalar++;
187 break;
188 case TYPE_STRING:
189 nb_string++;
190 break;
191 case TYPE_STRUCT:
192 nb_struct++;
193 break;
194 case TYPE_USER_STRUCT:
195 nb_user_struct++;
196 break;
197 case TYPE_UNION:
198 nb_union++;
199 break;
200 case TYPE_POINTER:
201 nb_pointer++;
202 break;
203 case TYPE_ARRAY:
204 nb_array++;
205 break;
206 case TYPE_CALLBACK:
207 nb_callback++;
208 break;
209 case TYPE_LANG_STRUCT:
210 nb_lang_struct++;
211 break;
212 case TYPE_NONE:
213 gcc_unreachable ();
216 fprintf (stderr, "\n" "%s:%d: %s: @@%%@@ %d types ::\n",
217 lbasename (fil), lin, msg, nb_types);
218 if (nb_scalar > 0 || nb_string > 0)
219 fprintf (stderr, "@@%%@@ %d scalars, %d strings\n", nb_scalar, nb_string);
220 if (nb_struct > 0 || nb_union > 0)
221 fprintf (stderr, "@@%%@@ %d structs, %d unions\n", nb_struct, nb_union);
222 if (nb_pointer > 0 || nb_array > 0)
223 fprintf (stderr, "@@%%@@ %d pointers, %d arrays\n", nb_pointer, nb_array);
224 if (nb_callback > 0)
225 fprintf (stderr, "@@%%@@ %d callbacks\n", nb_callback);
226 if (nb_lang_struct > 0)
227 fprintf (stderr, "@@%%@@ %d lang_structs\n", nb_lang_struct);
228 if (nb_user_struct > 0)
229 fprintf (stderr, "@@%%@@ %d user_structs\n", nb_user_struct);
230 if (nb_undefined > 0)
231 fprintf (stderr, "@@%%@@ %d undefined types\n", nb_undefined);
232 fprintf (stderr, "\n");
235 /* Scan the input file, LIST, and determine how much space we need to
236 store strings in. Also, count the number of language directories
237 and files. The numbers returned are overestimates as they does not
238 consider repeated files. */
239 static size_t
240 measure_input_list (FILE *list)
242 size_t n = 0;
243 int c;
244 bool atbol = true;
245 num_lang_dirs = 0;
246 num_gt_files = plugin_files ? nb_plugin_files : 0;
247 while ((c = getc (list)) != EOF)
249 n++;
250 if (atbol)
252 if (c == '[')
253 num_lang_dirs++;
254 else
256 /* Add space for a lang_bitmap before the input file name. */
257 n += sizeof (lang_bitmap);
258 num_gt_files++;
260 atbol = false;
263 if (c == '\n')
264 atbol = true;
267 rewind (list);
268 return n;
271 /* Read one input line from LIST to HEREP (which is updated). A
272 pointer to the string is returned via LINEP. If it was a language
273 subdirectory in square brackets, strip off the square brackets and
274 return true. Otherwise, leave space before the string for a
275 lang_bitmap, and return false. At EOF, returns false, does not
276 touch *HEREP, and sets *LINEP to NULL. POS is used for
277 diagnostics. */
278 static bool
279 read_input_line (FILE *list, char **herep, char **linep, struct fileloc *pos)
281 char *here = *herep;
282 char *line;
283 int c = getc (list);
285 /* Read over whitespace. */
286 while (c == '\n' || c == ' ')
287 c = getc (list);
289 if (c == EOF)
291 *linep = 0;
292 return false;
294 else if (c == '[')
296 /* No space for a lang_bitmap is necessary. Discard the '['. */
297 c = getc (list);
298 line = here;
299 while (c != ']' && c != '\n' && c != EOF)
301 *here++ = c;
302 c = getc (list);
304 *here++ = '\0';
306 if (c == ']')
308 c = getc (list); /* eat what should be a newline */
309 if (c != '\n' && c != EOF)
310 error_at_line (pos, "junk on line after language tag [%s]", line);
312 else
313 error_at_line (pos, "missing close bracket for language tag [%s",
314 line);
316 *herep = here;
317 *linep = line;
318 return true;
320 else
322 /* Leave space for a lang_bitmap. */
323 memset (here, 0, sizeof (lang_bitmap));
324 here += sizeof (lang_bitmap);
325 line = here;
328 *here++ = c;
329 c = getc (list);
331 while (c != EOF && c != '\n');
332 *here++ = '\0';
333 *herep = here;
334 *linep = line;
335 return false;
339 /* Read the list of input files from LIST and compute all of the
340 relevant tables. There is one file per line of the list. At
341 first, all the files on the list are language-generic, but
342 eventually a line will appear which is the name of a language
343 subdirectory in square brackets, like this: [cp]. All subsequent
344 files are specific to that language, until another language
345 subdirectory tag appears. Files can appear more than once, if
346 they apply to more than one language. */
347 static void
348 read_input_list (const char *listname)
350 FILE *list = fopen (listname, "r");
351 if (!list)
352 fatal ("cannot open %s: %s", listname, xstrerror (errno));
353 else
355 struct fileloc epos;
356 size_t bufsz = measure_input_list (list);
357 char *buf = XNEWVEC (char, bufsz);
358 char *here = buf;
359 char *committed = buf;
360 char *limit = buf + bufsz;
361 char *line;
362 bool is_language;
363 size_t langno = 0;
364 size_t nfiles = 0;
365 lang_bitmap curlangs = (1 << num_lang_dirs) - 1;
367 epos.file = input_file_by_name (listname);
368 epos.line = 0;
370 lang_dir_names = XNEWVEC (const char *, num_lang_dirs);
371 gt_files = XNEWVEC (const input_file *, num_gt_files);
373 for (;;)
375 next_line:
376 epos.line++;
377 committed = here;
378 is_language = read_input_line (list, &here, &line, &epos);
379 gcc_assert (here <= limit);
380 if (line == 0)
381 break;
382 else if (is_language)
384 size_t i;
385 gcc_assert (langno <= num_lang_dirs);
386 for (i = 0; i < langno; i++)
387 if (strcmp (lang_dir_names[i], line) == 0)
389 error_at_line (&epos, "duplicate language tag [%s]",
390 line);
391 curlangs = 1 << i;
392 here = committed;
393 goto next_line;
396 curlangs = 1 << langno;
397 lang_dir_names[langno++] = line;
399 else
401 size_t i;
402 input_file *inpf = input_file_by_name (line);
403 gcc_assert (nfiles <= num_gt_files);
404 for (i = 0; i < nfiles; i++)
405 /* Since the input_file-s are uniquely hash-consed, we
406 can just compare pointers! */
407 if (gt_files[i] == inpf)
409 /* Throw away the string we just read, and add the
410 current language to the existing string's bitmap. */
411 lang_bitmap bmap = get_lang_bitmap (inpf);
412 if (bmap & curlangs)
413 error_at_line (&epos,
414 "file %s specified more than once "
415 "for language %s", line,
416 langno ==
417 0 ? "(all)" : lang_dir_names[langno -
418 1]);
420 bmap |= curlangs;
421 set_lang_bitmap (inpf, bmap);
422 here = committed;
423 goto next_line;
426 set_lang_bitmap (inpf, curlangs);
427 gt_files[nfiles++] = inpf;
430 /* Update the global counts now that we know accurately how many
431 things there are. (We do not bother resizing the arrays down.) */
432 num_lang_dirs = langno;
433 /* Add the plugin files if provided. */
434 if (plugin_files)
436 size_t i;
437 for (i = 0; i < nb_plugin_files; i++)
438 gt_files[nfiles++] = plugin_files[i];
440 num_gt_files = nfiles;
443 /* Sanity check: any file that resides in a language subdirectory
444 (e.g. 'cp') ought to belong to the corresponding language.
445 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
446 (Can you even do that? Should you be allowed to?) */
448 size_t f;
449 for (f = 0; f < num_gt_files; f++)
451 lang_bitmap bitmap = get_lang_bitmap (gt_files[f]);
452 const char *basename = get_file_basename (gt_files[f]);
453 const char *slashpos = strchr (basename, '/');
454 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
455 const char *slashpos2 = strchr (basename, '\\');
457 if (!slashpos || (slashpos2 && slashpos2 < slashpos))
458 slashpos = slashpos2;
459 #endif
461 if (slashpos)
463 size_t l;
464 for (l = 0; l < num_lang_dirs; l++)
465 if ((size_t) (slashpos - basename) == strlen (lang_dir_names[l])
466 && memcmp (basename, lang_dir_names[l],
467 strlen (lang_dir_names[l])) == 0)
469 if (!(bitmap & (1 << l)))
470 error ("%s is in language directory '%s' but is not "
471 "tagged for that language",
472 basename, lang_dir_names[l]);
473 break;
479 if (ferror (list))
480 fatal ("error reading %s: %s", listname, xstrerror (errno));
482 fclose (list);
487 /* The one and only TYPE_STRING. */
489 struct type string_type = {
490 TYPE_STRING, 0, 0, 0, GC_USED, {0}
493 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
494 set early in main. */
496 struct type scalar_nonchar = {
497 TYPE_SCALAR, 0, 0, 0, GC_USED, {0}
500 struct type scalar_char = {
501 TYPE_SCALAR, 0, 0, 0, GC_USED, {0}
504 struct type callback_type = {
505 TYPE_CALLBACK, 0, 0, 0, GC_USED, {0}
508 /* Lists of various things. */
510 pair_p typedefs = NULL;
511 type_p structures = NULL;
512 pair_p variables = NULL;
514 static type_p adjust_field_rtx_def (type_p t, options_p opt);
516 /* Define S as a typedef to T at POS. */
518 void
519 do_typedef (const char *s, type_p t, struct fileloc *pos)
521 pair_p p;
523 /* temporary kludge - gengtype doesn't handle conditionals or
524 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
525 is coming from this file (main() sets them up with safe dummy
526 definitions). */
527 if (!strcmp (s, "CUMULATIVE_ARGS") && pos->file != this_file)
528 return;
530 for (p = typedefs; p != NULL; p = p->next)
531 if (strcmp (p->name, s) == 0)
533 if (p->type != t && strcmp (s, "result_type") != 0)
535 error_at_line (pos, "type `%s' previously defined", s);
536 error_at_line (&p->line, "previously defined here");
538 return;
541 p = XNEW (struct pair);
542 p->next = typedefs;
543 p->name = s;
544 p->type = t;
545 p->line = *pos;
546 p->opt = NULL;
547 typedefs = p;
550 /* Define S as a typename of a scalar. Cannot be used to define
551 typedefs of 'char'. Note: is also used for pointer-to-function
552 typedefs (which are therefore not treated as pointers). */
554 void
555 do_scalar_typedef (const char *s, struct fileloc *pos)
557 do_typedef (s, &scalar_nonchar, pos);
560 /* Similar to strtok_r. */
562 static char *
563 strtoken (char *str, const char *delim, char **next)
565 char *p;
567 if (str == NULL)
568 str = *next;
570 /* Skip the leading delimiters. */
571 str += strspn (str, delim);
572 if (*str == '\0')
573 /* This is an empty token. */
574 return NULL;
576 /* The current token. */
577 p = str;
579 /* Find the next delimiter. */
580 str += strcspn (str, delim);
581 if (*str == '\0')
582 /* This is the last token. */
583 *next = str;
584 else
586 /* Terminate the current token. */
587 *str = '\0';
588 /* Advance to the next token. */
589 *next = str + 1;
592 return p;
595 /* Define TYPE_NAME to be a user defined type at location POS. */
597 type_p
598 create_user_defined_type (const char *type_name, struct fileloc *pos)
600 type_p ty = find_structure (type_name, TYPE_USER_STRUCT);
602 /* We might have already seen an incomplete decl of the given type,
603 in which case we won't have yet seen a GTY((user)), and the type will
604 only have kind "TYPE_STRUCT". Mark it as a user struct. */
605 ty->kind = TYPE_USER_STRUCT;
607 ty->u.s.line = *pos;
608 ty->u.s.bitmap = get_lang_bitmap (pos->file);
609 do_typedef (type_name, ty, pos);
611 /* If TYPE_NAME specifies a template, create references to the types
612 in the template by pretending that each type is a field of TY.
613 This is needed to make sure that the types referenced by the
614 template are marked as used. */
615 char *str = xstrdup (type_name);
616 char *open_bracket = strchr (str, '<');
617 if (open_bracket)
619 /* We only accept simple template declarations (see
620 require_template_declaration), so we only need to parse a
621 comma-separated list of strings, implicitly assumed to
622 be type names, potentially with "*" characters. */
623 char *arg = open_bracket + 1;
624 /* Workaround -Wmaybe-uninitialized false positive during
625 profiledbootstrap by initializing it. */
626 char *next = NULL;
627 char *type_id = strtoken (arg, ",>", &next);
628 pair_p fields = 0;
629 while (type_id)
631 /* Create a new field for every type found inside the template
632 parameter list. */
634 /* Support a single trailing "*" character. */
635 const char *star = strchr (type_id, '*');
636 int is_ptr = (star != NULL);
637 size_t offset_to_star = star - type_id;
638 if (is_ptr)
639 offset_to_star = star - type_id;
641 if (strstr (type_id, "char*"))
643 type_id = strtoken (0, ",>", &next);
644 continue;
647 char *field_name = xstrdup (type_id);
649 type_p arg_type;
650 if (is_ptr)
652 /* Strip off the first '*' character (and any subsequent text). */
653 *(field_name + offset_to_star) = '\0';
655 arg_type = find_structure (field_name, TYPE_STRUCT);
656 arg_type = create_pointer (arg_type);
658 else
659 arg_type = resolve_typedef (field_name, pos);
661 fields = create_field_at (fields, arg_type, field_name, 0, pos);
662 type_id = strtoken (0, ",>", &next);
665 /* Associate the field list to TY. */
666 ty->u.s.fields = fields;
668 free (str);
670 return ty;
674 /* Given a typedef name S, return its associated type. Return NULL if
675 S is not a registered type name. */
677 static type_p
678 type_for_name (const char *s)
680 pair_p p;
682 /* Special-case support for types within a "gcc::" namespace. Rather
683 than fully-supporting namespaces, simply strip off the "gcc::" prefix
684 where present. This allows us to have GTY roots of this form:
685 extern GTY(()) gcc::some_type *some_ptr;
686 where the autogenerated functions will refer to simply "some_type",
687 where they can be resolved into their namespace. */
688 if (startswith (s, "gcc::"))
689 s += 5;
691 for (p = typedefs; p != NULL; p = p->next)
692 if (strcmp (p->name, s) == 0)
693 return p->type;
694 return NULL;
698 /* Create an undefined type with name S and location POS. Return the
699 newly created type. */
701 static type_p
702 create_undefined_type (const char *s, struct fileloc *pos)
704 type_p ty = find_structure (s, TYPE_UNDEFINED);
705 ty->u.s.line = *pos;
706 ty->u.s.bitmap = get_lang_bitmap (pos->file);
707 do_typedef (s, ty, pos);
708 return ty;
712 /* Return the type previously defined for S. Use POS to report errors. */
714 type_p
715 resolve_typedef (const char *s, struct fileloc *pos)
717 bool is_template_instance = (strchr (s, '<') != NULL);
718 type_p p = type_for_name (s);
720 /* If we did not find a typedef registered, generate a TYPE_UNDEFINED
721 type for regular type identifiers. If the type identifier S is a
722 template instantiation, however, we treat it as a user defined
723 type.
725 FIXME, this is actually a limitation in gengtype. Supporting
726 template types and their instances would require keeping separate
727 track of the basic types definition and its instances. This
728 essentially forces all template classes in GC to be marked
729 GTY((user)). */
730 if (!p)
731 p = (is_template_instance)
732 ? create_user_defined_type (s, pos)
733 : create_undefined_type (s, pos);
735 return p;
738 /* Add SUBCLASS to head of linked list of BASE's subclasses. */
740 void add_subclass (type_p base, type_p subclass)
742 gcc_assert (union_or_struct_p (base));
743 gcc_assert (union_or_struct_p (subclass));
745 subclass->u.s.next_sibling_class = base->u.s.first_subclass;
746 base->u.s.first_subclass = subclass;
749 /* Create and return a new structure with tag NAME at POS with fields
750 FIELDS and options O. The KIND of structure must be one of
751 TYPE_STRUCT, TYPE_UNION or TYPE_USER_STRUCT. */
753 type_p
754 new_structure (const char *name, enum typekind kind, struct fileloc *pos,
755 pair_p fields, options_p o, type_p base_class)
757 type_p si;
758 type_p s = NULL;
759 lang_bitmap bitmap = get_lang_bitmap (pos->file);
760 bool isunion = (kind == TYPE_UNION);
761 type_p *p = &structures;
763 gcc_assert (union_or_struct_p (kind));
765 for (si = structures; si != NULL; p = &si->next, si = *p)
766 if (strcmp (name, si->u.s.tag) == 0 && UNION_P (si) == isunion)
768 type_p ls = NULL;
769 if (si->kind == TYPE_LANG_STRUCT)
771 ls = si;
773 for (si = ls->u.s.lang_struct; si != NULL; si = si->next)
774 if (si->u.s.bitmap == bitmap)
775 s = si;
777 else if (si->u.s.line.file != NULL && si->u.s.bitmap != bitmap)
779 ls = si;
780 type_count++;
781 si = XCNEW (struct type);
782 memcpy (si, ls, sizeof (struct type));
783 ls->kind = TYPE_LANG_STRUCT;
784 ls->u.s.lang_struct = si;
785 ls->u.s.fields = NULL;
786 si->next = NULL;
787 si->state_number = -type_count;
788 si->pointer_to = NULL;
789 si->u.s.lang_struct = ls;
791 else
792 s = si;
794 if (ls != NULL && s == NULL)
796 type_count++;
797 s = XCNEW (struct type);
798 s->state_number = -type_count;
799 s->next = ls->u.s.lang_struct;
800 ls->u.s.lang_struct = s;
801 s->u.s.lang_struct = ls;
803 break;
806 if (s == NULL)
808 type_count++;
809 s = XCNEW (struct type);
810 s->state_number = -type_count;
811 *p = s;
814 if (s->u.s.lang_struct && (s->u.s.lang_struct->u.s.bitmap & bitmap))
816 error_at_line (pos, "duplicate definition of '%s %s'",
817 isunion ? "union" : "struct", s->u.s.tag);
818 error_at_line (&s->u.s.line, "previous definition here");
821 s->kind = kind;
822 s->u.s.tag = name;
823 s->u.s.line = *pos;
824 s->u.s.fields = fields;
825 s->u.s.opt = o;
826 s->u.s.bitmap = bitmap;
827 if (s->u.s.lang_struct)
828 s->u.s.lang_struct->u.s.bitmap |= bitmap;
829 s->u.s.base_class = base_class;
830 if (base_class)
831 add_subclass (base_class, s);
833 return s;
836 /* Return the previously-defined structure or union with tag NAME,
837 or a new empty structure or union if none was defined previously.
838 The KIND of structure must be one of TYPE_STRUCT, TYPE_UNION or
839 TYPE_USER_STRUCT. */
841 type_p
842 find_structure (const char *name, enum typekind kind)
844 type_p s;
845 bool isunion = (kind == TYPE_UNION);
846 type_p *p = &structures;
848 gcc_assert (kind == TYPE_UNDEFINED || union_or_struct_p (kind));
850 for (s = structures; s != NULL; p = &s->next, s = *p)
851 if (strcmp (name, s->u.s.tag) == 0 && UNION_P (s) == isunion)
852 return s;
854 type_count++;
855 s = XCNEW (struct type);
856 s->state_number = -type_count;
857 s->kind = kind;
858 s->u.s.tag = name;
859 *p = s;
860 return s;
863 /* Return a scalar type with name NAME. */
865 type_p
866 create_scalar_type (const char *name)
868 if (!strcmp (name, "char") || !strcmp (name, "unsigned char"))
869 return &scalar_char;
870 else
871 return &scalar_nonchar;
875 /* Return a pointer to T. */
877 type_p
878 create_pointer (type_p t)
880 if (!t->pointer_to)
882 type_p r = XCNEW (struct type);
883 type_count++;
884 r->state_number = -type_count;
885 r->kind = TYPE_POINTER;
886 r->u.p = t;
887 t->pointer_to = r;
889 return t->pointer_to;
892 /* Return an array of length LEN. */
894 type_p
895 create_array (type_p t, const char *len)
897 type_p v;
899 type_count++;
900 v = XCNEW (struct type);
901 v->kind = TYPE_ARRAY;
902 v->state_number = -type_count;
903 v->u.a.p = t;
904 v->u.a.len = len;
905 return v;
908 /* Return a string options structure with name NAME and info INFO.
909 NEXT is the next option in the chain. */
910 options_p
911 create_string_option (options_p next, const char *name, const char *info)
913 options_p o = XNEW (struct options);
914 o->kind = OPTION_STRING;
915 o->next = next;
916 o->name = name;
917 o->info.string = info;
918 return o;
921 /* Create a type options structure with name NAME and info INFO. NEXT
922 is the next option in the chain. */
923 options_p
924 create_type_option (options_p next, const char* name, type_p info)
926 options_p o = XNEW (struct options);
927 o->next = next;
928 o->name = name;
929 o->kind = OPTION_TYPE;
930 o->info.type = info;
931 return o;
934 /* Create a nested pointer options structure with name NAME and info
935 INFO. NEXT is the next option in the chain. */
936 options_p
937 create_nested_option (options_p next, const char* name,
938 struct nested_ptr_data* info)
940 options_p o;
941 o = XNEW (struct options);
942 o->next = next;
943 o->name = name;
944 o->kind = OPTION_NESTED;
945 o->info.nested = info;
946 return o;
949 /* Return an options structure for a "nested_ptr" option. */
950 options_p
951 create_nested_ptr_option (options_p next, type_p t,
952 const char *to, const char *from)
954 struct nested_ptr_data *d = XNEW (struct nested_ptr_data);
956 d->type = adjust_field_type (t, 0);
957 d->convert_to = to;
958 d->convert_from = from;
959 return create_nested_option (next, "nested_ptr", d);
962 /* Add a variable named S of type T with options O defined at POS,
963 to `variables'. */
964 void
965 note_variable (const char *s, type_p t, options_p o, struct fileloc *pos)
967 pair_p n;
968 n = XNEW (struct pair);
969 n->name = s;
970 n->type = t;
971 n->line = *pos;
972 n->opt = o;
973 n->next = variables;
974 variables = n;
977 /* Most-general structure field creator. */
978 static pair_p
979 create_field_all (pair_p next, type_p type, const char *name, options_p opt,
980 const input_file *inpf, int line)
982 pair_p field;
984 field = XNEW (struct pair);
985 field->next = next;
986 field->type = type;
987 field->name = name;
988 field->opt = opt;
989 field->line.file = inpf;
990 field->line.line = line;
991 return field;
994 /* Create a field that came from the source code we are scanning,
995 i.e. we have a 'struct fileloc', and possibly options; also,
996 adjust_field_type should be called. */
997 pair_p
998 create_field_at (pair_p next, type_p type, const char *name, options_p opt,
999 struct fileloc *pos)
1001 return create_field_all (next, adjust_field_type (type, opt),
1002 name, opt, pos->file, pos->line);
1005 /* Create a fake field with the given type and name. NEXT is the next
1006 field in the chain. */
1007 #define create_field(next,type,name) \
1008 create_field_all (next,type,name, 0, this_file, __LINE__)
1010 /* Like create_field, but the field is only valid when condition COND
1011 is true. */
1013 static pair_p
1014 create_optional_field_ (pair_p next, type_p type, const char *name,
1015 const char *cond, int line)
1017 static int id = 1;
1018 pair_p union_fields;
1019 type_p union_type;
1021 /* Create a fake union type with a single nameless field of type TYPE.
1022 The field has a tag of "1". This allows us to make the presence
1023 of a field of type TYPE depend on some boolean "desc" being true. */
1024 union_fields = create_field (NULL, type, "");
1025 union_fields->opt =
1026 create_string_option (union_fields->opt, "dot", "");
1027 union_fields->opt =
1028 create_string_option (union_fields->opt, "tag", "1");
1029 union_type =
1030 new_structure (xasprintf ("%s_%d", "fake_union", id++), TYPE_UNION,
1031 &lexer_line, union_fields, NULL, NULL);
1033 /* Create the field and give it the new fake union type. Add a "desc"
1034 tag that specifies the condition under which the field is valid. */
1035 return create_field_all (next, union_type, name,
1036 create_string_option (0, "desc", cond),
1037 this_file, line);
1040 #define create_optional_field(next,type,name,cond) \
1041 create_optional_field_(next,type,name,cond,__LINE__)
1043 /* Reverse a linked list of 'struct pair's in place. */
1044 pair_p
1045 nreverse_pairs (pair_p list)
1047 pair_p prev = 0, p, next;
1048 for (p = list; p; p = next)
1050 next = p->next;
1051 p->next = prev;
1052 prev = p;
1054 return prev;
1058 /* We don't care how long a CONST_DOUBLE is. */
1059 #define CONST_DOUBLE_FORMAT "ww"
1060 /* We don't want to see codes that are only for generator files. */
1061 #undef GENERATOR_FILE
1063 enum rtx_code
1065 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
1066 #include "rtl.def"
1067 #undef DEF_RTL_EXPR
1068 NUM_RTX_CODE
1071 static const char *const rtx_name[NUM_RTX_CODE] = {
1072 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
1073 #include "rtl.def"
1074 #undef DEF_RTL_EXPR
1077 static const char *const rtx_format[NUM_RTX_CODE] = {
1078 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
1079 #include "rtl.def"
1080 #undef DEF_RTL_EXPR
1083 static int rtx_next_new[NUM_RTX_CODE];
1085 /* We also need codes and names for insn notes (not register notes).
1086 Note that we do *not* bias the note values here. */
1087 enum insn_note
1089 #define DEF_INSN_NOTE(NAME) NAME,
1090 #include "insn-notes.def"
1091 #undef DEF_INSN_NOTE
1093 NOTE_INSN_MAX
1096 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
1097 default field for line number notes. */
1098 static const char *const note_insn_name[NOTE_INSN_MAX + 1] = {
1099 #define DEF_INSN_NOTE(NAME) #NAME,
1100 #include "insn-notes.def"
1101 #undef DEF_INSN_NOTE
1104 #undef CONST_DOUBLE_FORMAT
1105 #define GENERATOR_FILE
1107 /* Generate the contents of the rtx_next array. This really doesn't belong
1108 in gengtype at all, but it's needed for adjust_field_rtx_def. */
1110 static void
1111 gen_rtx_next (void)
1113 int i;
1114 for (i = 0; i < NUM_RTX_CODE; i++)
1116 int k;
1118 rtx_next_new[i] = -1;
1119 if (startswith (rtx_format[i], "uu"))
1120 rtx_next_new[i] = 1;
1121 else if (i == COND_EXEC || i == SET || i == EXPR_LIST || i == INSN_LIST)
1122 rtx_next_new[i] = 1;
1123 else
1124 for (k = strlen (rtx_format[i]) - 1; k >= 0; k--)
1125 if (rtx_format[i][k] == 'e' || rtx_format[i][k] == 'u')
1126 rtx_next_new[i] = k;
1130 /* Write out the contents of the rtx_next array. */
1131 static void
1132 write_rtx_next (void)
1134 outf_p f = get_output_file_with_visibility (NULL);
1135 int i;
1136 if (!f)
1137 return;
1139 oprintf (f, "\n/* Used to implement the RTX_NEXT macro. */\n");
1140 oprintf (f, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
1141 for (i = 0; i < NUM_RTX_CODE; i++)
1142 if (rtx_next_new[i] == -1)
1143 oprintf (f, " 0,\n");
1144 else
1145 oprintf (f,
1146 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n", rtx_next_new[i]);
1147 oprintf (f, "};\n");
1150 /* Handle `special("rtx_def")'. This is a special case for field
1151 `fld' of struct rtx_def, which is an array of unions whose values
1152 are based in a complex way on the type of RTL. */
1154 static type_p
1155 adjust_field_rtx_def (type_p t, options_p ARG_UNUSED (opt))
1157 pair_p flds = NULL;
1158 options_p nodot;
1159 int i;
1160 type_p rtx_tp, rtvec_tp, tree_tp, mem_attrs_tp, note_union_tp, scalar_tp;
1161 type_p basic_block_tp, reg_attrs_tp, constant_tp, symbol_union_tp;
1163 if (t->kind != TYPE_UNION)
1165 error_at_line (&lexer_line,
1166 "special `rtx_def' must be applied to a union");
1167 return &string_type;
1170 nodot = create_string_option (NULL, "dot", "");
1172 rtx_tp = create_pointer (find_structure ("rtx_def", TYPE_STRUCT));
1173 rtvec_tp = create_pointer (find_structure ("rtvec_def", TYPE_STRUCT));
1174 tree_tp = create_pointer (find_structure ("tree_node", TYPE_UNION));
1175 mem_attrs_tp = create_pointer (find_structure ("mem_attrs", TYPE_STRUCT));
1176 reg_attrs_tp =
1177 create_pointer (find_structure ("reg_attrs", TYPE_STRUCT));
1178 basic_block_tp =
1179 create_pointer (find_structure ("basic_block_def", TYPE_STRUCT));
1180 constant_tp =
1181 create_pointer (find_structure ("constant_descriptor_rtx", TYPE_STRUCT));
1182 scalar_tp = &scalar_nonchar; /* rtunion int */
1185 pair_p note_flds = NULL;
1186 int c;
1188 for (c = 0; c <= NOTE_INSN_MAX; c++)
1190 switch (c)
1192 case NOTE_INSN_MAX:
1193 case NOTE_INSN_DELETED_LABEL:
1194 case NOTE_INSN_DELETED_DEBUG_LABEL:
1195 note_flds = create_field (note_flds, &string_type, "rt_str");
1196 break;
1198 case NOTE_INSN_BLOCK_BEG:
1199 case NOTE_INSN_BLOCK_END:
1200 note_flds = create_field (note_flds, tree_tp, "rt_tree");
1201 break;
1203 case NOTE_INSN_VAR_LOCATION:
1204 note_flds = create_field (note_flds, rtx_tp, "rt_rtx");
1205 break;
1207 default:
1208 note_flds = create_field (note_flds, scalar_tp, "rt_int");
1209 break;
1211 /* NOTE_INSN_MAX is used as the default field for line
1212 number notes. */
1213 if (c == NOTE_INSN_MAX)
1214 note_flds->opt =
1215 create_string_option (nodot, "default", "");
1216 else
1217 note_flds->opt =
1218 create_string_option (nodot, "tag", note_insn_name[c]);
1220 note_union_tp = new_structure ("rtx_def_note_subunion", TYPE_UNION,
1221 &lexer_line, note_flds, NULL, NULL);
1223 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1225 pair_p sym_flds;
1226 sym_flds = create_field (NULL, tree_tp, "rt_tree");
1227 sym_flds->opt = create_string_option (nodot, "default", "");
1228 sym_flds = create_field (sym_flds, constant_tp, "rt_constant");
1229 sym_flds->opt = create_string_option (nodot, "tag", "1");
1230 symbol_union_tp = new_structure ("rtx_def_symbol_subunion", TYPE_UNION,
1231 &lexer_line, sym_flds, NULL, NULL);
1233 for (i = 0; i < NUM_RTX_CODE; i++)
1235 pair_p subfields = NULL;
1236 size_t aindex, nmindex;
1237 const char *sname;
1238 type_p substruct;
1239 char *ftag;
1241 for (aindex = 0; aindex < strlen (rtx_format[i]); aindex++)
1243 type_p t;
1244 const char *subname;
1246 switch (rtx_format[i][aindex])
1248 case '*':
1249 case 'i':
1250 case 'n':
1251 case 'w':
1252 case 'r':
1253 t = scalar_tp;
1254 subname = "rt_int";
1255 break;
1257 case 'p':
1258 t = scalar_tp;
1259 subname = "rt_subreg";
1260 break;
1262 case '0':
1263 if (i == MEM && aindex == 1)
1264 t = mem_attrs_tp, subname = "rt_mem";
1265 else if (i == JUMP_INSN && aindex == 7)
1266 t = rtx_tp, subname = "rt_rtx";
1267 else if (i == CODE_LABEL && aindex == 4)
1268 t = scalar_tp, subname = "rt_int";
1269 else if (i == CODE_LABEL && aindex == 3)
1270 t = rtx_tp, subname = "rt_rtx";
1271 else if (i == LABEL_REF && (aindex == 1 || aindex == 2))
1272 t = rtx_tp, subname = "rt_rtx";
1273 else if (i == NOTE && aindex == 3)
1274 t = note_union_tp, subname = "";
1275 else if (i == NOTE && aindex == 4)
1276 t = scalar_tp, subname = "rt_int";
1277 else if (i == NOTE && aindex >= 6)
1278 t = scalar_tp, subname = "rt_int";
1279 else if (i == ADDR_DIFF_VEC && aindex == 4)
1280 t = scalar_tp, subname = "rt_int";
1281 else if (i == VALUE && aindex == 0)
1282 t = scalar_tp, subname = "rt_int";
1283 else if (i == DEBUG_EXPR && aindex == 0)
1284 t = tree_tp, subname = "rt_tree";
1285 else if (i == SYMBOL_REF && aindex == 1)
1286 t = symbol_union_tp, subname = "";
1287 else if (i == JUMP_TABLE_DATA && aindex >= 4)
1288 t = scalar_tp, subname = "rt_int";
1289 else if (i == BARRIER && aindex >= 2)
1290 t = scalar_tp, subname = "rt_int";
1291 else if (i == ENTRY_VALUE && aindex == 0)
1292 t = rtx_tp, subname = "rt_rtx";
1293 else
1295 error_at_line
1296 (&lexer_line,
1297 "rtx type `%s' has `0' in position %lu, can't handle",
1298 rtx_name[i], (unsigned long) aindex);
1299 t = &string_type;
1300 subname = "rt_int";
1302 break;
1304 case 's':
1305 case 'S':
1306 case 'T':
1307 t = &string_type;
1308 subname = "rt_str";
1309 break;
1311 case 'e':
1312 case 'u':
1313 t = rtx_tp;
1314 subname = "rt_rtx";
1315 break;
1317 case 'E':
1318 case 'V':
1319 t = rtvec_tp;
1320 subname = "rt_rtvec";
1321 break;
1323 case 't':
1324 t = tree_tp;
1325 subname = "rt_tree";
1326 break;
1328 case 'B':
1329 t = basic_block_tp;
1330 subname = "rt_bb";
1331 break;
1333 default:
1334 error_at_line
1335 (&lexer_line,
1336 "rtx type `%s' has `%c' in position %lu, can't handle",
1337 rtx_name[i], rtx_format[i][aindex],
1338 (unsigned long) aindex);
1339 t = &string_type;
1340 subname = "rt_int";
1341 break;
1344 subfields = create_field (subfields, t,
1345 xasprintf (".fld[%lu].%s",
1346 (unsigned long) aindex,
1347 subname));
1348 subfields->opt = nodot;
1349 if (t == note_union_tp)
1350 subfields->opt =
1351 create_string_option (subfields->opt, "desc",
1352 "NOTE_KIND (&%0)");
1353 if (t == symbol_union_tp)
1354 subfields->opt =
1355 create_string_option (subfields->opt, "desc",
1356 "CONSTANT_POOL_ADDRESS_P (&%0)");
1359 if (i == REG)
1360 subfields = create_field (subfields, reg_attrs_tp, "reg.attrs");
1362 if (i == SYMBOL_REF)
1364 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P
1365 holds. */
1366 type_p field_tp = find_structure ("block_symbol", TYPE_STRUCT);
1367 subfields
1368 = create_optional_field (subfields, field_tp, "block_sym",
1369 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1372 sname = xasprintf ("rtx_def_%s", rtx_name[i]);
1373 substruct = new_structure (sname, TYPE_STRUCT, &lexer_line, subfields,
1374 NULL, NULL);
1376 ftag = xstrdup (rtx_name[i]);
1377 for (nmindex = 0; nmindex < strlen (ftag); nmindex++)
1378 ftag[nmindex] = TOUPPER (ftag[nmindex]);
1379 flds = create_field (flds, substruct, "");
1380 flds->opt = create_string_option (nodot, "tag", ftag);
1382 return new_structure ("rtx_def_subunion", TYPE_UNION, &lexer_line, flds,
1383 nodot, NULL);
1386 /* Perform any special processing on a type T, about to become the type
1387 of a field. Return the appropriate type for the field.
1388 At present:
1389 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1390 - Similarly for arrays of pointer-to-char;
1391 - Converts structures for which a parameter is provided to
1392 TYPE_PARAM_STRUCT;
1393 - Handles "special" options.
1396 type_p
1397 adjust_field_type (type_p t, options_p opt)
1399 int length_p = 0;
1400 const int pointer_p = t->kind == TYPE_POINTER;
1402 for (; opt; opt = opt->next)
1403 if (strcmp (opt->name, "length") == 0)
1405 if (length_p)
1406 error_at_line (&lexer_line, "duplicate `%s' option", opt->name);
1407 if (t->u.p->kind == TYPE_SCALAR || t->u.p->kind == TYPE_STRING)
1409 error_at_line (&lexer_line,
1410 "option `%s' may not be applied to "
1411 "arrays of atomic types", opt->name);
1413 length_p = 1;
1415 else if (strcmp (opt->name, "special") == 0
1416 && opt->kind == OPTION_STRING)
1418 const char *special_name = opt->info.string;
1419 if (strcmp (special_name, "rtx_def") == 0)
1420 t = adjust_field_rtx_def (t, opt);
1421 else
1422 error_at_line (&lexer_line, "unknown special `%s'", special_name);
1425 if (!length_p
1426 && pointer_p && t->u.p->kind == TYPE_SCALAR && t->u.p->u.scalar_is_char)
1427 return &string_type;
1428 if (t->kind == TYPE_ARRAY && t->u.a.p->kind == TYPE_POINTER
1429 && t->u.a.p->u.p->kind == TYPE_SCALAR
1430 && t->u.a.p->u.p->u.scalar_is_char)
1431 return create_array (&string_type, t->u.a.len);
1433 return t;
1437 static void set_gc_used_type (type_p, enum gc_used_enum, bool = false);
1438 static void set_gc_used (pair_p);
1440 /* Handle OPT for set_gc_used_type. */
1442 static void
1443 process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef,
1444 int *length, int *skip, int *callback, type_p *nested_ptr)
1446 options_p o;
1447 for (o = opt; o; o = o->next)
1448 if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO
1449 && o->kind == OPTION_TYPE)
1450 set_gc_used_type (o->info.type,
1451 GC_POINTED_TO);
1452 else if (strcmp (o->name, "maybe_undef") == 0)
1453 *maybe_undef = 1;
1454 else if (strcmp (o->name, "length") == 0)
1455 *length = 1;
1456 else if (strcmp (o->name, "skip") == 0)
1457 *skip = 1;
1458 else if (strcmp (o->name, "callback") == 0)
1459 *callback = 1;
1460 else if (strcmp (o->name, "nested_ptr") == 0
1461 && o->kind == OPTION_NESTED)
1462 *nested_ptr = ((const struct nested_ptr_data *) o->info.nested)->type;
1466 /* Set the gc_used field of T to LEVEL, and handle the types it references.
1468 If ALLOWED_UNDEFINED_TYPES is true, types of kind TYPE_UNDEFINED
1469 are set to GC_UNUSED. Otherwise, an error is emitted for
1470 TYPE_UNDEFINED types. This is used to support user-defined
1471 template types with non-type arguments.
1473 For instance, when we parse a template type with enum arguments
1474 (e.g. MyType<AnotherType, EnumValue>), the parser created two
1475 artificial fields for 'MyType', one for 'AnotherType', the other
1476 one for 'EnumValue'.
1478 At the time that we parse this type we don't know that 'EnumValue'
1479 is really an enum value, so the parser creates a TYPE_UNDEFINED
1480 type for it. Since 'EnumValue' is never resolved to a known
1481 structure, it will stay with TYPE_UNDEFINED.
1483 Since 'MyType' is a TYPE_USER_STRUCT, we can simply ignore
1484 'EnumValue'. Generating marking code for it would cause
1485 compilation failures since the marking routines assumes that
1486 'EnumValue' is a type. */
1488 static void
1489 set_gc_used_type (type_p t, enum gc_used_enum level,
1490 bool allow_undefined_types)
1492 if (t->gc_used >= level)
1493 return;
1495 t->gc_used = level;
1497 switch (t->kind)
1499 case TYPE_STRUCT:
1500 case TYPE_UNION:
1501 case TYPE_USER_STRUCT:
1503 pair_p f;
1504 int dummy;
1505 type_p dummy2;
1506 bool allow_undefined_field_types = (t->kind == TYPE_USER_STRUCT);
1508 process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, &dummy,
1509 &dummy2);
1511 if (t->u.s.base_class)
1512 set_gc_used_type (t->u.s.base_class, level, allow_undefined_types);
1513 /* Anything pointing to a base class might actually be pointing
1514 to a subclass. */
1515 for (type_p subclass = t->u.s.first_subclass; subclass;
1516 subclass = subclass->u.s.next_sibling_class)
1517 set_gc_used_type (subclass, level, allow_undefined_types);
1519 FOR_ALL_INHERITED_FIELDS(t, f)
1521 int maybe_undef = 0;
1522 int length = 0;
1523 int skip = 0;
1524 int callback = 0;
1525 type_p nested_ptr = NULL;
1526 process_gc_options (f->opt, level, &maybe_undef, &length, &skip,
1527 &callback, &nested_ptr);
1529 if (nested_ptr && f->type->kind == TYPE_POINTER)
1530 set_gc_used_type (nested_ptr, GC_POINTED_TO);
1531 else if (length && f->type->kind == TYPE_POINTER)
1532 set_gc_used_type (f->type->u.p, GC_USED);
1533 else if (maybe_undef && f->type->kind == TYPE_POINTER)
1534 set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO);
1535 else if (skip)
1536 ; /* target type is not used through this field */
1537 else if (callback)
1538 f->type = &callback_type;
1539 else
1540 set_gc_used_type (f->type, GC_USED, allow_undefined_field_types);
1542 break;
1545 case TYPE_UNDEFINED:
1546 if (level > GC_UNUSED)
1548 if (!allow_undefined_types)
1549 error_at_line (&t->u.s.line, "undefined type `%s'", t->u.s.tag);
1550 t->gc_used = GC_UNUSED;
1552 break;
1554 case TYPE_POINTER:
1555 set_gc_used_type (t->u.p, GC_POINTED_TO);
1556 break;
1558 case TYPE_ARRAY:
1559 set_gc_used_type (t->u.a.p, GC_USED);
1560 break;
1562 case TYPE_LANG_STRUCT:
1563 for (t = t->u.s.lang_struct; t; t = t->next)
1564 set_gc_used_type (t, level);
1565 break;
1567 default:
1568 break;
1572 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1574 static void
1575 set_gc_used (pair_p variables)
1577 int nbvars = 0;
1578 pair_p p;
1579 for (p = variables; p; p = p->next)
1581 set_gc_used_type (p->type, GC_USED);
1582 nbvars++;
1584 if (verbosity_level >= 2)
1585 printf ("%s used %d GTY-ed variables\n", progname, nbvars);
1588 /* File mapping routines. For each input file, there is one output .cc file
1589 (but some output files have many input files), and there is one .h file
1590 for the whole build. */
1592 /* Output file handling. */
1594 /* Create and return an outf_p for a new file for NAME, to be called
1595 ONAME. */
1597 static outf_p
1598 create_file (const char *name, const char *oname)
1600 static const char *const hdr[] = {
1601 " Copyright (C) 2004-2022 Free Software Foundation, Inc.\n",
1602 "\n",
1603 "This file is part of GCC.\n",
1604 "\n",
1605 "GCC is free software; you can redistribute it and/or modify it under\n",
1606 "the terms of the GNU General Public License as published by the Free\n",
1607 "Software Foundation; either version 3, or (at your option) any later\n",
1608 "version.\n",
1609 "\n",
1610 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1611 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1612 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1613 "for more details.\n",
1614 "\n",
1615 "You should have received a copy of the GNU General Public License\n",
1616 "along with GCC; see the file COPYING3. If not see\n",
1617 "<http://www.gnu.org/licenses/>. */\n",
1618 "\n",
1619 "/* This file is machine generated. Do not edit. */\n"
1621 outf_p f;
1622 size_t i;
1624 gcc_assert (name != NULL);
1625 gcc_assert (oname != NULL);
1626 f = XCNEW (struct outf);
1627 f->next = output_files;
1628 f->name = oname;
1629 output_files = f;
1631 oprintf (f, "/* Type information for %s.\n", name);
1632 for (i = 0; i < ARRAY_SIZE (hdr); i++)
1633 oprintf (f, "%s", hdr[i]);
1634 return f;
1637 /* Print, like fprintf, to O.
1638 N.B. You might think this could be implemented more efficiently
1639 with vsnprintf(). Unfortunately, there are C libraries that
1640 provide that function but without the C99 semantics for its return
1641 value, making it impossible to know how much space is required. */
1642 void
1643 oprintf (outf_p o, const char *format, ...)
1645 char *s;
1646 size_t slength;
1647 va_list ap;
1649 /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1650 in that case. */
1651 if (!o)
1652 return;
1654 va_start (ap, format);
1655 slength = vasprintf (&s, format, ap);
1656 if (s == NULL || (int) slength < 0)
1657 fatal ("out of memory");
1658 va_end (ap);
1660 if (o->bufused + slength > o->buflength)
1662 size_t new_len = o->buflength;
1663 if (new_len == 0)
1664 new_len = 1024;
1667 new_len *= 2;
1669 while (o->bufused + slength >= new_len);
1670 o->buf = XRESIZEVEC (char, o->buf, new_len);
1671 o->buflength = new_len;
1673 memcpy (o->buf + o->bufused, s, slength);
1674 o->bufused += slength;
1675 free (s);
1678 /* Open the global header file and the language-specific header files. */
1680 static void
1681 open_base_files (void)
1683 size_t i;
1685 if (nb_plugin_files > 0 && plugin_files)
1686 return;
1688 header_file = create_file ("GCC", "gtype-desc.h");
1690 base_files = XNEWVEC (outf_p, num_lang_dirs);
1692 for (i = 0; i < num_lang_dirs; i++)
1693 base_files[i] = create_file (lang_dir_names[i],
1694 xasprintf ("gtype-%s.h", lang_dir_names[i]));
1696 /* gtype-desc.cc is a little special, so we create it here. */
1698 /* The order of files here matters very much. */
1699 static const char *const ifiles[] = {
1700 "config.h", "system.h", "coretypes.h",
1701 "backend.h", "predict.h", "tree.h",
1702 "rtl.h", "gimple.h", "fold-const.h", "insn-codes.h", "splay-tree.h",
1703 "alias.h", "insn-config.h", "flags.h", "expmed.h", "dojump.h",
1704 "explow.h", "calls.h", "memmodel.h", "emit-rtl.h", "varasm.h",
1705 "stmt.h", "expr.h", "alloc-pool.h", "cselib.h", "insn-addr.h",
1706 "optabs.h", "libfuncs.h", "debug.h", "internal-fn.h",
1707 "gimple-iterator.h", "gimple-fold.h", "value-range.h",
1708 "value-range-storage.h",
1709 "tree-eh.h", "gimple-ssa.h", "tree-cfg.h",
1710 "tree-vrp.h", "tree-phinodes.h", "ssa-iterators.h", "stringpool.h",
1711 "tree-ssanames.h", "tree-ssa-loop.h", "tree-ssa-loop-ivopts.h",
1712 "tree-ssa-loop-manip.h", "tree-ssa-loop-niter.h", "tree-into-ssa.h",
1713 "tree-dfa.h", "tree-ssa.h", "reload.h", "cpplib.h", "tree-chrec.h",
1714 "except.h", "output.h", "cfgloop.h", "target.h", "lto-streamer.h",
1715 "target-globals.h", "ipa-ref.h", "cgraph.h", "symbol-summary.h",
1716 "ipa-prop.h", "ipa-fnsummary.h", "dwarf2out.h", "omp-general.h",
1717 "omp-offload.h", "ipa-modref-tree.h", "ipa-modref.h", "symtab-thunks.h",
1718 "symtab-clones.h", "diagnostic-spec.h", "ctfc.h",
1719 NULL
1721 const char *const *ifp;
1722 outf_p gtype_desc_c;
1724 gtype_desc_c = create_file ("GCC", "gtype-desc.cc");
1725 for (ifp = ifiles; *ifp; ifp++)
1726 oprintf (gtype_desc_c, "#include \"%s\"\n", *ifp);
1727 for (int j = 0; j < (int) num_build_headers; j++)
1728 oprintf (gtype_desc_c, "#include \"%s\"\n", build_headers[j]);
1730 /* Make sure we handle "cfun" specially. */
1731 oprintf (gtype_desc_c, "\n/* See definition in function.h. */\n");
1732 oprintf (gtype_desc_c, "#undef cfun\n");
1734 oprintf (gtype_desc_c,
1735 "\n"
1736 "/* Types with a \"gcc::\" namespace have it stripped\n"
1737 " during gengtype parsing. Provide a \"using\" directive\n"
1738 " to ensure that the fully-qualified types are found. */\n"
1739 "using namespace gcc;\n");
1743 /* For INPF an input file, return the real basename of INPF, with all
1744 the directory components skipped. */
1746 static const char *
1747 get_file_realbasename (const input_file *inpf)
1749 return lbasename (get_input_file_name (inpf));
1752 /* For INPF a filename, return the relative path to INPF from
1753 $(srcdir) if the latter is a prefix in INPF, NULL otherwise. */
1755 const char *
1756 get_file_srcdir_relative_path (const input_file *inpf)
1758 const char *f = get_input_file_name (inpf);
1759 if (strlen (f) > srcdir_len
1760 && IS_DIR_SEPARATOR (f[srcdir_len])
1761 && strncmp (f, srcdir, srcdir_len) == 0)
1762 return f + srcdir_len + 1;
1763 else
1764 return NULL;
1767 /* For INPF an input_file, return the relative path to INPF from
1768 $(srcdir) if the latter is a prefix in INPF, or the real basename
1769 of INPF otherwise. */
1771 static const char *
1772 get_file_basename (const input_file *inpf)
1774 const char *srcdir_path = get_file_srcdir_relative_path (inpf);
1776 return (srcdir_path != NULL) ? srcdir_path : get_file_realbasename (inpf);
1779 /* For F a filename, return the lang_dir_names relative index of the language
1780 directory that is a prefix in F, if any, -1 otherwise. */
1782 static int
1783 get_prefix_langdir_index (const char *f)
1785 size_t f_len = strlen (f);
1786 size_t lang_index;
1788 for (lang_index = 0; lang_index < num_lang_dirs; lang_index++)
1790 const char *langdir = lang_dir_names[lang_index];
1791 size_t langdir_len = strlen (langdir);
1793 if (f_len > langdir_len
1794 && IS_DIR_SEPARATOR (f[langdir_len])
1795 && memcmp (f, langdir, langdir_len) == 0)
1796 return lang_index;
1799 return -1;
1802 /* For INPF an input file, return the name of language directory where
1803 F is located, if any, NULL otherwise. */
1805 static const char *
1806 get_file_langdir (const input_file *inpf)
1808 /* Get the relative path to INPF from $(srcdir) and find the
1809 language by comparing the prefix with language directory names.
1810 If INPF is not even srcdir relative, no point in looking
1811 further. */
1813 int lang_index;
1814 const char *srcdir_relative_path = get_file_srcdir_relative_path (inpf);
1815 const char *r;
1817 if (!srcdir_relative_path)
1818 return NULL;
1820 lang_index = get_prefix_langdir_index (srcdir_relative_path);
1821 if (lang_index < 0 && startswith (srcdir_relative_path, "c-family"))
1822 r = "c-family";
1823 else if (lang_index >= 0)
1824 r = lang_dir_names[lang_index];
1825 else
1826 r = NULL;
1828 return r;
1831 /* The gt- output file name for INPF. */
1833 static const char *
1834 get_file_gtfilename (const input_file *inpf)
1836 /* Cook up an initial version of the gt- file name from the file real
1837 basename and the language name, if any. */
1839 const char *basename = get_file_realbasename (inpf);
1840 const char *langdir = get_file_langdir (inpf);
1842 char *result =
1843 (langdir ? xasprintf ("gt-%s-%s", langdir, basename)
1844 : xasprintf ("gt-%s", basename));
1846 /* Then replace all non alphanumerics characters by '-' and change the
1847 extension to ".h". We expect the input filename extension was at least
1848 one character long. */
1850 char *s = result;
1852 for (; *s != '.'; s++)
1853 if (!ISALNUM (*s) && *s != '-')
1854 *s = '-';
1856 memcpy (s, ".h", sizeof (".h"));
1858 return result;
1861 /* Each input_file has its associated output file outf_p. The
1862 association is computed by the function
1863 get_output_file_with_visibility. The associated file is cached
1864 inside input_file in its inpoutf field, so is really computed only
1865 once. Associated output file paths (i.e. output_name-s) are
1866 computed by a rule based regexp machinery, using the files_rules
1867 array of struct file_rule_st. A for_name is also computed, giving
1868 the source file name for which the output_file is generated; it is
1869 often the last component of the input_file path. */
1873 Regexpr machinery to compute the output_name and for_name-s of each
1874 input_file. We have a sequence of file rules which gives the POSIX
1875 extended regular expression to match an input file path, and two
1876 transformed strings for the corresponding output_name and the
1877 corresponding for_name. The transformed string contain dollars: $0
1878 is replaced by the entire match, $1 is replaced by the substring
1879 matching the first parenthesis in the regexp, etc. And $$ is replaced
1880 by a single verbatim dollar. The rule order is important. The
1881 general case is last, and the particular cases should come before.
1882 An action routine can, when needed, update the out_name & for_name
1883 and/or return the appropriate output file. It is invoked only when a
1884 rule is triggered. When a rule is triggered, the output_name and
1885 for_name are computed using their transform string in while $$, $0,
1886 $1, ... are suitably replaced. If there is an action, it is called.
1887 In some few cases, the action can directly return the outf_p, but
1888 usually it just updates the output_name and for_name so should free
1889 them before replacing them. The get_output_file_with_visibility
1890 function creates an outf_p only once per each output_name, so it
1891 scans the output_files list for previously seen output file names.
1894 /* Signature of actions in file rules. */
1895 typedef outf_p (frul_actionrout_t) (input_file*, char**, char**);
1898 struct file_rule_st {
1899 const char* frul_srcexpr; /* Source string for regexp. */
1900 int frul_rflags; /* Flags passed to regcomp, usually
1901 * REG_EXTENDED. */
1902 regex_t* frul_re; /* Compiled regular expression
1903 obtained by regcomp. */
1904 const char* frul_tr_out; /* Transformation string for making
1905 * the output_name, with $1 ... $9 for
1906 * subpatterns and $0 for the whole
1907 * matched filename. */
1908 const char* frul_tr_for; /* Tranformation string for making the
1909 for_name. */
1910 frul_actionrout_t* frul_action; /* The action, if non null, is
1911 * called once the rule matches, on
1912 * the transformed out_name &
1913 * for_name. It could change them
1914 * and/or give the output file. */
1917 /* File rule action handling *.h files. */
1918 static outf_p header_dot_h_frul (input_file*, char**, char**);
1920 /* File rule action handling *.cc files. */
1921 static outf_p source_dot_cc_frul (input_file*, char**, char**);
1923 #define NULL_REGEX (regex_t*)0
1925 /* The prefix in our regexp-s matching the directory. */
1926 #define DIR_PREFIX_REGEX "^(([^/]*/)*)"
1928 #define NULL_FRULACT (frul_actionrout_t*)0
1930 /* The array of our rules governing file name generation. Rules order
1931 matters, so change with extreme care! */
1933 struct file_rule_st files_rules[] = {
1934 /* The general rule assumes that files in subdirectories belong to a
1935 particular front-end, and files not in subdirectories are shared.
1936 The following rules deal with exceptions - files that are in
1937 subdirectories and yet are shared, and files that are top-level,
1938 but are not shared. */
1940 /* the c-family/ source directory is special. */
1941 { DIR_PREFIX_REGEX "c-family/([[:alnum:]_-]*)\\.cc$",
1942 REG_EXTENDED, NULL_REGEX,
1943 "gt-c-family-$3.h", "c-family/$3.cc", NULL_FRULACT},
1945 { DIR_PREFIX_REGEX "c-family/([[:alnum:]_-]*)\\.h$",
1946 REG_EXTENDED, NULL_REGEX,
1947 "gt-c-family-$3.h", "c-family/$3.h", NULL_FRULACT},
1949 /* Both c-lang.h & c-tree.h gives gt-c-c-decl.h for c-decl.cc ! */
1950 { DIR_PREFIX_REGEX "c/c-lang\\.h$",
1951 REG_EXTENDED, NULL_REGEX, "gt-c-c-decl.h", "c/c-decl.cc", NULL_FRULACT},
1953 { DIR_PREFIX_REGEX "c/c-tree\\.h$",
1954 REG_EXTENDED, NULL_REGEX, "gt-c-c-decl.h", "c/c-decl.cc", NULL_FRULACT},
1956 /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.cc ! */
1957 { DIR_PREFIX_REGEX "cp/cp-tree\\.h$",
1958 REG_EXTENDED, NULL_REGEX,
1959 "gt-cp-tree.h", "cp/tree.cc", NULL_FRULACT },
1961 /* cp/decl.h & cp/decl.cc gives gt-cp-decl.h for cp/decl.cc ! */
1962 { DIR_PREFIX_REGEX "cp/decl\\.[ch]$",
1963 REG_EXTENDED, NULL_REGEX,
1964 "gt-cp-decl.h", "cp/decl.cc", NULL_FRULACT },
1966 /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.cc ! */
1967 { DIR_PREFIX_REGEX "cp/name-lookup\\.h$",
1968 REG_EXTENDED, NULL_REGEX,
1969 "gt-cp-name-lookup.h", "cp/name-lookup.cc", NULL_FRULACT },
1971 /* cp/parser.h gives gt-cp-parser.h for cp/parser.cc ! */
1972 { DIR_PREFIX_REGEX "cp/parser\\.h$",
1973 REG_EXTENDED, NULL_REGEX,
1974 "gt-cp-parser.h", "cp/parser.cc", NULL_FRULACT },
1976 /* objc/objc-act.h gives gt-objc-objc-act.h for objc/objc-act.cc ! */
1977 { DIR_PREFIX_REGEX "objc/objc-act\\.h$",
1978 REG_EXTENDED, NULL_REGEX,
1979 "gt-objc-objc-act.h", "objc/objc-act.cc", NULL_FRULACT },
1981 /* objc/objc-map.h gives gt-objc-objc-map.h for objc/objc-map.cc ! */
1982 { DIR_PREFIX_REGEX "objc/objc-map\\.h$",
1983 REG_EXTENDED, NULL_REGEX,
1984 "gt-objc-objc-map.h", "objc/objc-map.cc", NULL_FRULACT },
1986 /* General cases. For header *.h and *.cc files, we
1987 * need special actions to handle the language. */
1989 /* Source *.cc files are using get_file_gtfilename to compute their
1990 output_name and get_file_basename to compute their for_name
1991 through the source_dot_cc_frul action. */
1992 { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.cc$",
1993 REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.cc", source_dot_cc_frul},
1995 /* Common header files get "gtype-desc.cc" as their output_name,
1996 * while language specific header files are handled specially. So
1997 * we need the header_dot_h_frul action. */
1998 { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.h$",
1999 REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.h", header_dot_h_frul},
2001 { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.in$",
2002 REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.in", NULL_FRULACT},
2004 /* Mandatory null last entry signaling end of rules. */
2005 {NULL, 0, NULL_REGEX, NULL, NULL, NULL_FRULACT}
2008 /* Special file rules action for handling *.h header files. It gives
2009 "gtype-desc.cc" for common headers and corresponding output
2010 files for language-specific header files. */
2011 static outf_p
2012 header_dot_h_frul (input_file* inpf, char**poutname,
2013 char**pforname ATTRIBUTE_UNUSED)
2015 const char *basename = 0;
2016 int lang_index = 0;
2017 DBGPRINTF ("inpf %p inpname %s outname %s forname %s",
2018 (void*) inpf, get_input_file_name (inpf),
2019 *poutname, *pforname);
2020 basename = get_file_basename (inpf);
2021 lang_index = get_prefix_langdir_index (basename);
2022 DBGPRINTF ("basename %s lang_index %d", basename, lang_index);
2024 if (lang_index >= 0)
2026 /* The header is language specific. Given output_name &
2027 for_name remains unchanged. The base_files array gives the
2028 outf_p. */
2029 DBGPRINTF ("header_dot_h found language specific @ %p '%s'",
2030 (void*) base_files[lang_index],
2031 (base_files[lang_index])->name);
2032 return base_files[lang_index];
2034 else
2036 /* The header is common to all front-end languages. So
2037 output_name is "gtype-desc.cc" file. The calling function
2038 get_output_file_with_visibility will find its outf_p. */
2039 free (*poutname);
2040 *poutname = xstrdup ("gtype-desc.cc");
2041 DBGPRINTF ("special 'gtype-desc.cc' for inpname %s",
2042 get_input_file_name (inpf));
2043 return NULL;
2048 /* Special file rules action for handling *.cc source files using
2049 * get_file_gtfilename to compute their output_name and
2050 * get_file_basename to compute their for_name. The output_name is
2051 * gt-<LANG>-<BASE>.h for language specific source files, and
2052 * gt-<BASE>.h for common source files. */
2053 static outf_p
2054 source_dot_cc_frul (input_file* inpf, char**poutname, char**pforname)
2056 char *newbasename = CONST_CAST (char*, get_file_basename (inpf));
2057 char *newoutname = CONST_CAST (char*, get_file_gtfilename (inpf));
2058 DBGPRINTF ("inpf %p inpname %s original outname %s forname %s",
2059 (void*) inpf, get_input_file_name (inpf),
2060 *poutname, *pforname);
2061 DBGPRINTF ("newoutname %s", newoutname);
2062 DBGPRINTF ("newbasename %s", newbasename);
2063 free (*poutname);
2064 free (*pforname);
2065 *poutname = newoutname;
2066 *pforname = newbasename;
2067 return NULL;
2070 /* Utility function for get_output_file_with_visibility which returns
2071 * a malloc-ed substituted string using TRS on matching of the FILNAM
2072 * file name, using the PMATCH array. */
2073 static char*
2074 matching_file_name_substitute (const char *filnam, regmatch_t pmatch[10],
2075 const char *trs)
2077 struct obstack str_obstack;
2078 char *str = NULL;
2079 char *rawstr = NULL;
2080 const char *pt = NULL;
2081 DBGPRINTF ("filnam %s", filnam);
2082 obstack_init (&str_obstack);
2083 for (pt = trs; *pt; pt++) {
2084 char c = *pt;
2085 if (c == '$')
2087 if (pt[1] == '$')
2089 /* A double dollar $$ is substituted by a single verbatim
2090 dollar, but who really uses dollar signs in file
2091 paths? */
2092 obstack_1grow (&str_obstack, '$');
2094 else if (ISDIGIT (pt[1]))
2096 /* Handle $0 $1 ... $9 by appropriate substitution. */
2097 int dolnum = pt[1] - '0';
2098 int so = pmatch[dolnum].rm_so;
2099 int eo = pmatch[dolnum].rm_eo;
2100 DBGPRINTF ("so=%d eo=%d dolnum=%d", so, eo, dolnum);
2101 if (so>=0 && eo>=so)
2102 obstack_grow (&str_obstack, filnam + so, eo - so);
2104 else
2106 /* This can happen only when files_rules is buggy! */
2107 gcc_unreachable ();
2109 /* Always skip the character after the dollar. */
2110 pt++;
2112 else
2113 obstack_1grow (&str_obstack, c);
2115 obstack_1grow (&str_obstack, '\0');
2116 rawstr = XOBFINISH (&str_obstack, char *);
2117 str = xstrdup (rawstr);
2118 obstack_free (&str_obstack, NULL);
2119 DBGPRINTF ("matched replacement %s", str);
2120 rawstr = NULL;
2121 return str;
2125 /* An output file, suitable for definitions, that can see declarations
2126 made in INPF and is linked into every language that uses INPF.
2127 Since the result is cached inside INPF, that argument cannot be
2128 declared constant, but is "almost" constant. */
2130 outf_p
2131 get_output_file_with_visibility (input_file *inpf)
2133 outf_p r;
2134 char *for_name = NULL;
2135 char *output_name = NULL;
2136 const char* inpfname;
2138 /* This can happen when we need a file with visibility on a
2139 structure that we've never seen. We have to just hope that it's
2140 globally visible. */
2141 if (inpf == NULL)
2142 inpf = system_h_file;
2144 /* The result is cached in INPF, so return it if already known. */
2145 if (inpf->inpoutf)
2146 return inpf->inpoutf;
2148 /* In plugin mode, return NULL unless the input_file is one of the
2149 plugin_files. */
2150 if (plugin_files)
2152 size_t i;
2153 for (i = 0; i < nb_plugin_files; i++)
2154 if (inpf == plugin_files[i])
2156 inpf->inpoutf = plugin_output;
2157 return plugin_output;
2160 return NULL;
2163 inpfname = get_input_file_name (inpf);
2165 /* Try each rule in sequence in files_rules until one is triggered. */
2167 int rulix = 0;
2168 DBGPRINTF ("passing input file @ %p named %s through the files_rules",
2169 (void*) inpf, inpfname);
2171 for (; files_rules[rulix].frul_srcexpr != NULL; rulix++)
2173 DBGPRINTF ("rulix#%d srcexpr %s",
2174 rulix, files_rules[rulix].frul_srcexpr);
2176 if (!files_rules[rulix].frul_re)
2178 /* Compile the regexpr lazily. */
2179 int err = 0;
2180 files_rules[rulix].frul_re = XCNEW (regex_t);
2181 err = regcomp (files_rules[rulix].frul_re,
2182 files_rules[rulix].frul_srcexpr,
2183 files_rules[rulix].frul_rflags);
2184 if (err)
2186 /* The regular expression compilation fails only when
2187 file_rules is buggy. */
2188 gcc_unreachable ();
2192 output_name = NULL;
2193 for_name = NULL;
2195 /* Match the regexpr and trigger the rule if matched. */
2197 /* We have exactly ten pmatch-s, one for each $0, $1, $2,
2198 $3, ... $9. */
2199 regmatch_t pmatch[10];
2200 memset (pmatch, 0, sizeof (pmatch));
2201 if (!regexec (files_rules[rulix].frul_re,
2202 inpfname, 10, pmatch, 0))
2204 DBGPRINTF ("input @ %p filename %s matched rulix#%d pattern %s",
2205 (void*) inpf, inpfname, rulix,
2206 files_rules[rulix].frul_srcexpr);
2207 for_name =
2208 matching_file_name_substitute (inpfname, pmatch,
2209 files_rules[rulix].frul_tr_for);
2210 DBGPRINTF ("for_name %s", for_name);
2211 output_name =
2212 matching_file_name_substitute (inpfname, pmatch,
2213 files_rules[rulix].frul_tr_out);
2214 DBGPRINTF ("output_name %s", output_name);
2215 if (files_rules[rulix].frul_action)
2217 /* Invoke our action routine. */
2218 outf_p of = NULL;
2219 DBGPRINTF ("before action rulix#%d output_name %s for_name %s",
2220 rulix, output_name, for_name);
2221 of =
2222 (files_rules[rulix].frul_action) (inpf,
2223 &output_name, &for_name);
2224 DBGPRINTF ("after action rulix#%d of=%p output_name %s for_name %s",
2225 rulix, (void*)of, output_name, for_name);
2226 /* If the action routine returned something, give it back
2227 immediately and cache it in inpf. */
2228 if (of)
2230 inpf->inpoutf = of;
2231 return of;
2234 /* The rule matched, and had no action, or that action did
2235 not return any output file but could have changed the
2236 output_name or for_name. We break out of the loop on the
2237 files_rules. */
2238 break;
2240 else
2242 /* The regexpr did not match. */
2243 DBGPRINTF ("rulix#%d did not match %s pattern %s",
2244 rulix, inpfname, files_rules[rulix].frul_srcexpr);
2245 continue;
2250 if (!output_name || !for_name)
2252 /* This should not be possible, and could only happen if the
2253 files_rules is incomplete or buggy. */
2254 fatal ("failed to compute output name for %s", inpfname);
2257 /* Look through to see if we've ever seen this output filename
2258 before. If found, cache the result in inpf. */
2259 for (r = output_files; r; r = r->next)
2260 if (filename_cmp (r->name, output_name) == 0)
2262 inpf->inpoutf = r;
2263 DBGPRINTF ("found r @ %p for output_name %s for_name %s", (void*)r,
2264 output_name, for_name);
2265 return r;
2268 /* If not found, create it, and cache it in inpf. */
2269 r = create_file (for_name, output_name);
2271 gcc_assert (r && r->name);
2272 DBGPRINTF ("created r @ %p for output_name %s for_name %s", (void*) r,
2273 output_name, for_name);
2274 inpf->inpoutf = r;
2275 return r;
2280 /* The name of an output file, suitable for definitions, that can see
2281 declarations made in INPF and is linked into every language that
2282 uses INPF. */
2284 const char *
2285 get_output_file_name (input_file* inpf)
2287 outf_p o = get_output_file_with_visibility (inpf);
2288 if (o)
2289 return o->name;
2290 return NULL;
2293 /* Check if existing file is equal to the in memory buffer. */
2295 static bool
2296 is_file_equal (outf_p of)
2298 FILE *newfile = fopen (of->name, "r");
2299 size_t i;
2300 bool equal;
2301 if (newfile == NULL)
2302 return false;
2304 equal = true;
2305 for (i = 0; i < of->bufused; i++)
2307 int ch;
2308 ch = fgetc (newfile);
2309 if (ch == EOF || ch != (unsigned char) of->buf[i])
2311 equal = false;
2312 break;
2315 if (equal && EOF != fgetc (newfile))
2316 equal = false;
2317 fclose (newfile);
2318 return equal;
2321 /* Copy the output to its final destination,
2322 but don't unnecessarily change modification times. */
2324 static void
2325 close_output_files (void)
2327 int nbwrittenfiles = 0;
2328 outf_p of;
2330 for (of = output_files; of; of = of->next)
2332 if (!is_file_equal (of))
2334 FILE *newfile = NULL;
2335 char *backupname = NULL;
2336 /* Back up the old version of the output file gt-FOO.cc as
2337 BACKUPDIR/gt-FOO.cc~ if we have a backup directory. */
2338 if (backup_dir)
2340 backupname = concat (backup_dir, "/",
2341 lbasename (of->name), "~", NULL);
2342 if (!access (of->name, F_OK) && rename (of->name, backupname))
2343 fatal ("failed to back up %s as %s: %s",
2344 of->name, backupname, xstrerror (errno));
2347 newfile = fopen (of->name, "w");
2348 if (newfile == NULL)
2349 fatal ("opening output file %s: %s", of->name, xstrerror (errno));
2350 if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused)
2351 fatal ("writing output file %s: %s", of->name, xstrerror (errno));
2352 if (fclose (newfile) != 0)
2353 fatal ("closing output file %s: %s", of->name, xstrerror (errno));
2354 nbwrittenfiles++;
2355 if (verbosity_level >= 2 && backupname)
2356 printf ("%s wrote #%-3d %s backed-up in %s\n",
2357 progname, nbwrittenfiles, of->name, backupname);
2358 else if (verbosity_level >= 1)
2359 printf ("%s write #%-3d %s\n", progname, nbwrittenfiles, of->name);
2360 free (backupname);
2362 else
2364 /* output file remains unchanged. */
2365 if (verbosity_level >= 2)
2366 printf ("%s keep %s\n", progname, of->name);
2368 free (of->buf);
2369 of->buf = NULL;
2370 of->bufused = of->buflength = 0;
2372 if (verbosity_level >= 1)
2373 printf ("%s wrote %d files.\n", progname, nbwrittenfiles);
2376 struct flist
2378 struct flist *next;
2379 int started_p;
2380 const input_file* file;
2381 outf_p f;
2384 struct walk_type_data;
2386 /* For scalars and strings, given the item in 'val'.
2387 For structures, given a pointer to the item in 'val'.
2388 For misc. pointers, given the item in 'val'.
2390 typedef void (*process_field_fn) (type_p f, const struct walk_type_data * p);
2391 typedef void (*func_name_fn) (type_p s, const struct walk_type_data * p);
2393 /* Parameters for write_types. */
2395 struct write_types_data
2397 const char *prefix;
2398 const char *param_prefix;
2399 const char *subfield_marker_routine;
2400 const char *marker_routine;
2401 const char *reorder_note_routine;
2402 const char *comment;
2403 enum write_types_kinds kind;
2406 static void output_escaped_param (struct walk_type_data *d,
2407 const char *, const char *);
2408 static void output_mangled_typename (outf_p, const_type_p);
2409 static void walk_type (type_p t, struct walk_type_data *d);
2410 static void write_func_for_structure (type_p orig_s, type_p s,
2411 const struct write_types_data *wtd);
2412 static void write_types_process_field
2413 (type_p f, const struct walk_type_data *d);
2414 static void write_types (outf_p output_header,
2415 type_p structures,
2416 const struct write_types_data *wtd);
2417 static void write_types_local_process_field
2418 (type_p f, const struct walk_type_data *d);
2419 static void write_local_func_for_structure (const_type_p orig_s, type_p s);
2420 static void write_local (outf_p output_header,
2421 type_p structures);
2422 static int contains_scalar_p (type_p t);
2423 static void put_mangled_filename (outf_p, const input_file *);
2424 static void finish_root_table (struct flist *flp, const char *pfx,
2425 const char *lastname,
2426 const char *tname, const char *name);
2427 static void write_root (outf_p, pair_p, type_p, const char *, int,
2428 struct fileloc *, bool);
2429 static void write_array (outf_p f, pair_p v,
2430 const struct write_types_data *wtd);
2431 static void write_roots (pair_p, bool);
2433 /* Parameters for walk_type. */
2435 struct walk_type_data
2437 process_field_fn process_field;
2438 const void *cookie;
2439 outf_p of;
2440 options_p opt;
2441 const char *val;
2442 const char *prev_val[4];
2443 int indent;
2444 int counter;
2445 const struct fileloc *line;
2446 lang_bitmap bitmap;
2447 int used_length;
2448 type_p orig_s;
2449 const char *reorder_fn;
2450 bool needs_cast_p;
2451 bool fn_wants_lvalue;
2452 bool in_record_p;
2453 int loopcounter;
2454 bool in_ptr_field;
2455 bool have_this_obj;
2456 bool in_nested_ptr;
2460 /* Given a string TYPE_NAME, representing a C++ typename, return a valid
2461 pre-processor identifier to use in a #define directive. This replaces
2462 special characters used in C++ identifiers like '>', '<' and ':' with
2463 '_'.
2465 If no C++ special characters are found in TYPE_NAME, return
2466 TYPE_NAME. Otherwise, return a copy of TYPE_NAME with the special
2467 characters replaced with '_'. In this case, the caller is
2468 responsible for freeing the allocated string. */
2470 static const char *
2471 filter_type_name (const char *type_name)
2473 if (strchr (type_name, '<') || strchr (type_name, ':'))
2475 size_t i;
2476 char *s = xstrdup (type_name);
2477 for (i = 0; i < strlen (s); i++)
2478 if (s[i] == '<' || s[i] == '>' || s[i] == ':' || s[i] == ','
2479 || s[i] == '*')
2480 s[i] = '_';
2481 return s;
2483 else
2484 return type_name;
2488 /* Print a mangled name representing T to OF. */
2490 static void
2491 output_mangled_typename (outf_p of, const_type_p t)
2493 if (t == NULL)
2494 oprintf (of, "Z");
2495 else
2496 switch (t->kind)
2498 case TYPE_NONE:
2499 case TYPE_UNDEFINED:
2500 case TYPE_CALLBACK:
2501 gcc_unreachable ();
2502 break;
2503 case TYPE_POINTER:
2504 oprintf (of, "P");
2505 output_mangled_typename (of, t->u.p);
2506 break;
2507 case TYPE_SCALAR:
2508 oprintf (of, "I");
2509 break;
2510 case TYPE_STRING:
2511 oprintf (of, "S");
2512 break;
2513 case TYPE_STRUCT:
2514 case TYPE_UNION:
2515 case TYPE_LANG_STRUCT:
2516 case TYPE_USER_STRUCT:
2518 /* For references to classes within an inheritance hierarchy,
2519 only ever reference the ultimate base class, since only
2520 it will have gt_ functions. */
2521 t = get_ultimate_base_class (t);
2522 const char *id_for_tag = filter_type_name (t->u.s.tag);
2523 oprintf (of, "%lu%s", (unsigned long) strlen (id_for_tag),
2524 id_for_tag);
2525 if (id_for_tag != t->u.s.tag)
2526 free (CONST_CAST (char *, id_for_tag));
2528 break;
2529 case TYPE_ARRAY:
2530 gcc_unreachable ();
2534 /* Print PARAM to D->OF processing escapes. D->VAL references the
2535 current object, D->PREV_VAL the object containing the current
2536 object, ONAME is the name of the option and D->LINE is used to
2537 print error messages. */
2539 static void
2540 output_escaped_param (struct walk_type_data *d, const char *param,
2541 const char *oname)
2543 const char *p;
2545 for (p = param; *p; p++)
2546 if (*p != '%')
2547 oprintf (d->of, "%c", *p);
2548 else
2549 switch (*++p)
2551 case 'h':
2552 oprintf (d->of, "(%s)", d->prev_val[2]);
2553 break;
2554 case '0':
2555 oprintf (d->of, "(%s)", d->prev_val[0]);
2556 break;
2557 case '1':
2558 oprintf (d->of, "(%s)", d->prev_val[1]);
2559 break;
2560 case 'a':
2562 const char *pp = d->val + strlen (d->val);
2563 while (pp[-1] == ']')
2564 while (*pp != '[')
2565 pp--;
2566 oprintf (d->of, "%s", pp);
2568 break;
2569 default:
2570 error_at_line (d->line, "`%s' option contains bad escape %c%c",
2571 oname, '%', *p);
2575 const char *
2576 get_string_option (options_p opt, const char *key)
2578 for (; opt; opt = opt->next)
2579 if (strcmp (opt->name, key) == 0)
2580 return opt->info.string;
2581 return NULL;
2584 /* Machinery for avoiding duplicate tags within switch statements. */
2585 struct seen_tag
2587 const char *tag;
2588 struct seen_tag *next;
2592 already_seen_tag (struct seen_tag *seen_tags, const char *tag)
2594 /* Linear search, so O(n^2), but n is currently small. */
2595 while (seen_tags)
2597 if (!strcmp (seen_tags->tag, tag))
2598 return 1;
2599 seen_tags = seen_tags->next;
2601 /* Not yet seen this tag. */
2602 return 0;
2605 void
2606 mark_tag_as_seen (struct seen_tag **seen_tags, const char *tag)
2608 /* Add to front of linked list. */
2609 struct seen_tag *new_node = XCNEW (struct seen_tag);
2610 new_node->tag = tag;
2611 new_node->next = *seen_tags;
2612 *seen_tags = new_node;
2615 static void
2616 walk_subclasses (type_p base, struct walk_type_data *d,
2617 struct seen_tag **seen_tags)
2619 for (type_p sub = base->u.s.first_subclass; sub != NULL;
2620 sub = sub->u.s.next_sibling_class)
2622 const char *type_tag = get_string_option (sub->u.s.opt, "tag");
2623 if (type_tag && !already_seen_tag (*seen_tags, type_tag))
2625 mark_tag_as_seen (seen_tags, type_tag);
2626 oprintf (d->of, "%*scase %s:\n", d->indent, "", type_tag);
2627 d->indent += 2;
2628 oprintf (d->of, "%*s{\n", d->indent, "");
2629 d->indent += 2;
2630 oprintf (d->of, "%*s%s *sub = static_cast <%s *> (x);\n",
2631 d->indent, "", sub->u.s.tag, sub->u.s.tag);
2632 const char *old_val = d->val;
2633 d->val = "(*sub)";
2634 walk_type (sub, d);
2635 d->val = old_val;
2636 d->indent -= 2;
2637 oprintf (d->of, "%*s}\n", d->indent, "");
2638 oprintf (d->of, "%*sbreak;\n", d->indent, "");
2639 d->indent -= 2;
2641 walk_subclasses (sub, d, seen_tags);
2645 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2646 which is of type T. Write code to D->OF to constrain execution (at
2647 the point that D->PROCESS_FIELD is called) to the appropriate
2648 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2649 pointers to those objects. D->PREV_VAL lists the objects
2650 containing the current object, D->OPT is a list of options to
2651 apply, D->INDENT is the current indentation level, D->LINE is used
2652 to print error messages, D->BITMAP indicates which languages to
2653 print the structure for. */
2655 static void
2656 walk_type (type_p t, struct walk_type_data *d)
2658 const char *length = NULL;
2659 const char *desc = NULL;
2660 const char *type_tag = NULL;
2661 int maybe_undef_p = 0;
2662 int atomic_p = 0;
2663 options_p oo;
2664 const struct nested_ptr_data *nested_ptr_d = NULL;
2666 d->needs_cast_p = false;
2667 for (oo = d->opt; oo; oo = oo->next)
2668 if (strcmp (oo->name, "length") == 0 && oo->kind == OPTION_STRING)
2669 length = oo->info.string;
2670 else if (strcmp (oo->name, "maybe_undef") == 0)
2671 maybe_undef_p = 1;
2672 else if (strcmp (oo->name, "desc") == 0 && oo->kind == OPTION_STRING)
2673 desc = oo->info.string;
2674 else if (strcmp (oo->name, "nested_ptr") == 0
2675 && oo->kind == OPTION_NESTED)
2676 nested_ptr_d = (const struct nested_ptr_data *) oo->info.nested;
2677 else if (strcmp (oo->name, "dot") == 0)
2679 else if (strcmp (oo->name, "tag") == 0)
2680 type_tag = oo->info.string;
2681 else if (strcmp (oo->name, "special") == 0)
2683 else if (strcmp (oo->name, "skip") == 0)
2685 else if (strcmp (oo->name, "atomic") == 0)
2686 atomic_p = 1;
2687 else if (strcmp (oo->name, "default") == 0)
2689 else if (strcmp (oo->name, "chain_next") == 0)
2691 else if (strcmp (oo->name, "chain_prev") == 0)
2693 else if (strcmp (oo->name, "chain_circular") == 0)
2695 else if (strcmp (oo->name, "reorder") == 0)
2697 else if (strcmp (oo->name, "variable_size") == 0)
2699 else if (strcmp (oo->name, "for_user") == 0)
2701 else if (strcmp (oo->name, "callback") == 0)
2703 else
2704 error_at_line (d->line, "unknown option `%s'\n", oo->name);
2706 if (d->used_length)
2707 length = NULL;
2709 if (maybe_undef_p
2710 && (t->kind != TYPE_POINTER || !union_or_struct_p (t->u.p)))
2712 error_at_line (d->line,
2713 "field `%s' has invalid option `maybe_undef_p'\n",
2714 d->val);
2715 return;
2718 if (atomic_p && (t->kind != TYPE_POINTER) && (t->kind != TYPE_STRING))
2720 error_at_line (d->line, "field `%s' has invalid option `atomic'\n", d->val);
2721 return;
2724 switch (t->kind)
2726 case TYPE_SCALAR:
2727 case TYPE_STRING:
2728 case TYPE_CALLBACK:
2729 d->process_field (t, d);
2730 break;
2732 case TYPE_POINTER:
2734 d->in_ptr_field = true;
2735 if (maybe_undef_p && t->u.p->u.s.line.file == NULL)
2737 oprintf (d->of, "%*sgcc_assert (!%s);\n", d->indent, "", d->val);
2738 break;
2741 /* If a pointer type is marked as "atomic", we process the
2742 field itself, but we don't walk the data that they point to.
2744 There are two main cases where we walk types: to mark
2745 pointers that are reachable, and to relocate pointers when
2746 writing a PCH file. In both cases, an atomic pointer is
2747 itself marked or relocated, but the memory that it points
2748 to is left untouched. In the case of PCH, that memory will
2749 be read/written unchanged to the PCH file. */
2750 if (atomic_p)
2752 oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val);
2753 d->indent += 2;
2754 d->process_field (t, d);
2755 d->indent -= 2;
2756 oprintf (d->of, "%*s}\n", d->indent, "");
2757 break;
2760 if (!length)
2762 if (!union_or_struct_p (t->u.p))
2764 error_at_line (d->line,
2765 "field `%s' is pointer to unimplemented type",
2766 d->val);
2767 break;
2770 if (nested_ptr_d)
2772 const char *oldprevval2 = d->prev_val[2];
2773 bool old_in_nested_ptr = d->in_nested_ptr;
2775 if (!union_or_struct_p (nested_ptr_d->type))
2777 error_at_line (d->line,
2778 "field `%s' has invalid "
2779 "option `nested_ptr'\n", d->val);
2780 return;
2783 d->prev_val[2] = d->val;
2784 d->in_nested_ptr = true;
2785 oprintf (d->of, "%*s{\n", d->indent, "");
2786 d->indent += 2;
2787 d->val = xasprintf ("x%d", d->counter++);
2788 oprintf (d->of, "%*s%s %s * %s%s =\n", d->indent, "",
2789 (nested_ptr_d->type->kind == TYPE_UNION
2790 ? "union" : "struct"),
2791 nested_ptr_d->type->u.s.tag,
2792 d->fn_wants_lvalue ? "" : "const ", d->val);
2793 oprintf (d->of, "%*s", d->indent + 2, "");
2794 output_escaped_param (d, nested_ptr_d->convert_from,
2795 "nested_ptr");
2796 oprintf (d->of, ";\n");
2798 d->process_field (nested_ptr_d->type, d);
2800 if (d->fn_wants_lvalue)
2802 oprintf (d->of, "%*s%s = ", d->indent, "",
2803 d->prev_val[2]);
2804 d->prev_val[2] = d->val;
2805 output_escaped_param (d, nested_ptr_d->convert_to,
2806 "nested_ptr");
2807 oprintf (d->of, ";\n");
2810 d->indent -= 2;
2811 oprintf (d->of, "%*s}\n", d->indent, "");
2812 d->val = d->prev_val[2];
2813 d->prev_val[2] = oldprevval2;
2814 d->in_nested_ptr = old_in_nested_ptr;
2816 else
2817 d->process_field (t->u.p, d);
2819 else
2821 int loopcounter = d->loopcounter;
2822 const char *oldval = d->val;
2823 const char *oldprevval3 = d->prev_val[3];
2824 char *newval;
2826 oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val);
2827 d->indent += 2;
2828 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
2829 oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent,
2830 "", loopcounter, loopcounter);
2831 if (!d->in_record_p)
2832 output_escaped_param (d, length, "length");
2833 else
2834 oprintf (d->of, "l%d", loopcounter);
2835 if (d->have_this_obj)
2836 /* Try to unswitch loops (see PR53880). */
2837 oprintf (d->of, ") && ((void *)%s == this_obj", oldval);
2838 oprintf (d->of, "); i%d++) {\n", loopcounter);
2839 d->indent += 2;
2840 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
2841 d->used_length = 1;
2842 d->prev_val[3] = oldval;
2843 walk_type (t->u.p, d);
2844 free (newval);
2845 d->val = oldval;
2846 d->prev_val[3] = oldprevval3;
2847 d->used_length = 0;
2848 d->indent -= 2;
2849 oprintf (d->of, "%*s}\n", d->indent, "");
2850 d->process_field (t, d);
2851 d->indent -= 2;
2852 oprintf (d->of, "%*s}\n", d->indent, "");
2854 d->in_ptr_field = false;
2856 break;
2858 case TYPE_ARRAY:
2860 int loopcounter;
2861 const char *oldval = d->val;
2862 char *newval;
2864 /* If it's an array of scalars, we optimize by not generating
2865 any code. */
2866 if (t->u.a.p->kind == TYPE_SCALAR)
2867 break;
2869 if (length)
2870 loopcounter = d->loopcounter;
2871 else
2872 loopcounter = d->counter++;
2874 /* When walking an array, compute the length and store it in a
2875 local variable before walking the array elements, instead of
2876 recomputing the length expression each time through the loop.
2877 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2878 where the length is stored in the first array element,
2879 because otherwise that operand can get overwritten on the
2880 first iteration. */
2881 oprintf (d->of, "%*s{\n", d->indent, "");
2882 d->indent += 2;
2883 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
2884 if (!d->in_record_p || !length)
2886 oprintf (d->of, "%*ssize_t l%d = (size_t)(",
2887 d->indent, "", loopcounter);
2888 if (length)
2889 output_escaped_param (d, length, "length");
2890 else
2891 oprintf (d->of, "%s", t->u.a.len);
2892 oprintf (d->of, ");\n");
2895 oprintf (d->of, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2896 d->indent, "",
2897 loopcounter, loopcounter, loopcounter, loopcounter);
2898 d->indent += 2;
2899 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
2900 d->used_length = 1;
2901 walk_type (t->u.a.p, d);
2902 free (newval);
2903 d->used_length = 0;
2904 d->val = oldval;
2905 d->indent -= 2;
2906 oprintf (d->of, "%*s}\n", d->indent, "");
2907 d->indent -= 2;
2908 oprintf (d->of, "%*s}\n", d->indent, "");
2910 break;
2912 case TYPE_STRUCT:
2913 case TYPE_UNION:
2915 pair_p f;
2916 const char *oldval = d->val;
2917 const char *oldprevval1 = d->prev_val[1];
2918 const char *oldprevval2 = d->prev_val[2];
2919 const int union_p = t->kind == TYPE_UNION;
2920 int seen_default_p = 0;
2921 options_p o;
2922 int lengths_seen = 0;
2923 int endcounter;
2924 bool any_length_seen = false;
2926 if (!t->u.s.line.file)
2927 error_at_line (d->line, "incomplete structure `%s'", t->u.s.tag);
2929 if ((d->bitmap & t->u.s.bitmap) != d->bitmap)
2931 error_at_line (d->line,
2932 "structure `%s' defined for mismatching languages",
2933 t->u.s.tag);
2934 error_at_line (&t->u.s.line, "one structure defined here");
2937 /* Some things may also be defined in the structure's options. */
2938 for (o = t->u.s.opt; o; o = o->next)
2939 if (!desc && strcmp (o->name, "desc") == 0
2940 && o->kind == OPTION_STRING)
2941 desc = o->info.string;
2943 d->prev_val[2] = oldval;
2944 d->prev_val[1] = oldprevval2;
2945 if (union_p)
2947 if (desc == NULL)
2949 error_at_line (d->line,
2950 "missing `desc' option for union `%s'",
2951 t->u.s.tag);
2952 desc = "1";
2954 oprintf (d->of, "%*sswitch ((int) (", d->indent, "");
2955 output_escaped_param (d, desc, "desc");
2956 oprintf (d->of, "))\n");
2957 d->indent += 2;
2958 oprintf (d->of, "%*s{\n", d->indent, "");
2960 else if (desc)
2962 /* We have a "desc" option on a struct, signifying the
2963 base class within a GC-managed inheritance hierarchy.
2964 The current code specialcases the base class, then walks
2965 into subclasses, recursing into this routine to handle them.
2966 This organization requires the base class to have a case in
2967 the switch statement, and hence a tag value is mandatory
2968 for the base class. This restriction could be removed, but
2969 it would require some restructing of this code. */
2970 if (!type_tag)
2972 error_at_line (d->line,
2973 "missing `tag' option for type `%s'",
2974 t->u.s.tag);
2976 oprintf (d->of, "%*sswitch ((int) (", d->indent, "");
2977 output_escaped_param (d, desc, "desc");
2978 oprintf (d->of, "))\n");
2979 d->indent += 2;
2980 oprintf (d->of, "%*s{\n", d->indent, "");
2981 oprintf (d->of, "%*scase %s:\n", d->indent, "", type_tag);
2982 d->indent += 2;
2985 FOR_ALL_INHERITED_FIELDS (t, f)
2987 options_p oo;
2988 int skip_p = 0;
2989 const char *fieldlength = NULL;
2991 d->reorder_fn = NULL;
2992 for (oo = f->opt; oo; oo = oo->next)
2993 if (strcmp (oo->name, "skip") == 0)
2994 skip_p = 1;
2995 else if (strcmp (oo->name, "length") == 0
2996 && oo->kind == OPTION_STRING)
2997 fieldlength = oo->info.string;
2999 if (skip_p)
3000 continue;
3001 if (fieldlength)
3003 lengths_seen++;
3004 d->counter++;
3005 if (!union_p)
3007 if (!any_length_seen)
3009 oprintf (d->of, "%*s{\n", d->indent, "");
3010 d->indent += 2;
3012 any_length_seen = true;
3014 oprintf (d->of, "%*ssize_t l%d = (size_t)(",
3015 d->indent, "", d->counter - 1);
3016 output_escaped_param (d, fieldlength, "length");
3017 oprintf (d->of, ");\n");
3021 endcounter = d->counter;
3023 FOR_ALL_INHERITED_FIELDS (t, f)
3025 options_p oo;
3026 const char *dot = ".";
3027 const char *tagid = NULL;
3028 int skip_p = 0;
3029 int default_p = 0;
3030 const char *fieldlength = NULL;
3031 char *newval;
3033 d->reorder_fn = NULL;
3034 for (oo = f->opt; oo; oo = oo->next)
3035 if (strcmp (oo->name, "dot") == 0
3036 && oo->kind == OPTION_STRING)
3037 dot = oo->info.string;
3038 else if (strcmp (oo->name, "tag") == 0
3039 && oo->kind == OPTION_STRING)
3040 tagid = oo->info.string;
3041 else if (strcmp (oo->name, "skip") == 0)
3042 skip_p = 1;
3043 else if (strcmp (oo->name, "default") == 0)
3044 default_p = 1;
3045 else if (strcmp (oo->name, "reorder") == 0
3046 && oo->kind == OPTION_STRING)
3047 d->reorder_fn = oo->info.string;
3048 else if (strcmp (oo->name, "length") == 0
3049 && oo->kind == OPTION_STRING)
3050 fieldlength = oo->info.string;
3052 if (skip_p)
3053 continue;
3055 if (union_p && tagid)
3057 oprintf (d->of, "%*scase %s:\n", d->indent, "", tagid);
3058 d->indent += 2;
3060 else if (union_p && default_p)
3062 oprintf (d->of, "%*sdefault:\n", d->indent, "");
3063 d->indent += 2;
3064 seen_default_p = 1;
3066 else if (!union_p && (default_p || tagid))
3067 error_at_line (d->line,
3068 "can't use `%s' outside a union on field `%s'",
3069 default_p ? "default" : "tag", f->name);
3070 else if (union_p && !(default_p || tagid)
3071 && f->type->kind == TYPE_SCALAR)
3073 fprintf (stderr,
3074 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
3075 get_input_file_name (d->line->file), d->line->line,
3076 f->name);
3077 continue;
3079 else if (union_p && !(default_p || tagid))
3080 error_at_line (d->line,
3081 "field `%s' is missing `tag' or `default' option",
3082 f->name);
3084 if (fieldlength)
3086 d->loopcounter = endcounter - lengths_seen--;
3089 d->line = &f->line;
3090 d->val = newval = xasprintf ("%s%s%s", oldval, dot, f->name);
3091 d->opt = f->opt;
3092 d->used_length = false;
3093 d->in_record_p = !union_p;
3095 walk_type (f->type, d);
3097 d->in_record_p = false;
3099 free (newval);
3101 if (union_p)
3103 oprintf (d->of, "%*sbreak;\n", d->indent, "");
3104 d->indent -= 2;
3107 d->reorder_fn = NULL;
3109 d->val = oldval;
3110 d->prev_val[1] = oldprevval1;
3111 d->prev_val[2] = oldprevval2;
3113 if (union_p && !seen_default_p)
3115 oprintf (d->of, "%*sdefault:\n", d->indent, "");
3116 oprintf (d->of, "%*s break;\n", d->indent, "");
3119 if (desc && !union_p)
3121 oprintf (d->of, "%*sbreak;\n", d->indent, "");
3122 d->indent -= 2;
3124 if (union_p)
3126 oprintf (d->of, "%*s}\n", d->indent, "");
3127 d->indent -= 2;
3129 else if (desc)
3131 /* Add cases to handle subclasses. */
3132 struct seen_tag *tags = NULL;
3133 walk_subclasses (t, d, &tags);
3135 /* Ensure that if someone forgets a "tag" option that we don't
3136 silent fail to traverse that subclass's fields. */
3137 if (!seen_default_p)
3139 oprintf (d->of, "%*s/* Unrecognized tag value. */\n",
3140 d->indent, "");
3141 oprintf (d->of, "%*sdefault: gcc_unreachable (); \n",
3142 d->indent, "");
3145 /* End of the switch statement */
3146 oprintf (d->of, "%*s}\n", d->indent, "");
3147 d->indent -= 2;
3149 if (any_length_seen)
3151 d->indent -= 2;
3152 oprintf (d->of, "%*s}\n", d->indent, "");
3155 break;
3157 case TYPE_LANG_STRUCT:
3159 type_p nt;
3160 for (nt = t->u.s.lang_struct; nt; nt = nt->next)
3161 if ((d->bitmap & nt->u.s.bitmap) == d->bitmap)
3162 break;
3163 if (nt == NULL)
3164 error_at_line (d->line, "structure `%s' differs between languages",
3165 t->u.s.tag);
3166 else
3167 walk_type (nt, d);
3169 break;
3171 case TYPE_USER_STRUCT:
3172 d->process_field (t, d);
3173 break;
3175 case TYPE_NONE:
3176 case TYPE_UNDEFINED:
3177 gcc_unreachable ();
3181 /* process_field routine for marking routines. */
3183 static void
3184 write_types_process_field (type_p f, const struct walk_type_data *d)
3186 const struct write_types_data *wtd;
3187 const char *cast = d->needs_cast_p ? "(void *)" : "";
3188 wtd = (const struct write_types_data *) d->cookie;
3190 switch (f->kind)
3192 case TYPE_NONE:
3193 case TYPE_UNDEFINED:
3194 gcc_unreachable ();
3195 case TYPE_POINTER:
3196 oprintf (d->of, "%*s%s (%s%s", d->indent, "",
3197 wtd->subfield_marker_routine, cast, d->val);
3198 if (wtd->param_prefix)
3200 if (f->u.p->kind == TYPE_SCALAR)
3201 /* The current type is a pointer to a scalar (so not
3202 considered like a pointer to instances of user defined
3203 types) and we are seeing it; it means we must be even
3204 more careful about the second argument of the
3205 SUBFIELD_MARKER_ROUTINE call. That argument must
3206 always be the instance of the type for which
3207 write_func_for_structure was called - this really is
3208 what the function SUBFIELD_MARKER_ROUTINE expects.
3209 That is, it must be an instance of the ORIG_S type
3210 parameter of write_func_for_structure. The convention
3211 is that that argument must be "x" in that case (as set
3212 by write_func_for_structure). The problem is, we can't
3213 count on d->prev_val[3] to be always set to "x" in that
3214 case. Sometimes walk_type can set it to something else
3215 (to e.g cooperate with write_array when called from
3216 write_roots). So let's set it to "x" here then. */
3217 oprintf (d->of, ", x");
3218 else
3219 oprintf (d->of, ", %s", d->prev_val[3]);
3220 if (d->orig_s)
3222 oprintf (d->of, ", gt_%s_", wtd->param_prefix);
3223 output_mangled_typename (d->of, d->orig_s);
3225 else
3226 oprintf (d->of, ", gt_%sa_%s", wtd->param_prefix, d->prev_val[0]);
3228 oprintf (d->of, ");\n");
3229 if (d->reorder_fn && wtd->reorder_note_routine)
3230 oprintf (d->of, "%*s%s (%s%s, %s, %s);\n", d->indent, "",
3231 wtd->reorder_note_routine, cast, d->val,
3232 d->prev_val[3], d->reorder_fn);
3233 break;
3235 case TYPE_STRING:
3236 case TYPE_STRUCT:
3237 case TYPE_UNION:
3238 case TYPE_LANG_STRUCT:
3239 case TYPE_USER_STRUCT:
3240 if (f->kind == TYPE_USER_STRUCT && !d->in_ptr_field)
3242 /* If F is a user-defined type and the field is not a
3243 pointer to the type, then we should not generate the
3244 standard pointer-marking code. All we need to do is call
3245 the user-provided marking function to process the fields
3246 of F. */
3247 oprintf (d->of, "%*sgt_%sx (&(%s));\n", d->indent, "", wtd->prefix,
3248 d->val);
3250 else
3252 oprintf (d->of, "%*sgt_%s_", d->indent, "", wtd->prefix);
3253 output_mangled_typename (d->of, f);
3254 oprintf (d->of, " (%s%s);\n", cast, d->val);
3255 if (d->reorder_fn && wtd->reorder_note_routine)
3256 oprintf (d->of, "%*s%s (%s%s, %s%s, %s);\n", d->indent, "",
3257 wtd->reorder_note_routine, cast, d->val, cast, d->val,
3258 d->reorder_fn);
3260 break;
3262 case TYPE_SCALAR:
3263 case TYPE_CALLBACK:
3264 break;
3266 case TYPE_ARRAY:
3267 gcc_unreachable ();
3271 /* Return an output file that is suitable for definitions which can
3272 reference struct S */
3274 static outf_p
3275 get_output_file_for_structure (const_type_p s)
3277 const input_file *fn;
3279 gcc_assert (union_or_struct_p (s));
3280 fn = s->u.s.line.file;
3282 /* The call to get_output_file_with_visibility may update fn by
3283 caching its result inside, so we need the CONST_CAST. */
3284 return get_output_file_with_visibility (CONST_CAST (input_file*, fn));
3288 /* Returns the specifier keyword for a string or union type S, empty string
3289 otherwise. */
3291 static const char *
3292 get_type_specifier (const type_p s)
3294 if (s->kind == TYPE_STRUCT)
3295 return "struct ";
3296 else if (s->kind == TYPE_LANG_STRUCT)
3297 return get_type_specifier (s->u.s.lang_struct);
3298 else if (s->kind == TYPE_UNION)
3299 return "union ";
3300 return "";
3304 /* Emits a declaration for type TY (assumed to be a union or a
3305 structure) on stream OUT. */
3307 static void
3308 write_type_decl (outf_p out, type_p ty)
3310 if (union_or_struct_p (ty))
3311 oprintf (out, "%s%s", get_type_specifier (ty), ty->u.s.tag);
3312 else if (ty->kind == TYPE_SCALAR)
3314 if (ty->u.scalar_is_char)
3315 oprintf (out, "const char");
3316 else
3317 oprintf (out, "void");
3319 else if (ty->kind == TYPE_POINTER)
3321 write_type_decl (out, ty->u.p);
3322 oprintf (out, " *");
3324 else if (ty->kind == TYPE_ARRAY)
3326 write_type_decl (out, ty->u.a.p);
3327 oprintf (out, " *");
3329 else if (ty->kind == TYPE_STRING)
3331 oprintf (out, "const char *");
3333 else
3334 gcc_unreachable ();
3338 /* Write on OF the name of the marker function for structure S. PREFIX
3339 is the prefix to use (to distinguish ggc from pch markers). */
3341 static void
3342 write_marker_function_name (outf_p of, type_p s, const char *prefix)
3344 if (union_or_struct_p (s))
3346 const char *id_for_tag = filter_type_name (s->u.s.tag);
3347 oprintf (of, "gt_%sx_%s", prefix, id_for_tag);
3348 if (id_for_tag != s->u.s.tag)
3349 free (CONST_CAST (char *, id_for_tag));
3351 else
3352 gcc_unreachable ();
3355 /* Write on OF a user-callable routine to act as an entry point for
3356 the marking routine for S, generated by write_func_for_structure.
3357 WTD distinguishes between ggc and pch markers. */
3359 static void
3360 write_user_func_for_structure_ptr (outf_p of, type_p s, const write_types_data *wtd)
3362 gcc_assert (union_or_struct_p (s));
3364 type_p alias_of = NULL;
3365 for (options_p opt = s->u.s.opt; opt; opt = opt->next)
3366 if (strcmp (opt->name, "ptr_alias") == 0)
3368 /* ALIAS_OF is set if ORIG_S is marked "ptr_alias". This means that
3369 we do not generate marking code for ORIG_S here. Instead, a
3370 forwarder #define in gtype-desc.h will cause every call to its
3371 marker to call the target of this alias.
3373 However, we still want to create a user entry code for the
3374 aliased type. So, if ALIAS_OF is set, we only generate the
3375 user-callable marker function. */
3376 alias_of = opt->info.type;
3377 break;
3380 DBGPRINTF ("write_user_func_for_structure_ptr: %s %s", s->u.s.tag,
3381 wtd->prefix);
3383 /* Only write the function once. */
3384 if (s->u.s.wrote_user_func_for_ptr[wtd->kind])
3385 return;
3386 s->u.s.wrote_user_func_for_ptr[wtd->kind] = true;
3388 oprintf (of, "\nvoid\n");
3389 oprintf (of, "gt_%sx (", wtd->prefix);
3390 write_type_decl (of, s);
3391 oprintf (of, " *& x)\n");
3392 oprintf (of, "{\n");
3393 oprintf (of, " if (x)\n ");
3394 write_marker_function_name (of,
3395 alias_of ? alias_of : get_ultimate_base_class (s),
3396 wtd->prefix);
3397 oprintf (of, " ((void *) x);\n");
3398 oprintf (of, "}\n");
3402 /* Write a function to mark all the fields of type S on OF. PREFIX
3403 and D are as in write_user_marking_functions. */
3405 static void
3406 write_user_func_for_structure_body (type_p s, const char *prefix,
3407 struct walk_type_data *d)
3409 oprintf (d->of, "\nvoid\n");
3410 oprintf (d->of, "gt_%sx (", prefix);
3411 write_type_decl (d->of, s);
3412 oprintf (d->of, "& x_r ATTRIBUTE_UNUSED)\n");
3413 oprintf (d->of, "{\n");
3414 oprintf (d->of, " ");
3415 write_type_decl (d->of, s);
3416 oprintf (d->of, " * ATTRIBUTE_UNUSED x = &x_r;\n");
3417 d->val = "(*x)";
3418 d->indent = 2;
3419 walk_type (s, d);
3420 oprintf (d->of, "}\n");
3423 /* Emit the user-callable functions needed to mark all the types used
3424 by the user structure S. PREFIX is the prefix to use to
3425 distinguish ggc and pch markers. D contains data needed to pass to
3426 walk_type when traversing the fields of a type.
3428 For every type T referenced by S, two routines are generated: one
3429 that takes 'T *', marks the pointer and calls the second routine,
3430 which just marks the fields of T. */
3432 static void
3433 write_user_marking_functions (type_p s,
3434 const write_types_data *w,
3435 struct walk_type_data *d)
3437 gcc_assert (s->kind == TYPE_USER_STRUCT);
3439 for (pair_p fld = s->u.s.fields; fld; fld = fld->next)
3441 type_p fld_type = fld->type;
3442 if (fld_type->kind == TYPE_POINTER)
3444 type_p pointed_to_type = fld_type->u.p;
3445 if (union_or_struct_p (pointed_to_type))
3446 write_user_func_for_structure_ptr (d->of, pointed_to_type, w);
3448 else if (union_or_struct_p (fld_type))
3449 write_user_func_for_structure_body (fld_type, w->prefix, d);
3454 /* For S, a structure that's part of ORIG_S write out a routine that:
3455 - Takes a parameter, a void * but actually of type *S
3456 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
3457 field of S or its substructures and (in some cases) things
3458 that are pointed to by S. */
3460 static void
3461 write_func_for_structure (type_p orig_s, type_p s,
3462 const struct write_types_data *wtd)
3464 const char *chain_next = NULL;
3465 const char *chain_prev = NULL;
3466 const char *chain_circular = NULL;
3467 options_p opt;
3468 struct walk_type_data d;
3470 if (s->u.s.base_class)
3472 /* Verify that the base class has a "desc", since otherwise
3473 the traversal hooks there won't attempt to visit fields of
3474 subclasses such as this one. */
3475 const_type_p ubc = get_ultimate_base_class (s);
3476 if ((!opts_have (ubc->u.s.opt, "user")
3477 && !opts_have (ubc->u.s.opt, "desc")))
3478 error_at_line (&s->u.s.line,
3479 ("'%s' is a subclass of non-GTY(user) GTY class '%s'"
3480 ", but '%s' lacks a discriminator 'desc' option"),
3481 s->u.s.tag, ubc->u.s.tag, ubc->u.s.tag);
3483 /* Don't write fns for subclasses, only for the ultimate base class
3484 within an inheritance hierarchy. */
3485 return;
3488 memset (&d, 0, sizeof (d));
3489 d.of = get_output_file_for_structure (s);
3491 bool for_user = false;
3492 for (opt = s->u.s.opt; opt; opt = opt->next)
3493 if (strcmp (opt->name, "chain_next") == 0
3494 && opt->kind == OPTION_STRING)
3495 chain_next = opt->info.string;
3496 else if (strcmp (opt->name, "chain_prev") == 0
3497 && opt->kind == OPTION_STRING)
3498 chain_prev = opt->info.string;
3499 else if (strcmp (opt->name, "chain_circular") == 0
3500 && opt->kind == OPTION_STRING)
3501 chain_circular = opt->info.string;
3502 else if (strcmp (opt->name, "for_user") == 0)
3503 for_user = true;
3504 if (chain_prev != NULL && chain_next == NULL)
3505 error_at_line (&s->u.s.line, "chain_prev without chain_next");
3506 if (chain_circular != NULL && chain_next != NULL)
3507 error_at_line (&s->u.s.line, "chain_circular with chain_next");
3508 if (chain_circular != NULL)
3509 chain_next = chain_circular;
3511 d.process_field = write_types_process_field;
3512 d.cookie = wtd;
3513 d.orig_s = orig_s;
3514 d.opt = s->u.s.opt;
3515 d.line = &s->u.s.line;
3516 d.bitmap = s->u.s.bitmap;
3517 d.prev_val[0] = "*x";
3518 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
3519 d.prev_val[3] = "x";
3520 d.val = "(*x)";
3521 d.have_this_obj = false;
3523 oprintf (d.of, "\n");
3524 oprintf (d.of, "void\n");
3525 write_marker_function_name (d.of, orig_s, wtd->prefix);
3526 oprintf (d.of, " (void *x_p)\n");
3527 oprintf (d.of, "{\n ");
3528 write_type_decl (d.of, s);
3529 oprintf (d.of, " * %sx = (", chain_next == NULL ? "const " : "");
3530 write_type_decl (d.of, s);
3531 oprintf (d.of, " *)x_p;\n");
3532 if (chain_next != NULL)
3534 /* TYPE_USER_STRUCTs should not occur here. These structures
3535 are completely handled by user code. */
3536 gcc_assert (orig_s->kind != TYPE_USER_STRUCT);
3538 oprintf (d.of, " ");
3539 write_type_decl (d.of, s);
3540 oprintf (d.of, " * xlimit = x;\n");
3542 if (chain_next == NULL)
3544 oprintf (d.of, " if (%s (x", wtd->marker_routine);
3545 if (wtd->param_prefix)
3547 oprintf (d.of, ", x, gt_%s_", wtd->param_prefix);
3548 output_mangled_typename (d.of, orig_s);
3550 oprintf (d.of, "))\n");
3552 else
3554 if (chain_circular != NULL)
3555 oprintf (d.of, " if (!%s (xlimit", wtd->marker_routine);
3556 else
3557 oprintf (d.of, " while (%s (xlimit", wtd->marker_routine);
3558 if (wtd->param_prefix)
3560 oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix);
3561 output_mangled_typename (d.of, orig_s);
3563 oprintf (d.of, "))\n");
3564 if (chain_circular != NULL)
3565 oprintf (d.of, " return;\n do\n");
3567 oprintf (d.of, " xlimit = (");
3568 d.prev_val[2] = "*xlimit";
3569 output_escaped_param (&d, chain_next, "chain_next");
3570 oprintf (d.of, ");\n");
3571 if (chain_prev != NULL)
3573 oprintf (d.of, " if (x != xlimit)\n");
3574 oprintf (d.of, " for (;;)\n");
3575 oprintf (d.of, " {\n");
3576 oprintf (d.of, " %s %s * const xprev = (",
3577 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
3579 d.prev_val[2] = "*x";
3580 output_escaped_param (&d, chain_prev, "chain_prev");
3581 oprintf (d.of, ");\n");
3582 oprintf (d.of, " if (xprev == NULL) break;\n");
3583 oprintf (d.of, " x = xprev;\n");
3584 oprintf (d.of, " (void) %s (xprev", wtd->marker_routine);
3585 if (wtd->param_prefix)
3587 oprintf (d.of, ", xprev, gt_%s_", wtd->param_prefix);
3588 output_mangled_typename (d.of, orig_s);
3590 oprintf (d.of, ");\n");
3591 oprintf (d.of, " }\n");
3593 if (chain_circular != NULL)
3595 oprintf (d.of, " while (%s (xlimit", wtd->marker_routine);
3596 if (wtd->param_prefix)
3598 oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix);
3599 output_mangled_typename (d.of, orig_s);
3601 oprintf (d.of, "));\n");
3602 oprintf (d.of, " do\n");
3604 else
3605 oprintf (d.of, " while (x != xlimit)\n");
3607 oprintf (d.of, " {\n");
3609 d.prev_val[2] = "*x";
3610 d.indent = 6;
3611 if (orig_s->kind != TYPE_USER_STRUCT)
3612 walk_type (s, &d);
3613 else
3615 /* User structures have no fields to walk. Simply generate a call
3616 to the user-provided structure marker. */
3617 oprintf (d.of, "%*sgt_%sx (x);\n", d.indent, "", wtd->prefix);
3620 if (chain_next != NULL)
3622 oprintf (d.of, " x = (");
3623 output_escaped_param (&d, chain_next, "chain_next");
3624 oprintf (d.of, ");\n");
3627 oprintf (d.of, " }\n");
3628 if (chain_circular != NULL)
3629 oprintf (d.of, " while (x != xlimit);\n");
3630 oprintf (d.of, "}\n");
3632 if (orig_s->kind == TYPE_USER_STRUCT)
3633 write_user_marking_functions (orig_s, wtd, &d);
3635 if (for_user)
3637 write_user_func_for_structure_body (orig_s, wtd->prefix, &d);
3638 write_user_func_for_structure_ptr (d.of, orig_s, wtd);
3643 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
3645 static void
3646 write_types (outf_p output_header, type_p structures,
3647 const struct write_types_data *wtd)
3649 int nbfun = 0; /* Count the emitted functions. */
3650 type_p s;
3652 oprintf (output_header, "\n/* %s*/\n", wtd->comment);
3654 /* We first emit the macros and the declarations. Functions' code is
3655 emitted afterwards. This is needed in plugin mode. */
3656 oprintf (output_header, "/* Macros and declarations. */\n");
3657 for (s = structures; s; s = s->next)
3658 /* Do not emit handlers for derived classes; we only ever deal with
3659 the ultimate base class within an inheritance hierarchy. */
3660 if ((s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO)
3661 && !s->u.s.base_class)
3663 options_p opt;
3665 if (s->gc_used == GC_MAYBE_POINTED_TO && s->u.s.line.file == NULL)
3666 continue;
3668 const char *s_id_for_tag = filter_type_name (s->u.s.tag);
3670 oprintf (output_header, "#define gt_%s_", wtd->prefix);
3671 output_mangled_typename (output_header, s);
3672 oprintf (output_header, "(X) do { \\\n");
3673 oprintf (output_header,
3674 " if ((intptr_t)(X) != 0) gt_%sx_%s (X);\\\n",
3675 wtd->prefix, s_id_for_tag);
3676 oprintf (output_header, " } while (0)\n");
3678 for (opt = s->u.s.opt; opt; opt = opt->next)
3679 if (strcmp (opt->name, "ptr_alias") == 0
3680 && opt->kind == OPTION_TYPE)
3682 const_type_p const t = (const_type_p) opt->info.type;
3683 if (t->kind == TYPE_STRUCT
3684 || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT)
3686 const char *t_id_for_tag = filter_type_name (t->u.s.tag);
3687 oprintf (output_header,
3688 "#define gt_%sx_%s gt_%sx_%s\n",
3689 wtd->prefix, s->u.s.tag, wtd->prefix, t_id_for_tag);
3690 if (t_id_for_tag != t->u.s.tag)
3691 free (CONST_CAST (char *, t_id_for_tag));
3693 else
3694 error_at_line (&s->u.s.line,
3695 "structure alias is not a structure");
3696 break;
3698 if (opt)
3699 continue;
3701 /* Declare the marker procedure only once. */
3702 oprintf (output_header,
3703 "extern void gt_%sx_%s (void *);\n",
3704 wtd->prefix, s_id_for_tag);
3706 if (s_id_for_tag != s->u.s.tag)
3707 free (CONST_CAST (char *, s_id_for_tag));
3709 if (s->u.s.line.file == NULL)
3711 fprintf (stderr, "warning: structure `%s' used but not defined\n",
3712 s->u.s.tag);
3713 continue;
3717 /* At last we emit the functions code. */
3718 oprintf (output_header, "\n/* functions code */\n");
3719 for (s = structures; s; s = s->next)
3720 if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO)
3722 options_p opt;
3724 if (s->gc_used == GC_MAYBE_POINTED_TO && s->u.s.line.file == NULL)
3725 continue;
3726 for (opt = s->u.s.opt; opt; opt = opt->next)
3727 if (strcmp (opt->name, "ptr_alias") == 0)
3728 break;
3729 if (opt)
3730 continue;
3732 if (s->kind == TYPE_LANG_STRUCT)
3734 type_p ss;
3735 for (ss = s->u.s.lang_struct; ss; ss = ss->next)
3737 nbfun++;
3738 DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'",
3739 nbfun, (void*) ss, ss->u.s.tag);
3740 write_func_for_structure (s, ss, wtd);
3743 else
3745 nbfun++;
3746 DBGPRINTF ("writing func #%d struct s @ %p '%s'",
3747 nbfun, (void*) s, s->u.s.tag);
3748 write_func_for_structure (s, s, wtd);
3751 else
3753 /* Structure s is not possibly pointed to, so can be ignored. */
3754 DBGPRINTF ("ignored s @ %p '%s' gc_used#%d",
3755 (void*)s, s->u.s.tag,
3756 (int) s->gc_used);
3759 if (verbosity_level >= 2)
3760 printf ("%s emitted %d routines for %s\n",
3761 progname, nbfun, wtd->comment);
3764 static const struct write_types_data ggc_wtd = {
3765 "ggc_m", NULL, "ggc_mark", "ggc_test_and_set_mark", NULL,
3766 "GC marker procedures. ",
3767 WTK_GGC
3770 static const struct write_types_data pch_wtd = {
3771 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
3772 "gt_pch_note_reorder",
3773 "PCH type-walking procedures. ",
3774 WTK_PCH
3777 /* Write out the local pointer-walking routines. */
3779 /* process_field routine for local pointer-walking for user-callable
3780 routines. The difference between this and
3781 write_types_local_process_field is that, in this case, we do not
3782 need to check whether the given pointer matches the address of the
3783 parent structure. This check was already generated by the call
3784 to gt_pch_nx in the main gt_pch_p_*() function that is calling
3785 this code. */
3787 static void
3788 write_types_local_user_process_field (type_p f, const struct walk_type_data *d)
3790 switch (f->kind)
3792 case TYPE_POINTER:
3793 case TYPE_STRUCT:
3794 case TYPE_UNION:
3795 case TYPE_LANG_STRUCT:
3796 case TYPE_STRING:
3797 if (d->in_nested_ptr)
3798 oprintf (d->of, "%*s op (&(%s), &(%s), cookie);\n",
3799 d->indent, "", d->val, d->prev_val[2]);
3800 oprintf (d->of, "%*s op (&(%s), NULL, cookie);\n",
3801 d->indent, "", d->val);
3802 break;
3804 case TYPE_USER_STRUCT:
3805 if (d->in_ptr_field)
3806 oprintf (d->of, "%*s op (&(%s), NULL, cookie);\n",
3807 d->indent, "", d->val);
3808 else
3809 oprintf (d->of, "%*s gt_pch_nx (&(%s), op, cookie);\n",
3810 d->indent, "", d->val);
3811 break;
3813 case TYPE_SCALAR:
3814 case TYPE_CALLBACK:
3815 break;
3817 case TYPE_ARRAY:
3818 case TYPE_NONE:
3819 case TYPE_UNDEFINED:
3820 gcc_unreachable ();
3825 /* Write a function to PCH walk all the fields of type S on OF.
3826 D contains data needed by walk_type to recurse into the fields of S. */
3828 static void
3829 write_pch_user_walking_for_structure_body (type_p s, struct walk_type_data *d)
3831 oprintf (d->of, "\nvoid\n");
3832 oprintf (d->of, "gt_pch_nx (");
3833 write_type_decl (d->of, s);
3834 oprintf (d->of, "* x ATTRIBUTE_UNUSED,\n"
3835 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3836 "\tATTRIBUTE_UNUSED void *cookie)\n");
3837 oprintf (d->of, "{\n");
3838 d->val = "(*x)";
3839 d->indent = 2;
3840 d->process_field = write_types_local_user_process_field;
3841 walk_type (s, d);
3842 oprintf (d->of, "}\n");
3846 /* Emit the user-callable functions needed to mark all the types used
3847 by the user structure S. PREFIX is the prefix to use to
3848 distinguish ggc and pch markers. CHAIN_NEXT is set if S has the
3849 chain_next option defined. D contains data needed to pass to
3850 walk_type when traversing the fields of a type.
3852 For every type T referenced by S, two routines are generated: one
3853 that takes 'T *', marks the pointer and calls the second routine,
3854 which just marks the fields of T. */
3856 static void
3857 write_pch_user_walking_functions (type_p s, struct walk_type_data *d)
3859 gcc_assert (s->kind == TYPE_USER_STRUCT);
3861 for (pair_p fld = s->u.s.fields; fld; fld = fld->next)
3863 type_p fld_type = fld->type;
3864 if (union_or_struct_p (fld_type))
3865 write_pch_user_walking_for_structure_body (fld_type, d);
3870 /* process_field routine for local pointer-walking. */
3872 static void
3873 write_types_local_process_field (type_p f, const struct walk_type_data *d)
3875 gcc_assert (d->have_this_obj);
3876 switch (f->kind)
3878 case TYPE_POINTER:
3879 case TYPE_STRUCT:
3880 case TYPE_UNION:
3881 case TYPE_LANG_STRUCT:
3882 case TYPE_STRING:
3883 oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "",
3884 d->prev_val[3]);
3885 if (d->in_nested_ptr)
3886 oprintf (d->of, "%*s op (&(%s), &(%s), cookie);\n",
3887 d->indent, "", d->val, d->prev_val[2]);
3888 else
3889 oprintf (d->of, "%*s op (&(%s), NULL, cookie);\n",
3890 d->indent, "", d->val);
3891 break;
3893 case TYPE_USER_STRUCT:
3894 oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "",
3895 d->prev_val[3]);
3896 if (d->in_ptr_field)
3897 oprintf (d->of, "%*s op (&(%s), NULL, cookie);\n",
3898 d->indent, "", d->val);
3899 else
3900 oprintf (d->of, "%*s gt_pch_nx (&(%s), op, cookie);\n",
3901 d->indent, "", d->val);
3902 break;
3904 case TYPE_SCALAR:
3905 break;
3907 case TYPE_CALLBACK:
3908 oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "",
3909 d->prev_val[3]);
3910 oprintf (d->of, "%*s gt_pch_note_callback (&(%s), this_obj);\n",
3911 d->indent, "", d->val);
3912 break;
3914 case TYPE_ARRAY:
3915 case TYPE_NONE:
3916 case TYPE_UNDEFINED:
3917 gcc_unreachable ();
3922 /* For S, a structure that's part of ORIG_S, and using parameters
3923 PARAM, write out a routine that:
3924 - Is of type gt_note_pointers
3925 - Calls PROCESS_FIELD on each field of S or its substructures.
3928 static void
3929 write_local_func_for_structure (const_type_p orig_s, type_p s)
3931 struct walk_type_data d;
3933 /* Don't write fns for subclasses, only for the ultimate base class
3934 within an inheritance hierarchy. */
3935 if (s->u.s.base_class)
3936 return;
3938 memset (&d, 0, sizeof (d));
3939 d.of = get_output_file_for_structure (s);
3940 d.process_field = write_types_local_process_field;
3941 d.opt = s->u.s.opt;
3942 d.line = &s->u.s.line;
3943 d.bitmap = s->u.s.bitmap;
3944 d.prev_val[0] = d.prev_val[2] = "*x";
3945 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
3946 d.prev_val[3] = "x";
3947 d.val = "(*x)";
3948 d.fn_wants_lvalue = true;
3950 oprintf (d.of, "\n");
3951 oprintf (d.of, "void\n");
3952 oprintf (d.of, "gt_pch_p_");
3953 output_mangled_typename (d.of, orig_s);
3954 oprintf (d.of, " (ATTRIBUTE_UNUSED void *this_obj,\n"
3955 "\tvoid *x_p,\n"
3956 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3957 "\tATTRIBUTE_UNUSED void *cookie)\n");
3958 oprintf (d.of, "{\n");
3959 oprintf (d.of, " %s %s * x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
3960 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag,
3961 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
3962 d.indent = 2;
3963 d.have_this_obj = true;
3965 if (s->kind != TYPE_USER_STRUCT)
3966 walk_type (s, &d);
3967 else
3969 /* User structures have no fields to walk. Simply generate a
3970 call to the user-provided PCH walker. */
3971 oprintf (d.of, "%*sif ((void *)(%s) == this_obj)\n", d.indent, "",
3972 d.prev_val[3]);
3973 oprintf (d.of, "%*s gt_pch_nx (&(%s), op, cookie);\n",
3974 d.indent, "", d.val);
3977 oprintf (d.of, "}\n");
3979 /* Write user-callable entry points for the PCH walking routines. */
3980 if (orig_s->kind == TYPE_USER_STRUCT)
3981 write_pch_user_walking_functions (s, &d);
3983 for (options_p o = s->u.s.opt; o; o = o->next)
3984 if (strcmp (o->name, "for_user") == 0)
3986 write_pch_user_walking_for_structure_body (s, &d);
3987 break;
3991 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
3993 static void
3994 write_local (outf_p output_header, type_p structures)
3996 type_p s;
3998 if (!output_header)
3999 return;
4001 oprintf (output_header, "\n/* Local pointer-walking routines. */\n");
4002 for (s = structures; s; s = s->next)
4003 if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO)
4005 options_p opt;
4007 if (s->u.s.line.file == NULL)
4008 continue;
4009 for (opt = s->u.s.opt; opt; opt = opt->next)
4010 if (strcmp (opt->name, "ptr_alias") == 0
4011 && opt->kind == OPTION_TYPE)
4013 const_type_p const t = (const_type_p) opt->info.type;
4014 if (t->kind == TYPE_STRUCT
4015 || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT)
4017 oprintf (output_header, "#define gt_pch_p_");
4018 output_mangled_typename (output_header, s);
4019 oprintf (output_header, " gt_pch_p_");
4020 output_mangled_typename (output_header, t);
4021 oprintf (output_header, "\n");
4023 else
4024 error_at_line (&s->u.s.line,
4025 "structure alias is not a structure");
4026 break;
4028 if (opt)
4029 continue;
4031 /* Declare the marker procedure only once. */
4032 oprintf (output_header, "extern void gt_pch_p_");
4033 output_mangled_typename (output_header, s);
4034 oprintf (output_header,
4035 "\n (void *, void *, gt_pointer_operator, void *);\n");
4037 if (s->kind == TYPE_LANG_STRUCT)
4039 type_p ss;
4040 for (ss = s->u.s.lang_struct; ss; ss = ss->next)
4041 write_local_func_for_structure (s, ss);
4043 else
4044 write_local_func_for_structure (s, s);
4048 /* Nonzero if S is a type for which typed GC allocators should be output. */
4050 #define USED_BY_TYPED_GC_P(s) \
4051 ((s->kind == TYPE_POINTER \
4052 && (s->u.p->gc_used == GC_POINTED_TO \
4053 || s->u.p->gc_used == GC_USED)) \
4054 || (union_or_struct_p (s) \
4055 && ((s)->gc_used == GC_POINTED_TO \
4056 || ((s)->gc_used == GC_MAYBE_POINTED_TO \
4057 && s->u.s.line.file != NULL) \
4058 || ((s)->gc_used == GC_USED \
4059 && !startswith (s->u.s.tag, "anonymous")) \
4060 || (s->u.s.base_class && opts_have (s->u.s.opt, "tag")))))
4064 /* Might T contain any non-pointer elements? */
4066 static int
4067 contains_scalar_p (type_p t)
4069 switch (t->kind)
4071 case TYPE_STRING:
4072 case TYPE_POINTER:
4073 return 0;
4074 case TYPE_ARRAY:
4075 return contains_scalar_p (t->u.a.p);
4076 case TYPE_USER_STRUCT:
4077 /* User-marked structures will typically contain pointers. */
4078 return 0;
4079 default:
4080 /* Could also check for structures that have no non-pointer
4081 fields, but there aren't enough of those to worry about. */
4082 return 1;
4086 /* Mangle INPF and print it to F. */
4088 static void
4089 put_mangled_filename (outf_p f, const input_file *inpf)
4091 /* The call to get_output_file_name may indirectly update fn since
4092 get_output_file_with_visibility caches its result inside, so we
4093 need the CONST_CAST. */
4094 const char *name = get_output_file_name (CONST_CAST (input_file*, inpf));
4095 if (!f || !name)
4096 return;
4097 for (; *name != 0; name++)
4098 if (ISALNUM (*name))
4099 oprintf (f, "%c", *name);
4100 else
4101 oprintf (f, "%c", '_');
4104 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
4105 LASTNAME, and NAME are all strings to insert in various places in
4106 the resulting code. */
4108 static void
4109 finish_root_table (struct flist *flp, const char *pfx, const char *lastname,
4110 const char *tname, const char *name)
4112 struct flist *fli2;
4114 for (fli2 = flp; fli2; fli2 = fli2->next)
4115 if (fli2->started_p)
4117 oprintf (fli2->f, " %s\n", lastname);
4118 oprintf (fli2->f, "};\n\n");
4121 for (fli2 = flp; fli2 && base_files; fli2 = fli2->next)
4122 if (fli2->started_p)
4124 lang_bitmap bitmap = get_lang_bitmap (fli2->file);
4125 int fnum;
4127 for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1)
4128 if (bitmap & 1)
4130 oprintf (base_files[fnum],
4131 "extern const struct %s gt_%s_", tname, pfx);
4132 put_mangled_filename (base_files[fnum], fli2->file);
4133 oprintf (base_files[fnum], "[];\n");
4138 size_t fnum;
4139 for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
4140 oprintf (base_files[fnum],
4141 "EXPORTED_CONST struct %s * const %s[] = {\n", tname, name);
4145 for (fli2 = flp; fli2; fli2 = fli2->next)
4146 if (fli2->started_p)
4148 lang_bitmap bitmap = get_lang_bitmap (fli2->file);
4149 int fnum;
4151 fli2->started_p = 0;
4153 for (fnum = 0; base_files && bitmap != 0; fnum++, bitmap >>= 1)
4154 if (bitmap & 1)
4156 oprintf (base_files[fnum], " gt_%s_", pfx);
4157 put_mangled_filename (base_files[fnum], fli2->file);
4158 oprintf (base_files[fnum], ",\n");
4163 size_t fnum;
4164 for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
4166 oprintf (base_files[fnum], " NULL\n");
4167 oprintf (base_files[fnum], "};\n");
4172 /* Finish off the created gt_clear_caches_file_c functions. */
4174 static void
4175 finish_cache_funcs (flist *flp)
4177 struct flist *fli2;
4179 for (fli2 = flp; fli2; fli2 = fli2->next)
4180 if (fli2->started_p)
4182 oprintf (fli2->f, "}\n\n");
4185 for (fli2 = flp; fli2 && base_files; fli2 = fli2->next)
4186 if (fli2->started_p)
4188 lang_bitmap bitmap = get_lang_bitmap (fli2->file);
4189 int fnum;
4191 for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1)
4192 if (bitmap & 1)
4194 oprintf (base_files[fnum], "extern void gt_clear_caches_");
4195 put_mangled_filename (base_files[fnum], fli2->file);
4196 oprintf (base_files[fnum], " ();\n");
4200 for (size_t fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
4201 oprintf (base_files[fnum], "void\ngt_clear_caches ()\n{\n");
4203 for (fli2 = flp; fli2; fli2 = fli2->next)
4204 if (fli2->started_p)
4206 lang_bitmap bitmap = get_lang_bitmap (fli2->file);
4207 int fnum;
4209 fli2->started_p = 0;
4211 for (fnum = 0; base_files && bitmap != 0; fnum++, bitmap >>= 1)
4212 if (bitmap & 1)
4214 oprintf (base_files[fnum], " gt_clear_caches_");
4215 put_mangled_filename (base_files[fnum], fli2->file);
4216 oprintf (base_files[fnum], " ();\n");
4220 for (size_t fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
4222 oprintf (base_files[fnum], "}\n");
4226 /* Write the first three fields (pointer, count and stride) for
4227 root NAME to F. V and LINE are as for write_root.
4229 Return true if the entry could be written; return false on error. */
4231 static bool
4232 start_root_entry (outf_p f, pair_p v, const char *name, struct fileloc *line)
4234 type_p ap;
4236 if (!v)
4238 error_at_line (line, "`%s' is too complex to be a root", name);
4239 return false;
4242 oprintf (f, " {\n");
4243 oprintf (f, " &%s,\n", name);
4244 oprintf (f, " 1");
4246 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
4247 if (ap->u.a.len[0])
4248 oprintf (f, " * (%s)", ap->u.a.len);
4249 else if (ap == v->type)
4250 oprintf (f, " * ARRAY_SIZE (%s)", v->name);
4251 oprintf (f, ",\n");
4252 oprintf (f, " sizeof (%s", v->name);
4253 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
4254 oprintf (f, "[0]");
4255 oprintf (f, "),\n");
4256 return true;
4259 /* A subroutine of write_root for writing the roots for field FIELD_NAME,
4260 which has type FIELD_TYPE. Parameters F to EMIT_PCH are the parameters
4261 of the caller. */
4263 static void
4264 write_field_root (outf_p f, pair_p v, type_p type, const char *name,
4265 int has_length, struct fileloc *line,
4266 bool emit_pch, type_p field_type, const char *field_name)
4268 struct pair newv;
4269 /* If the field reference is relative to V, rather than to some
4270 subcomponent of V, we can mark any subarrays with a single stride.
4271 We're effectively treating the field as a global variable in its
4272 own right. */
4273 if (v && type == v->type)
4275 newv = *v;
4276 newv.type = field_type;
4277 newv.name = ACONCAT ((v->name, ".", field_name, NULL));
4278 v = &newv;
4280 /* Otherwise, any arrays nested in the structure are too complex to
4281 handle. */
4282 else if (field_type->kind == TYPE_ARRAY)
4283 v = NULL;
4284 write_root (f, v, field_type, ACONCAT ((name, ".", field_name, NULL)),
4285 has_length, line, emit_pch);
4288 /* Write out to F the table entry and any marker routines needed to
4289 mark NAME as TYPE. V can be one of three values:
4291 - null, if NAME is too complex to represent using a single
4292 count and stride. In this case, it is an error for NAME to
4293 contain any gc-ed data.
4295 - the outermost array that contains NAME, if NAME is part of an array.
4297 - the C variable that contains NAME, if NAME is not part of an array.
4299 LINE is the line of the C source that declares the root variable.
4300 HAS_LENGTH is nonzero iff V was a variable-length array. */
4302 static void
4303 write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
4304 struct fileloc *line, bool emit_pch)
4306 switch (type->kind)
4308 case TYPE_STRUCT:
4310 pair_p fld;
4311 for (fld = type->u.s.fields; fld; fld = fld->next)
4313 int skip_p = 0;
4314 const char *desc = NULL;
4315 options_p o;
4317 for (o = fld->opt; o; o = o->next)
4318 if (strcmp (o->name, "skip") == 0)
4319 skip_p = 1;
4320 else if (strcmp (o->name, "desc") == 0
4321 && o->kind == OPTION_STRING)
4322 desc = o->info.string;
4323 else
4324 error_at_line (line,
4325 "field `%s' of global `%s' has unknown option `%s'",
4326 fld->name, name, o->name);
4328 if (skip_p)
4329 continue;
4330 else if (desc && fld->type->kind == TYPE_UNION)
4332 pair_p validf = NULL;
4333 pair_p ufld;
4335 for (ufld = fld->type->u.s.fields; ufld; ufld = ufld->next)
4337 const char *tag = NULL;
4338 options_p oo;
4339 for (oo = ufld->opt; oo; oo = oo->next)
4340 if (strcmp (oo->name, "tag") == 0
4341 && oo->kind == OPTION_STRING)
4342 tag = oo->info.string;
4343 if (tag == NULL || strcmp (tag, desc) != 0)
4344 continue;
4345 if (validf != NULL)
4346 error_at_line (line,
4347 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
4348 name, fld->name, validf->name,
4349 name, fld->name, ufld->name, tag);
4350 validf = ufld;
4352 if (validf != NULL)
4353 write_field_root (f, v, type, name, 0, line, emit_pch,
4354 validf->type,
4355 ACONCAT ((fld->name, ".",
4356 validf->name, NULL)));
4358 else if (desc)
4359 error_at_line (line,
4360 "global `%s.%s' has `desc' option but is not union",
4361 name, fld->name);
4362 else
4363 write_field_root (f, v, type, name, 0, line, emit_pch, fld->type,
4364 fld->name);
4367 break;
4369 case TYPE_ARRAY:
4371 char *newname;
4372 newname = xasprintf ("%s[0]", name);
4373 write_root (f, v, type->u.a.p, newname, has_length, line, emit_pch);
4374 free (newname);
4376 break;
4378 case TYPE_USER_STRUCT:
4379 error_at_line (line, "`%s' must be a pointer type, because it is "
4380 "a GC root and its type is marked with GTY((user))",
4381 v->name);
4382 break;
4384 case TYPE_POINTER:
4386 const_type_p tp;
4388 if (!start_root_entry (f, v, name, line))
4389 return;
4391 tp = type->u.p;
4393 if (!has_length && union_or_struct_p (tp))
4395 tp = get_ultimate_base_class (tp);
4396 const char *id_for_tag = filter_type_name (tp->u.s.tag);
4397 oprintf (f, " &gt_ggc_mx_%s,\n", id_for_tag);
4398 if (emit_pch)
4399 oprintf (f, " &gt_pch_nx_%s", id_for_tag);
4400 else
4401 oprintf (f, " NULL");
4402 if (id_for_tag != tp->u.s.tag)
4403 free (CONST_CAST (char *, id_for_tag));
4405 else if (has_length
4406 && (tp->kind == TYPE_POINTER || union_or_struct_p (tp)))
4408 oprintf (f, " &gt_ggc_ma_%s,\n", name);
4409 if (emit_pch)
4410 oprintf (f, " &gt_pch_na_%s", name);
4411 else
4412 oprintf (f, " NULL");
4414 else
4416 error_at_line (line,
4417 "global `%s' is pointer to unimplemented type",
4418 name);
4420 oprintf (f, "\n },\n");
4422 break;
4424 case TYPE_STRING:
4426 if (!start_root_entry (f, v, name, line))
4427 return;
4429 oprintf (f, " (gt_pointer_walker) &gt_ggc_m_S,\n");
4430 oprintf (f, " (gt_pointer_walker) &gt_pch_n_S\n");
4431 oprintf (f, " },\n");
4433 break;
4435 case TYPE_SCALAR:
4436 break;
4438 case TYPE_NONE:
4439 case TYPE_UNDEFINED:
4440 case TYPE_UNION:
4441 case TYPE_LANG_STRUCT:
4442 case TYPE_CALLBACK:
4443 error_at_line (line, "global `%s' is unimplemented type", name);
4447 /* This generates a routine to walk an array. */
4449 static void
4450 write_array (outf_p f, pair_p v, const struct write_types_data *wtd)
4452 struct walk_type_data d;
4453 char *prevval3;
4455 memset (&d, 0, sizeof (d));
4456 d.of = f;
4457 d.cookie = wtd;
4458 d.indent = 2;
4459 d.line = &v->line;
4460 d.opt = v->opt;
4461 d.bitmap = get_lang_bitmap (v->line.file);
4463 d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name);
4465 if (wtd->param_prefix)
4467 oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name);
4468 oprintf (f, " (void *, void *, gt_pointer_operator, void *);\n");
4469 oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
4470 wtd->param_prefix, v->name);
4471 oprintf (d.of,
4472 " ATTRIBUTE_UNUSED void *x_p,\n"
4473 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
4474 " ATTRIBUTE_UNUSED void * cookie)\n");
4475 oprintf (d.of, "{\n");
4476 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
4477 d.process_field = write_types_local_process_field;
4478 d.have_this_obj = true;
4479 walk_type (v->type, &d);
4480 oprintf (f, "}\n\n");
4483 d.opt = v->opt;
4484 oprintf (f, "static void gt_%sa_%s (void *);\n", wtd->prefix, v->name);
4485 oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
4486 wtd->prefix, v->name);
4487 oprintf (f, "{\n");
4488 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
4489 d.process_field = write_types_process_field;
4490 d.have_this_obj = false;
4491 walk_type (v->type, &d);
4492 free (prevval3);
4493 oprintf (f, "}\n\n");
4496 /* Output a table describing the locations and types of VARIABLES. */
4498 static void
4499 write_roots (pair_p variables, bool emit_pch)
4501 pair_p v;
4502 struct flist *flp = NULL;
4504 for (v = variables; v; v = v->next)
4506 outf_p f =
4507 get_output_file_with_visibility (CONST_CAST (input_file*,
4508 v->line.file));
4509 struct flist *fli;
4510 const char *length = NULL;
4511 int deletable_p = 0;
4512 options_p o;
4513 for (o = v->opt; o; o = o->next)
4514 if (strcmp (o->name, "length") == 0
4515 && o->kind == OPTION_STRING)
4516 length = o->info.string;
4517 else if (strcmp (o->name, "deletable") == 0)
4518 deletable_p = 1;
4519 else if (strcmp (o->name, "cache") == 0)
4521 else
4522 error_at_line (&v->line,
4523 "global `%s' has unknown option `%s'",
4524 v->name, o->name);
4526 for (fli = flp; fli; fli = fli->next)
4527 if (fli->f == f && f)
4528 break;
4529 if (fli == NULL)
4531 fli = XNEW (struct flist);
4532 fli->f = f;
4533 fli->next = flp;
4534 fli->started_p = 0;
4535 fli->file = v->line.file;
4536 gcc_assert (fli->file);
4537 flp = fli;
4539 oprintf (f, "\n/* GC roots. */\n\n");
4542 if (!deletable_p
4543 && length
4544 && v->type->kind == TYPE_POINTER
4545 && (v->type->u.p->kind == TYPE_POINTER
4546 || v->type->u.p->kind == TYPE_STRUCT))
4548 write_array (f, v, &ggc_wtd);
4549 write_array (f, v, &pch_wtd);
4553 for (v = variables; v; v = v->next)
4555 outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
4556 v->line.file));
4557 struct flist *fli;
4558 int skip_p = 0;
4559 int length_p = 0;
4560 options_p o;
4562 for (o = v->opt; o; o = o->next)
4563 if (strcmp (o->name, "length") == 0)
4564 length_p = 1;
4565 else if (strcmp (o->name, "deletable") == 0)
4566 skip_p = 1;
4568 if (skip_p)
4569 continue;
4571 for (fli = flp; fli; fli = fli->next)
4572 if (fli->f == f)
4573 break;
4574 if (!fli->started_p)
4576 fli->started_p = 1;
4578 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
4579 put_mangled_filename (f, v->line.file);
4580 oprintf (f, "[] = {\n");
4583 write_root (f, v, v->type, v->name, length_p, &v->line, emit_pch);
4586 finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4587 "gt_ggc_rtab");
4589 for (v = variables; v; v = v->next)
4591 outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
4592 v->line.file));
4593 struct flist *fli;
4594 int skip_p = 1;
4595 options_p o;
4597 for (o = v->opt; o; o = o->next)
4598 if (strcmp (o->name, "deletable") == 0)
4599 skip_p = 0;
4601 if (skip_p)
4602 continue;
4604 for (fli = flp; fli; fli = fli->next)
4605 if (fli->f == f)
4606 break;
4607 if (!fli->started_p)
4609 fli->started_p = 1;
4611 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
4612 put_mangled_filename (f, v->line.file);
4613 oprintf (f, "[] = {\n");
4616 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
4617 v->name, v->name);
4620 finish_root_table (flp, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4621 "gt_ggc_deletable_rtab");
4623 for (v = variables; v; v = v->next)
4625 outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
4626 v->line.file));
4627 struct flist *fli;
4628 bool cache = false;
4629 options_p o;
4631 for (o = v->opt; o; o = o->next)
4632 if (strcmp (o->name, "cache") == 0)
4633 cache = true;
4634 if (!cache)
4635 continue;
4637 for (fli = flp; fli; fli = fli->next)
4638 if (fli->f == f)
4639 break;
4640 if (!fli->started_p)
4642 fli->started_p = 1;
4644 oprintf (f, "void\ngt_clear_caches_");
4645 put_mangled_filename (f, v->line.file);
4646 oprintf (f, " ()\n{\n");
4649 oprintf (f, " gt_cleare_cache (%s);\n", v->name);
4652 finish_cache_funcs (flp);
4654 if (!emit_pch)
4655 return;
4657 for (v = variables; v; v = v->next)
4659 outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
4660 v->line.file));
4661 struct flist *fli;
4662 int skip_p = 0;
4663 options_p o;
4665 for (o = v->opt; o; o = o->next)
4666 if (strcmp (o->name, "deletable") == 0)
4668 skip_p = 1;
4669 break;
4672 if (skip_p)
4673 continue;
4675 if (!contains_scalar_p (v->type))
4676 continue;
4678 for (fli = flp; fli; fli = fli->next)
4679 if (fli->f == f)
4680 break;
4681 if (!fli->started_p)
4683 fli->started_p = 1;
4685 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
4686 put_mangled_filename (f, v->line.file);
4687 oprintf (f, "[] = {\n");
4690 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
4691 v->name, v->name);
4694 finish_root_table (flp, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4695 "gt_pch_scalar_rtab");
4698 /* Prints not-as-ugly version of a typename of T to OF. Trades the uniquness
4699 guaranteee for somewhat increased readability. If name conflicts do happen,
4700 this funcion will have to be adjusted to be more like
4701 output_mangled_typename. */
4703 #define INDENT 2
4705 /* Dumps the value of typekind KIND. */
4707 static void
4708 dump_typekind (int indent, enum typekind kind)
4710 printf ("%*ckind = ", indent, ' ');
4711 switch (kind)
4713 case TYPE_SCALAR:
4714 printf ("TYPE_SCALAR");
4715 break;
4716 case TYPE_STRING:
4717 printf ("TYPE_STRING");
4718 break;
4719 case TYPE_STRUCT:
4720 printf ("TYPE_STRUCT");
4721 break;
4722 case TYPE_UNDEFINED:
4723 printf ("TYPE_UNDEFINED");
4724 break;
4725 case TYPE_USER_STRUCT:
4726 printf ("TYPE_USER_STRUCT");
4727 break;
4728 case TYPE_UNION:
4729 printf ("TYPE_UNION");
4730 break;
4731 case TYPE_POINTER:
4732 printf ("TYPE_POINTER");
4733 break;
4734 case TYPE_ARRAY:
4735 printf ("TYPE_ARRAY");
4736 break;
4737 case TYPE_CALLBACK:
4738 printf ("TYPE_CALLBACK");
4739 break;
4740 case TYPE_LANG_STRUCT:
4741 printf ("TYPE_LANG_STRUCT");
4742 break;
4743 default:
4744 gcc_unreachable ();
4746 printf ("\n");
4749 /* Dumps the value of GC_USED flag. */
4751 static void
4752 dump_gc_used (int indent, enum gc_used_enum gc_used)
4754 printf ("%*cgc_used = ", indent, ' ');
4755 switch (gc_used)
4757 case GC_UNUSED:
4758 printf ("GC_UNUSED");
4759 break;
4760 case GC_USED:
4761 printf ("GC_USED");
4762 break;
4763 case GC_MAYBE_POINTED_TO:
4764 printf ("GC_MAYBE_POINTED_TO");
4765 break;
4766 case GC_POINTED_TO:
4767 printf ("GC_POINTED_TO");
4768 break;
4769 default:
4770 gcc_unreachable ();
4772 printf ("\n");
4775 /* Dumps the type options OPT. */
4777 static void
4778 dump_options (int indent, options_p opt)
4780 options_p o;
4781 printf ("%*coptions = ", indent, ' ');
4782 o = opt;
4783 while (o)
4785 switch (o->kind)
4787 case OPTION_STRING:
4788 printf ("%s:string %s ", o->name, o->info.string);
4789 break;
4790 case OPTION_TYPE:
4791 printf ("%s:type ", o->name);
4792 dump_type (indent+1, o->info.type);
4793 break;
4794 case OPTION_NESTED:
4795 printf ("%s:nested ", o->name);
4796 break;
4797 case OPTION_NONE:
4798 gcc_unreachable ();
4800 o = o->next;
4802 printf ("\n");
4805 /* Dumps the source file location in LINE. */
4807 static void
4808 dump_fileloc (int indent, struct fileloc line)
4810 printf ("%*cfileloc: file = %s, line = %d\n", indent, ' ',
4811 get_input_file_name (line.file),
4812 line.line);
4815 /* Recursively dumps the struct, union, or a language-specific
4816 struct T. */
4818 static void
4819 dump_type_u_s (int indent, type_p t)
4821 pair_p fields;
4823 gcc_assert (union_or_struct_p (t));
4824 printf ("%*cu.s.tag = %s\n", indent, ' ', t->u.s.tag);
4825 dump_fileloc (indent, t->u.s.line);
4826 printf ("%*cu.s.fields =\n", indent, ' ');
4827 fields = t->u.s.fields;
4828 while (fields)
4830 dump_pair (indent + INDENT, fields);
4831 fields = fields->next;
4833 printf ("%*cend of fields of type %p\n", indent, ' ', (void *) t);
4834 dump_options (indent, t->u.s.opt);
4835 printf ("%*cu.s.bitmap = %X\n", indent, ' ', t->u.s.bitmap);
4836 if (t->kind == TYPE_LANG_STRUCT)
4838 printf ("%*cu.s.lang_struct:\n", indent, ' ');
4839 dump_type_list (indent + INDENT, t->u.s.lang_struct);
4843 /* Recursively dumps the array T. */
4845 static void
4846 dump_type_u_a (int indent, type_p t)
4848 gcc_assert (t->kind == TYPE_ARRAY);
4849 printf ("%*clen = %s, u.a.p:\n", indent, ' ', t->u.a.len);
4850 dump_type_list (indent + INDENT, t->u.a.p);
4853 /* Recursively dumps the type list T. */
4855 static void
4856 dump_type_list (int indent, type_p t)
4858 type_p p = t;
4859 while (p)
4861 dump_type (indent, p);
4862 p = p->next;
4866 static htab_t seen_types;
4868 /* Recursively dumps the type T if it was not dumped previously. */
4870 static void
4871 dump_type (int indent, type_p t)
4873 void **slot;
4875 printf ("%*cType at %p: ", indent, ' ', (void *) t);
4876 if (t->kind == TYPE_UNDEFINED)
4878 gcc_assert (t->gc_used == GC_UNUSED);
4879 printf ("undefined.\n");
4880 return;
4883 if (seen_types == NULL)
4884 seen_types = htab_create (100, htab_hash_pointer, htab_eq_pointer, NULL);
4886 slot = htab_find_slot (seen_types, t, INSERT);
4887 if (*slot != NULL)
4889 printf ("already seen.\n");
4890 return;
4892 *slot = t;
4893 printf ("\n");
4895 dump_typekind (indent, t->kind);
4896 printf ("%*cpointer_to = %p\n", indent + INDENT, ' ',
4897 (void *) t->pointer_to);
4898 dump_gc_used (indent + INDENT, t->gc_used);
4899 switch (t->kind)
4901 case TYPE_SCALAR:
4902 printf ("%*cscalar_is_char = %s\n", indent + INDENT, ' ',
4903 t->u.scalar_is_char ? "true" : "false");
4904 break;
4905 case TYPE_STRING:
4906 case TYPE_CALLBACK:
4907 break;
4908 case TYPE_STRUCT:
4909 case TYPE_UNION:
4910 case TYPE_LANG_STRUCT:
4911 case TYPE_USER_STRUCT:
4912 dump_type_u_s (indent + INDENT, t);
4913 break;
4914 case TYPE_POINTER:
4915 printf ("%*cp:\n", indent + INDENT, ' ');
4916 dump_type (indent + INDENT, t->u.p);
4917 break;
4918 case TYPE_ARRAY:
4919 dump_type_u_a (indent + INDENT, t);
4920 break;
4921 default:
4922 gcc_unreachable ();
4924 printf ("%*cEnd of type at %p\n", indent, ' ', (void *) t);
4927 /* Dumps the pair P. */
4929 static void
4930 dump_pair (int indent, pair_p p)
4932 printf ("%*cpair: name = %s\n", indent, ' ', p->name);
4933 dump_type (indent, p->type);
4934 dump_fileloc (indent, p->line);
4935 dump_options (indent, p->opt);
4936 printf ("%*cEnd of pair %s\n", indent, ' ', p->name);
4939 /* Dumps the list of pairs PP. */
4941 static void
4942 dump_pair_list (const char *name, pair_p pp)
4944 pair_p p;
4945 printf ("%s:\n", name);
4946 for (p = pp; p != NULL; p = p->next)
4947 dump_pair (0, p);
4948 printf ("End of %s\n\n", name);
4951 /* Dumps the STRUCTURES. */
4953 static void
4954 dump_structures (const char *name, type_p structures)
4956 printf ("%s:\n", name);
4957 dump_type_list (0, structures);
4958 printf ("End of %s\n\n", name);
4961 /* Dumps the internal structures of gengtype. This is useful to debug
4962 gengtype itself, or to understand what it does, e.g. for plugin
4963 developers. */
4965 static void
4966 dump_everything (void)
4968 dump_pair_list ("typedefs", typedefs);
4969 dump_structures ("structures", structures);
4970 dump_pair_list ("variables", variables);
4972 /* Allocated with the first call to dump_type. */
4973 htab_delete (seen_types);
4978 /* Option specification for getopt_long. */
4979 static const struct option gengtype_long_options[] = {
4980 {"help", no_argument, NULL, 'h'},
4981 {"version", no_argument, NULL, 'V'},
4982 {"verbose", no_argument, NULL, 'v'},
4983 {"dump", no_argument, NULL, 'd'},
4984 {"debug", no_argument, NULL, 'D'},
4985 {"plugin", required_argument, NULL, 'P'},
4986 {"srcdir", required_argument, NULL, 'S'},
4987 {"backupdir", required_argument, NULL, 'B'},
4988 {"inputs", required_argument, NULL, 'I'},
4989 {"read-state", required_argument, NULL, 'r'},
4990 {"write-state", required_argument, NULL, 'w'},
4991 /* Terminating NULL placeholder. */
4992 {NULL, no_argument, NULL, 0},
4996 static void
4997 print_usage (void)
4999 printf ("Usage: %s\n", progname);
5000 printf ("\t -h | --help " " \t# Give this help.\n");
5001 printf ("\t -D | --debug "
5002 " \t# Give debug output to debug %s itself.\n", progname);
5003 printf ("\t -V | --version " " \t# Give version information.\n");
5004 printf ("\t -v | --verbose \t# Increase verbosity. Can be given several times.\n");
5005 printf ("\t -d | --dump " " \t# Dump state for debugging.\n");
5006 printf ("\t -P | --plugin <output-file> <plugin-src> ... "
5007 " \t# Generate for plugin.\n");
5008 printf ("\t -S | --srcdir <GCC-directory> "
5009 " \t# Specify the GCC source directory.\n");
5010 printf ("\t -B | --backupdir <directory> "
5011 " \t# Specify the backup directory for updated files.\n");
5012 printf ("\t -I | --inputs <input-list> "
5013 " \t# Specify the file with source files list.\n");
5014 printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n");
5015 printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n");
5018 static void
5019 print_version (void)
5021 printf ("%s %s%s\n", progname, pkgversion_string, version_string);
5022 printf ("Report bugs: %s\n", bug_report_url);
5025 /* Parse the program options using getopt_long... */
5026 static void
5027 parse_program_options (int argc, char **argv)
5029 int opt = -1;
5030 while ((opt = getopt_long (argc, argv, "hVvdP:S:B:I:w:r:D",
5031 gengtype_long_options, NULL)) >= 0)
5033 switch (opt)
5035 case 'h': /* --help */
5036 print_usage ();
5037 break;
5038 case 'V': /* --version */
5039 print_version ();
5040 break;
5041 case 'd': /* --dump */
5042 do_dump = 1;
5043 break;
5044 case 'D': /* --debug */
5045 do_debug = 1;
5046 break;
5047 case 'v': /* --verbose */
5048 verbosity_level++;
5049 break;
5050 case 'P': /* --plugin */
5051 if (optarg)
5052 plugin_output_filename = optarg;
5053 else
5054 fatal ("missing plugin output file name");
5055 break;
5056 case 'S': /* --srcdir */
5057 if (optarg)
5058 srcdir = optarg;
5059 else
5060 fatal ("missing source directory");
5061 srcdir_len = strlen (srcdir);
5062 break;
5063 case 'B': /* --backupdir */
5064 if (optarg)
5065 backup_dir = optarg;
5066 else
5067 fatal ("missing backup directory");
5068 break;
5069 case 'I': /* --inputs */
5070 if (optarg)
5071 inputlist = optarg;
5072 else
5073 fatal ("missing input list");
5074 break;
5075 case 'r': /* --read-state */
5076 if (optarg)
5077 read_state_filename = optarg;
5078 else
5079 fatal ("missing read state file");
5080 DBGPRINTF ("read state %s\n", optarg);
5081 break;
5082 case 'w': /* --write-state */
5083 DBGPRINTF ("write state %s\n", optarg);
5084 if (optarg)
5085 write_state_filename = optarg;
5086 else
5087 fatal ("missing write state file");
5088 break;
5089 default:
5090 fprintf (stderr, "%s: unknown flag '%c'\n", progname, opt);
5091 print_usage ();
5092 fatal ("unexpected flag");
5095 if (plugin_output_filename)
5097 /* In plugin mode we require some input files. */
5098 int i = 0;
5099 if (optind >= argc)
5100 fatal ("no source files given in plugin mode");
5101 nb_plugin_files = argc - optind;
5102 plugin_files = XNEWVEC (input_file*, nb_plugin_files);
5103 for (i = 0; i < (int) nb_plugin_files; i++)
5105 char *name = argv[i + optind];
5106 plugin_files[i] = input_file_by_name (name);
5113 /******* Manage input files. ******/
5115 /* Hash table of unique input file names. */
5116 static htab_t input_file_htab;
5118 /* Find or allocate a new input_file by hash-consing it. */
5119 input_file*
5120 input_file_by_name (const char* name)
5122 void ** slot;
5123 input_file* f = NULL;
5124 int namlen = 0;
5125 if (!name)
5126 return NULL;
5127 namlen = strlen (name);
5128 f = XCNEWVAR (input_file, sizeof (input_file)+namlen+2);
5129 f->inpbitmap = 0;
5130 f->inpoutf = NULL;
5131 f->inpisplugin = false;
5132 strcpy (f->inpname, name);
5133 slot = htab_find_slot (input_file_htab, f, INSERT);
5134 gcc_assert (slot != NULL);
5135 if (*slot)
5137 /* Already known input file. */
5138 free (f);
5139 return (input_file*)(*slot);
5141 /* New input file. */
5142 *slot = f;
5143 return f;
5146 /* Hash table support routines for input_file-s. */
5147 static hashval_t
5148 htab_hash_inputfile (const void *p)
5150 const input_file *inpf = (const input_file *) p;
5151 gcc_assert (inpf);
5152 return htab_hash_string (get_input_file_name (inpf));
5155 static int
5156 htab_eq_inputfile (const void *x, const void *y)
5158 const input_file *inpfx = (const input_file *) x;
5159 const input_file *inpfy = (const input_file *) y;
5160 gcc_assert (inpfx != NULL && inpfy != NULL);
5161 return !filename_cmp (get_input_file_name (inpfx), get_input_file_name (inpfy));
5166 main (int argc, char **argv)
5168 size_t i;
5169 static struct fileloc pos = { NULL, 0 };
5170 outf_p output_header;
5172 /* Mandatory common initializations. */
5173 progname = "gengtype"; /* For fatal and messages. */
5174 /* Create the hash-table used to hash-cons input files. */
5175 input_file_htab =
5176 htab_create (800, htab_hash_inputfile, htab_eq_inputfile, NULL);
5177 /* Initialize our special input files. */
5178 this_file = input_file_by_name (__FILE__);
5179 system_h_file = input_file_by_name ("system.h");
5180 /* Set the scalar_is_char union number for predefined scalar types. */
5181 scalar_nonchar.u.scalar_is_char = FALSE;
5182 scalar_char.u.scalar_is_char = TRUE;
5184 parse_program_options (argc, argv);
5186 if (do_debug)
5188 time_t now = (time_t) 0;
5189 time (&now);
5190 DBGPRINTF ("gengtype started pid %d at %s",
5191 (int) getpid (), ctime (&now));
5194 /* Parse the input list and the input files. */
5195 DBGPRINTF ("inputlist %s", inputlist);
5196 if (read_state_filename)
5198 if (inputlist)
5199 fatal ("input list %s cannot be given with a read state file %s",
5200 inputlist, read_state_filename);
5201 read_state (read_state_filename);
5202 DBGPRINT_COUNT_TYPE ("structures after read_state", structures);
5204 else if (inputlist)
5206 /* These types are set up with #define or else outside of where
5207 we can see them. We should initialize them before calling
5208 read_input_list. */
5209 #define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \
5210 Call;} while (0)
5211 POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos));
5212 POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos));
5213 POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos));
5214 POS_HERE (do_scalar_typedef ("double_int", &pos));
5215 POS_HERE (do_scalar_typedef ("poly_int64_pod", &pos));
5216 POS_HERE (do_scalar_typedef ("offset_int", &pos));
5217 POS_HERE (do_scalar_typedef ("widest_int", &pos));
5218 POS_HERE (do_scalar_typedef ("int64_t", &pos));
5219 POS_HERE (do_scalar_typedef ("poly_int64", &pos));
5220 POS_HERE (do_scalar_typedef ("poly_uint64", &pos));
5221 POS_HERE (do_scalar_typedef ("uint64_t", &pos));
5222 POS_HERE (do_scalar_typedef ("uint32_t", &pos));
5223 POS_HERE (do_scalar_typedef ("uint8", &pos));
5224 POS_HERE (do_scalar_typedef ("uintptr_t", &pos));
5225 POS_HERE (do_scalar_typedef ("jword", &pos));
5226 POS_HERE (do_scalar_typedef ("JCF_u2", &pos));
5227 POS_HERE (do_scalar_typedef ("void", &pos));
5228 POS_HERE (do_scalar_typedef ("machine_mode", &pos));
5229 POS_HERE (do_scalar_typedef ("fixed_size_mode", &pos));
5230 POS_HERE (do_scalar_typedef ("CONSTEXPR", &pos));
5231 POS_HERE (do_typedef ("void *",
5232 create_pointer (resolve_typedef ("void", &pos)),
5233 &pos));
5234 #undef POS_HERE
5235 read_input_list (inputlist);
5236 num_build_headers = 0;
5237 for (i = 0; i < num_gt_files; i++)
5239 const char *fname = get_input_file_name (gt_files[i]);
5240 parse_file (fname);
5241 DBGPRINTF ("parsed file #%d %s", (int) i, fname);
5242 /* Check if this is a header file generated during the build. */
5243 int len = strlen (fname);
5244 if (len >= 5
5245 && fname[0] == '.'
5246 && IS_DIR_SEPARATOR (fname[1])
5247 && fname[len-2] == '.'
5248 && fname[len-1] == 'h')
5249 num_build_headers++;
5251 if (verbosity_level >= 1)
5252 printf ("%s parsed %d files with %d GTY types\n",
5253 progname, (int) num_gt_files, type_count);
5255 DBGPRINT_COUNT_TYPE ("structures after parsing", structures);
5257 else
5258 fatal ("either an input list or a read state file should be given");
5259 if (hit_error)
5260 return 1;
5263 if (plugin_output_filename)
5265 size_t ix = 0;
5266 /* In plugin mode, we should have read a state file, and have
5267 given at least one plugin file. */
5268 if (!read_state_filename)
5269 fatal ("No read state given in plugin mode for %s",
5270 plugin_output_filename);
5272 if (nb_plugin_files == 0 || !plugin_files)
5273 fatal ("No plugin files given in plugin mode for %s",
5274 plugin_output_filename);
5276 /* Parse our plugin files and augment the state. */
5277 for (ix = 0; ix < nb_plugin_files; ix++)
5279 input_file* pluginput = plugin_files [ix];
5280 pluginput->inpisplugin = true;
5281 parse_file (get_input_file_name (pluginput));
5283 if (hit_error)
5284 return 1;
5286 plugin_output = create_file ("GCC", plugin_output_filename);
5287 DBGPRINTF ("created plugin_output %p named %s",
5288 (void *) plugin_output, plugin_output->name);
5290 else
5291 { /* No plugin files, we are in normal mode. */
5292 if (!srcdir)
5293 fatal ("gengtype needs a source directory in normal mode");
5295 if (hit_error)
5296 return 1;
5298 gen_rtx_next ();
5300 set_gc_used (variables);
5302 for (type_p t = structures; t; t = t->next)
5304 bool for_user = false;
5305 for (options_p o = t->u.s.opt; o; o = o->next)
5306 if (strcmp (o->name, "for_user") == 0)
5308 for_user = true;
5309 break;
5312 if (for_user)
5313 set_gc_used_type (t, GC_POINTED_TO);
5315 /* The state at this point is read from the state input file or by
5316 parsing source files and optionally augmented by parsing plugin
5317 source files. Write it now. */
5318 if (write_state_filename)
5320 DBGPRINT_COUNT_TYPE ("structures before write_state", structures);
5322 if (hit_error)
5323 fatal ("didn't write state file %s after errors",
5324 write_state_filename);
5326 DBGPRINTF ("before write_state %s", write_state_filename);
5327 write_state (write_state_filename);
5329 if (do_dump)
5330 dump_everything ();
5332 /* After having written the state file we return immediately to
5333 avoid generating any output file. */
5334 if (hit_error)
5335 return 1;
5336 else
5337 return 0;
5341 open_base_files ();
5343 output_header = plugin_output ? plugin_output : header_file;
5344 DBGPRINT_COUNT_TYPE ("structures before write_types outputheader",
5345 structures);
5347 write_types (output_header, structures, &ggc_wtd);
5348 if (plugin_files == NULL)
5350 DBGPRINT_COUNT_TYPE ("structures before write_types headerfil",
5351 structures);
5352 write_types (header_file, structures, &pch_wtd);
5353 write_local (header_file, structures);
5355 write_roots (variables, plugin_files == NULL);
5356 write_rtx_next ();
5357 close_output_files ();
5359 if (do_dump)
5360 dump_everything ();
5362 /* Don't bother about free-ing any input or plugin file, etc. */
5364 if (hit_error)
5365 return 1;
5366 return 0;