1 /* Process source files and output type information.
2 Copyright (C) 2002-2017 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
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
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
22 #define GENERATOR_FILE 1
27 #include "errors.h" /* for fatal */
29 #include "version.h" /* for version_string & pkgversion_string. */
33 #include "filenames.h"
35 /* Data types, macros, etc. used only in this file. */
38 /* The list of output files. */
41 /* The output header file that is included into pretty much every
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. */
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. */
70 /* Level for verbose messages. */
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. */
107 error_at_line (const struct fileloc
*pos
, const char *msg
, ...)
111 gcc_assert (pos
!= NULL
&& pos
->file
!= NULL
);
114 fprintf (stderr
, "%s:%d: ", get_input_file_name (pos
->file
), pos
->line
);
115 vfprintf (stderr
, msg
, ap
);
116 fputc ('\n', stderr
);
122 /* Locate the ultimate base class of struct S. */
125 get_ultimate_base_class (const_type_p s
)
127 while (s
->u
.s
.base_class
)
128 s
= s
->u
.s
.base_class
;
133 get_ultimate_base_class (type_p s
)
135 while (s
->u
.s
.base_class
)
136 s
= s
->u
.s
.base_class
;
140 /* Input file handling. */
142 /* Table of all input files. */
143 const input_file
**gt_files
;
146 /* A number of places use the name of this "gengtype.c" file for a
147 location for things that we can't rely on the source to define.
148 Make sure we can still use pointer comparison on filenames. */
149 input_file
* this_file
;
150 /* The "system.h" file is likewise specially useful. */
151 input_file
* system_h_file
;
153 /* Vector of per-language directories. */
154 const char **lang_dir_names
;
155 size_t num_lang_dirs
;
157 /* An array of output files suitable for definitions. There is one
158 BASE_FILES entry for each language. */
159 static outf_p
*base_files
;
161 /* Utility debugging function, printing the various type counts within
162 a list of types. Called through the DBGPRINT_COUNT_TYPE macro. */
164 dbgprint_count_type_at (const char *fil
, int lin
, const char *msg
, type_p t
)
166 int nb_types
= 0, nb_scalar
= 0, nb_string
= 0;
167 int nb_struct
= 0, nb_union
= 0, nb_array
= 0, nb_pointer
= 0;
168 int nb_lang_struct
= 0;
169 int nb_user_struct
= 0, nb_undefined
= 0;
171 for (p
= t
; p
; p
= p
->next
)
188 case TYPE_USER_STRUCT
:
200 case TYPE_LANG_STRUCT
:
207 fprintf (stderr
, "\n" "%s:%d: %s: @@%%@@ %d types ::\n",
208 lbasename (fil
), lin
, msg
, nb_types
);
209 if (nb_scalar
> 0 || nb_string
> 0)
210 fprintf (stderr
, "@@%%@@ %d scalars, %d strings\n", nb_scalar
, nb_string
);
211 if (nb_struct
> 0 || nb_union
> 0)
212 fprintf (stderr
, "@@%%@@ %d structs, %d unions\n", nb_struct
, nb_union
);
213 if (nb_pointer
> 0 || nb_array
> 0)
214 fprintf (stderr
, "@@%%@@ %d pointers, %d arrays\n", nb_pointer
, nb_array
);
215 if (nb_lang_struct
> 0)
216 fprintf (stderr
, "@@%%@@ %d lang_structs\n", nb_lang_struct
);
217 if (nb_user_struct
> 0)
218 fprintf (stderr
, "@@%%@@ %d user_structs\n", nb_user_struct
);
219 if (nb_undefined
> 0)
220 fprintf (stderr
, "@@%%@@ %d undefined types\n", nb_undefined
);
221 fprintf (stderr
, "\n");
224 /* Scan the input file, LIST, and determine how much space we need to
225 store strings in. Also, count the number of language directories
226 and files. The numbers returned are overestimates as they does not
227 consider repeated files. */
229 measure_input_list (FILE *list
)
235 num_gt_files
= plugin_files
? nb_plugin_files
: 0;
236 while ((c
= getc (list
)) != EOF
)
245 /* Add space for a lang_bitmap before the input file name. */
246 n
+= sizeof (lang_bitmap
);
260 /* Read one input line from LIST to HEREP (which is updated). A
261 pointer to the string is returned via LINEP. If it was a language
262 subdirectory in square brackets, strip off the square brackets and
263 return true. Otherwise, leave space before the string for a
264 lang_bitmap, and return false. At EOF, returns false, does not
265 touch *HEREP, and sets *LINEP to NULL. POS is used for
268 read_input_line (FILE *list
, char **herep
, char **linep
, struct fileloc
*pos
)
274 /* Read over whitespace. */
275 while (c
== '\n' || c
== ' ')
285 /* No space for a lang_bitmap is necessary. Discard the '['. */
288 while (c
!= ']' && c
!= '\n' && c
!= EOF
)
297 c
= getc (list
); /* eat what should be a newline */
298 if (c
!= '\n' && c
!= EOF
)
299 error_at_line (pos
, "junk on line after language tag [%s]", line
);
302 error_at_line (pos
, "missing close bracket for language tag [%s",
311 /* Leave space for a lang_bitmap. */
312 memset (here
, 0, sizeof (lang_bitmap
));
313 here
+= sizeof (lang_bitmap
);
320 while (c
!= EOF
&& c
!= '\n');
328 /* Read the list of input files from LIST and compute all of the
329 relevant tables. There is one file per line of the list. At
330 first, all the files on the list are language-generic, but
331 eventually a line will appear which is the name of a language
332 subdirectory in square brackets, like this: [cp]. All subsequent
333 files are specific to that language, until another language
334 subdirectory tag appears. Files can appear more than once, if
335 they apply to more than one language. */
337 read_input_list (const char *listname
)
339 FILE *list
= fopen (listname
, "r");
341 fatal ("cannot open %s: %s", listname
, xstrerror (errno
));
345 size_t bufsz
= measure_input_list (list
);
346 char *buf
= XNEWVEC (char, bufsz
);
348 char *committed
= buf
;
349 char *limit
= buf
+ bufsz
;
354 lang_bitmap curlangs
= (1 << num_lang_dirs
) - 1;
356 epos
.file
= input_file_by_name (listname
);
359 lang_dir_names
= XNEWVEC (const char *, num_lang_dirs
);
360 gt_files
= XNEWVEC (const input_file
*, num_gt_files
);
367 is_language
= read_input_line (list
, &here
, &line
, &epos
);
368 gcc_assert (here
<= limit
);
371 else if (is_language
)
374 gcc_assert (langno
<= num_lang_dirs
);
375 for (i
= 0; i
< langno
; i
++)
376 if (strcmp (lang_dir_names
[i
], line
) == 0)
378 error_at_line (&epos
, "duplicate language tag [%s]",
385 curlangs
= 1 << langno
;
386 lang_dir_names
[langno
++] = line
;
391 input_file
*inpf
= input_file_by_name (line
);
392 gcc_assert (nfiles
<= num_gt_files
);
393 for (i
= 0; i
< nfiles
; i
++)
394 /* Since the input_file-s are uniquely hash-consed, we
395 can just compare pointers! */
396 if (gt_files
[i
] == inpf
)
398 /* Throw away the string we just read, and add the
399 current language to the existing string's bitmap. */
400 lang_bitmap bmap
= get_lang_bitmap (inpf
);
402 error_at_line (&epos
,
403 "file %s specified more than once "
404 "for language %s", line
,
406 0 ? "(all)" : lang_dir_names
[langno
-
410 set_lang_bitmap (inpf
, bmap
);
415 set_lang_bitmap (inpf
, curlangs
);
416 gt_files
[nfiles
++] = inpf
;
419 /* Update the global counts now that we know accurately how many
420 things there are. (We do not bother resizing the arrays down.) */
421 num_lang_dirs
= langno
;
422 /* Add the plugin files if provided. */
426 for (i
= 0; i
< nb_plugin_files
; i
++)
427 gt_files
[nfiles
++] = plugin_files
[i
];
429 num_gt_files
= nfiles
;
432 /* Sanity check: any file that resides in a language subdirectory
433 (e.g. 'cp') ought to belong to the corresponding language.
434 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
435 (Can you even do that? Should you be allowed to?) */
438 for (f
= 0; f
< num_gt_files
; f
++)
440 lang_bitmap bitmap
= get_lang_bitmap (gt_files
[f
]);
441 const char *basename
= get_file_basename (gt_files
[f
]);
442 const char *slashpos
= strchr (basename
, '/');
443 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
444 const char *slashpos2
= strchr (basename
, '\\');
446 if (!slashpos
|| (slashpos2
&& slashpos2
< slashpos
))
447 slashpos
= slashpos2
;
453 for (l
= 0; l
< num_lang_dirs
; l
++)
454 if ((size_t) (slashpos
- basename
) == strlen (lang_dir_names
[l
])
455 && memcmp (basename
, lang_dir_names
[l
],
456 strlen (lang_dir_names
[l
])) == 0)
458 if (!(bitmap
& (1 << l
)))
459 error ("%s is in language directory '%s' but is not "
460 "tagged for that language",
461 basename
, lang_dir_names
[l
]);
469 fatal ("error reading %s: %s", listname
, xstrerror (errno
));
476 /* The one and only TYPE_STRING. */
478 struct type string_type
= {
479 TYPE_STRING
, 0, 0, 0, GC_USED
, {0}
482 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
483 set early in main. */
485 struct type scalar_nonchar
= {
486 TYPE_SCALAR
, 0, 0, 0, GC_USED
, {0}
489 struct type scalar_char
= {
490 TYPE_SCALAR
, 0, 0, 0, GC_USED
, {0}
493 /* Lists of various things. */
495 pair_p typedefs
= NULL
;
496 type_p structures
= NULL
;
497 pair_p variables
= NULL
;
499 static type_p
adjust_field_tree_exp (type_p t
, options_p opt
);
500 static type_p
adjust_field_rtx_def (type_p t
, options_p opt
);
502 /* Define S as a typedef to T at POS. */
505 do_typedef (const char *s
, type_p t
, struct fileloc
*pos
)
509 /* temporary kludge - gengtype doesn't handle conditionals or
510 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
511 is coming from this file (main() sets them up with safe dummy
513 if (!strcmp (s
, "CUMULATIVE_ARGS") && pos
->file
!= this_file
)
516 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
517 if (strcmp (p
->name
, s
) == 0)
519 if (p
->type
!= t
&& strcmp (s
, "result_type") != 0)
521 error_at_line (pos
, "type `%s' previously defined", s
);
522 error_at_line (&p
->line
, "previously defined here");
527 p
= XNEW (struct pair
);
536 /* Define S as a typename of a scalar. Cannot be used to define
537 typedefs of 'char'. Note: is also used for pointer-to-function
538 typedefs (which are therefore not treated as pointers). */
541 do_scalar_typedef (const char *s
, struct fileloc
*pos
)
543 do_typedef (s
, &scalar_nonchar
, pos
);
546 /* Similar to strtok_r. */
549 strtoken (char *str
, const char *delim
, char **next
)
556 /* Skip the leading delimiters. */
557 str
+= strspn (str
, delim
);
559 /* This is an empty token. */
562 /* The current token. */
565 /* Find the next delimiter. */
566 str
+= strcspn (str
, delim
);
568 /* This is the last token. */
572 /* Terminate the current token. */
574 /* Advance to the next token. */
581 /* Define TYPE_NAME to be a user defined type at location POS. */
584 create_user_defined_type (const char *type_name
, struct fileloc
*pos
)
586 type_p ty
= find_structure (type_name
, TYPE_USER_STRUCT
);
588 /* We might have already seen an incomplete decl of the given type,
589 in which case we won't have yet seen a GTY((user)), and the type will
590 only have kind "TYPE_STRUCT". Mark it as a user struct. */
591 ty
->kind
= TYPE_USER_STRUCT
;
594 ty
->u
.s
.bitmap
= get_lang_bitmap (pos
->file
);
595 do_typedef (type_name
, ty
, pos
);
597 /* If TYPE_NAME specifies a template, create references to the types
598 in the template by pretending that each type is a field of TY.
599 This is needed to make sure that the types referenced by the
600 template are marked as used. */
601 char *str
= xstrdup (type_name
);
602 char *open_bracket
= strchr (str
, '<');
605 /* We only accept simple template declarations (see
606 require_template_declaration), so we only need to parse a
607 comma-separated list of strings, implicitly assumed to
608 be type names, potentially with "*" characters. */
609 char *arg
= open_bracket
+ 1;
610 /* Workaround -Wmaybe-uninitialized false positive during
611 profiledbootstrap by initializing it. */
613 char *type_id
= strtoken (arg
, ",>", &next
);
617 /* Create a new field for every type found inside the template
620 /* Support a single trailing "*" character. */
621 const char *star
= strchr (type_id
, '*');
622 int is_ptr
= (star
!= NULL
);
623 size_t offset_to_star
= star
- type_id
;
625 offset_to_star
= star
- type_id
;
627 if (strstr (type_id
, "char*"))
629 type_id
= strtoken (0, ",>", &next
);
633 char *field_name
= xstrdup (type_id
);
638 /* Strip off the first '*' character (and any subsequent text). */
639 *(field_name
+ offset_to_star
) = '\0';
641 arg_type
= find_structure (field_name
, TYPE_STRUCT
);
642 arg_type
= create_pointer (arg_type
);
645 arg_type
= resolve_typedef (field_name
, pos
);
647 fields
= create_field_at (fields
, arg_type
, field_name
, 0, pos
);
648 type_id
= strtoken (0, ",>", &next
);
651 /* Associate the field list to TY. */
652 ty
->u
.s
.fields
= fields
;
660 /* Given a typedef name S, return its associated type. Return NULL if
661 S is not a registered type name. */
664 type_for_name (const char *s
)
668 /* Special-case support for types within a "gcc::" namespace. Rather
669 than fully-supporting namespaces, simply strip off the "gcc::" prefix
670 where present. This allows us to have GTY roots of this form:
671 extern GTY(()) gcc::some_type *some_ptr;
672 where the autogenerated functions will refer to simply "some_type",
673 where they can be resolved into their namespace. */
674 if (strncmp (s
, "gcc::", 5) == 0)
677 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
678 if (strcmp (p
->name
, s
) == 0)
684 /* Create an undefined type with name S and location POS. Return the
685 newly created type. */
688 create_undefined_type (const char *s
, struct fileloc
*pos
)
690 type_p ty
= find_structure (s
, TYPE_UNDEFINED
);
692 ty
->u
.s
.bitmap
= get_lang_bitmap (pos
->file
);
693 do_typedef (s
, ty
, pos
);
698 /* Return the type previously defined for S. Use POS to report errors. */
701 resolve_typedef (const char *s
, struct fileloc
*pos
)
703 bool is_template_instance
= (strchr (s
, '<') != NULL
);
704 type_p p
= type_for_name (s
);
706 /* If we did not find a typedef registered, generate a TYPE_UNDEFINED
707 type for regular type identifiers. If the type identifier S is a
708 template instantiation, however, we treat it as a user defined
711 FIXME, this is actually a limitation in gengtype. Supporting
712 template types and their instances would require keeping separate
713 track of the basic types definition and its instances. This
714 essentially forces all template classes in GC to be marked
717 p
= (is_template_instance
)
718 ? create_user_defined_type (s
, pos
)
719 : create_undefined_type (s
, pos
);
724 /* Add SUBCLASS to head of linked list of BASE's subclasses. */
726 void add_subclass (type_p base
, type_p subclass
)
728 gcc_assert (union_or_struct_p (base
));
729 gcc_assert (union_or_struct_p (subclass
));
731 subclass
->u
.s
.next_sibling_class
= base
->u
.s
.first_subclass
;
732 base
->u
.s
.first_subclass
= subclass
;
735 /* Create and return a new structure with tag NAME at POS with fields
736 FIELDS and options O. The KIND of structure must be one of
737 TYPE_STRUCT, TYPE_UNION or TYPE_USER_STRUCT. */
740 new_structure (const char *name
, enum typekind kind
, struct fileloc
*pos
,
741 pair_p fields
, options_p o
, type_p base_class
)
745 lang_bitmap bitmap
= get_lang_bitmap (pos
->file
);
746 bool isunion
= (kind
== TYPE_UNION
);
747 type_p
*p
= &structures
;
749 gcc_assert (union_or_struct_p (kind
));
751 for (si
= structures
; si
!= NULL
; p
= &si
->next
, si
= *p
)
752 if (strcmp (name
, si
->u
.s
.tag
) == 0 && UNION_P (si
) == isunion
)
755 if (si
->kind
== TYPE_LANG_STRUCT
)
759 for (si
= ls
->u
.s
.lang_struct
; si
!= NULL
; si
= si
->next
)
760 if (si
->u
.s
.bitmap
== bitmap
)
763 else if (si
->u
.s
.line
.file
!= NULL
&& si
->u
.s
.bitmap
!= bitmap
)
767 si
= XCNEW (struct type
);
768 memcpy (si
, ls
, sizeof (struct type
));
769 ls
->kind
= TYPE_LANG_STRUCT
;
770 ls
->u
.s
.lang_struct
= si
;
771 ls
->u
.s
.fields
= NULL
;
773 si
->state_number
= -type_count
;
774 si
->pointer_to
= NULL
;
775 si
->u
.s
.lang_struct
= ls
;
780 if (ls
!= NULL
&& s
== NULL
)
783 s
= XCNEW (struct type
);
784 s
->state_number
= -type_count
;
785 s
->next
= ls
->u
.s
.lang_struct
;
786 ls
->u
.s
.lang_struct
= s
;
787 s
->u
.s
.lang_struct
= ls
;
795 s
= XCNEW (struct type
);
796 s
->state_number
= -type_count
;
800 if (s
->u
.s
.lang_struct
&& (s
->u
.s
.lang_struct
->u
.s
.bitmap
& bitmap
))
802 error_at_line (pos
, "duplicate definition of '%s %s'",
803 isunion
? "union" : "struct", s
->u
.s
.tag
);
804 error_at_line (&s
->u
.s
.line
, "previous definition here");
810 s
->u
.s
.fields
= fields
;
812 s
->u
.s
.bitmap
= bitmap
;
813 if (s
->u
.s
.lang_struct
)
814 s
->u
.s
.lang_struct
->u
.s
.bitmap
|= bitmap
;
815 s
->u
.s
.base_class
= base_class
;
817 add_subclass (base_class
, s
);
822 /* Return the previously-defined structure or union with tag NAME,
823 or a new empty structure or union if none was defined previously.
824 The KIND of structure must be one of TYPE_STRUCT, TYPE_UNION or
828 find_structure (const char *name
, enum typekind kind
)
831 bool isunion
= (kind
== TYPE_UNION
);
832 type_p
*p
= &structures
;
834 gcc_assert (kind
== TYPE_UNDEFINED
|| union_or_struct_p (kind
));
836 for (s
= structures
; s
!= NULL
; p
= &s
->next
, s
= *p
)
837 if (strcmp (name
, s
->u
.s
.tag
) == 0 && UNION_P (s
) == isunion
)
841 s
= XCNEW (struct type
);
842 s
->state_number
= -type_count
;
849 /* Return a scalar type with name NAME. */
852 create_scalar_type (const char *name
)
854 if (!strcmp (name
, "char") || !strcmp (name
, "unsigned char"))
857 return &scalar_nonchar
;
861 /* Return a pointer to T. */
864 create_pointer (type_p t
)
868 type_p r
= XCNEW (struct type
);
870 r
->state_number
= -type_count
;
871 r
->kind
= TYPE_POINTER
;
875 return t
->pointer_to
;
878 /* Return an array of length LEN. */
881 create_array (type_p t
, const char *len
)
886 v
= XCNEW (struct type
);
887 v
->kind
= TYPE_ARRAY
;
888 v
->state_number
= -type_count
;
894 /* Return a string options structure with name NAME and info INFO.
895 NEXT is the next option in the chain. */
897 create_string_option (options_p next
, const char *name
, const char *info
)
899 options_p o
= XNEW (struct options
);
900 o
->kind
= OPTION_STRING
;
903 o
->info
.string
= info
;
907 /* Create a type options structure with name NAME and info INFO. NEXT
908 is the next option in the chain. */
910 create_type_option (options_p next
, const char* name
, type_p info
)
912 options_p o
= XNEW (struct options
);
915 o
->kind
= OPTION_TYPE
;
920 /* Create a nested pointer options structure with name NAME and info
921 INFO. NEXT is the next option in the chain. */
923 create_nested_option (options_p next
, const char* name
,
924 struct nested_ptr_data
* info
)
927 o
= XNEW (struct options
);
930 o
->kind
= OPTION_NESTED
;
931 o
->info
.nested
= info
;
935 /* Return an options structure for a "nested_ptr" option. */
937 create_nested_ptr_option (options_p next
, type_p t
,
938 const char *to
, const char *from
)
940 struct nested_ptr_data
*d
= XNEW (struct nested_ptr_data
);
942 d
->type
= adjust_field_type (t
, 0);
944 d
->convert_from
= from
;
945 return create_nested_option (next
, "nested_ptr", d
);
948 /* Add a variable named S of type T with options O defined at POS,
951 note_variable (const char *s
, type_p t
, options_p o
, struct fileloc
*pos
)
954 n
= XNEW (struct pair
);
963 /* Most-general structure field creator. */
965 create_field_all (pair_p next
, type_p type
, const char *name
, options_p opt
,
966 const input_file
*inpf
, int line
)
970 field
= XNEW (struct pair
);
975 field
->line
.file
= inpf
;
976 field
->line
.line
= line
;
980 /* Create a field that came from the source code we are scanning,
981 i.e. we have a 'struct fileloc', and possibly options; also,
982 adjust_field_type should be called. */
984 create_field_at (pair_p next
, type_p type
, const char *name
, options_p opt
,
987 return create_field_all (next
, adjust_field_type (type
, opt
),
988 name
, opt
, pos
->file
, pos
->line
);
991 /* Create a fake field with the given type and name. NEXT is the next
992 field in the chain. */
993 #define create_field(next,type,name) \
994 create_field_all (next,type,name, 0, this_file, __LINE__)
996 /* Like create_field, but the field is only valid when condition COND
1000 create_optional_field_ (pair_p next
, type_p type
, const char *name
,
1001 const char *cond
, int line
)
1004 pair_p union_fields
;
1007 /* Create a fake union type with a single nameless field of type TYPE.
1008 The field has a tag of "1". This allows us to make the presence
1009 of a field of type TYPE depend on some boolean "desc" being true. */
1010 union_fields
= create_field (NULL
, type
, "");
1012 create_string_option (union_fields
->opt
, "dot", "");
1014 create_string_option (union_fields
->opt
, "tag", "1");
1016 new_structure (xasprintf ("%s_%d", "fake_union", id
++), TYPE_UNION
,
1017 &lexer_line
, union_fields
, NULL
, NULL
);
1019 /* Create the field and give it the new fake union type. Add a "desc"
1020 tag that specifies the condition under which the field is valid. */
1021 return create_field_all (next
, union_type
, name
,
1022 create_string_option (0, "desc", cond
),
1026 #define create_optional_field(next,type,name,cond) \
1027 create_optional_field_(next,type,name,cond,__LINE__)
1029 /* Reverse a linked list of 'struct pair's in place. */
1031 nreverse_pairs (pair_p list
)
1033 pair_p prev
= 0, p
, next
;
1034 for (p
= list
; p
; p
= next
)
1044 /* We don't care how long a CONST_DOUBLE is. */
1045 #define CONST_DOUBLE_FORMAT "ww"
1046 /* We don't want to see codes that are only for generator files. */
1047 #undef GENERATOR_FILE
1051 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
1057 static const char *const rtx_name
[NUM_RTX_CODE
] = {
1058 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
1063 static const char *const rtx_format
[NUM_RTX_CODE
] = {
1064 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
1069 static int rtx_next_new
[NUM_RTX_CODE
];
1071 /* We also need codes and names for insn notes (not register notes).
1072 Note that we do *not* bias the note values here. */
1075 #define DEF_INSN_NOTE(NAME) NAME,
1076 #include "insn-notes.def"
1077 #undef DEF_INSN_NOTE
1082 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
1083 default field for line number notes. */
1084 static const char *const note_insn_name
[NOTE_INSN_MAX
+ 1] = {
1085 #define DEF_INSN_NOTE(NAME) #NAME,
1086 #include "insn-notes.def"
1087 #undef DEF_INSN_NOTE
1090 #undef CONST_DOUBLE_FORMAT
1091 #define GENERATOR_FILE
1093 /* Generate the contents of the rtx_next array. This really doesn't belong
1094 in gengtype at all, but it's needed for adjust_field_rtx_def. */
1100 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1104 rtx_next_new
[i
] = -1;
1105 if (strncmp (rtx_format
[i
], "uu", 2) == 0)
1106 rtx_next_new
[i
] = 1;
1107 else if (i
== COND_EXEC
|| i
== SET
|| i
== EXPR_LIST
|| i
== INSN_LIST
)
1108 rtx_next_new
[i
] = 1;
1110 for (k
= strlen (rtx_format
[i
]) - 1; k
>= 0; k
--)
1111 if (rtx_format
[i
][k
] == 'e' || rtx_format
[i
][k
] == 'u')
1112 rtx_next_new
[i
] = k
;
1116 /* Write out the contents of the rtx_next array. */
1118 write_rtx_next (void)
1120 outf_p f
= get_output_file_with_visibility (NULL
);
1125 oprintf (f
, "\n/* Used to implement the RTX_NEXT macro. */\n");
1126 oprintf (f
, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
1127 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1128 if (rtx_next_new
[i
] == -1)
1129 oprintf (f
, " 0,\n");
1132 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n", rtx_next_new
[i
]);
1133 oprintf (f
, "};\n");
1136 /* Handle `special("rtx_def")'. This is a special case for field
1137 `fld' of struct rtx_def, which is an array of unions whose values
1138 are based in a complex way on the type of RTL. */
1141 adjust_field_rtx_def (type_p t
, options_p
ARG_UNUSED (opt
))
1146 type_p rtx_tp
, rtvec_tp
, tree_tp
, mem_attrs_tp
, note_union_tp
, scalar_tp
;
1147 type_p basic_block_tp
, reg_attrs_tp
, constant_tp
, symbol_union_tp
;
1149 if (t
->kind
!= TYPE_UNION
)
1151 error_at_line (&lexer_line
,
1152 "special `rtx_def' must be applied to a union");
1153 return &string_type
;
1156 nodot
= create_string_option (NULL
, "dot", "");
1158 rtx_tp
= create_pointer (find_structure ("rtx_def", TYPE_STRUCT
));
1159 rtvec_tp
= create_pointer (find_structure ("rtvec_def", TYPE_STRUCT
));
1160 tree_tp
= create_pointer (find_structure ("tree_node", TYPE_UNION
));
1161 mem_attrs_tp
= create_pointer (find_structure ("mem_attrs", TYPE_STRUCT
));
1163 create_pointer (find_structure ("reg_attrs", TYPE_STRUCT
));
1165 create_pointer (find_structure ("basic_block_def", TYPE_STRUCT
));
1167 create_pointer (find_structure ("constant_descriptor_rtx", TYPE_STRUCT
));
1168 scalar_tp
= &scalar_nonchar
; /* rtunion int */
1171 pair_p note_flds
= NULL
;
1174 for (c
= 0; c
<= NOTE_INSN_MAX
; c
++)
1179 case NOTE_INSN_DELETED_LABEL
:
1180 case NOTE_INSN_DELETED_DEBUG_LABEL
:
1181 note_flds
= create_field (note_flds
, &string_type
, "rt_str");
1184 case NOTE_INSN_BLOCK_BEG
:
1185 case NOTE_INSN_BLOCK_END
:
1186 note_flds
= create_field (note_flds
, tree_tp
, "rt_tree");
1189 case NOTE_INSN_VAR_LOCATION
:
1190 case NOTE_INSN_CALL_ARG_LOCATION
:
1191 note_flds
= create_field (note_flds
, rtx_tp
, "rt_rtx");
1195 note_flds
= create_field (note_flds
, scalar_tp
, "rt_int");
1198 /* NOTE_INSN_MAX is used as the default field for line
1200 if (c
== NOTE_INSN_MAX
)
1202 create_string_option (nodot
, "default", "");
1205 create_string_option (nodot
, "tag", note_insn_name
[c
]);
1207 note_union_tp
= new_structure ("rtx_def_note_subunion", TYPE_UNION
,
1208 &lexer_line
, note_flds
, NULL
, NULL
);
1210 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1213 sym_flds
= create_field (NULL
, tree_tp
, "rt_tree");
1214 sym_flds
->opt
= create_string_option (nodot
, "default", "");
1215 sym_flds
= create_field (sym_flds
, constant_tp
, "rt_constant");
1216 sym_flds
->opt
= create_string_option (nodot
, "tag", "1");
1217 symbol_union_tp
= new_structure ("rtx_def_symbol_subunion", TYPE_UNION
,
1218 &lexer_line
, sym_flds
, NULL
, NULL
);
1220 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1222 pair_p subfields
= NULL
;
1223 size_t aindex
, nmindex
;
1228 for (aindex
= 0; aindex
< strlen (rtx_format
[i
]); aindex
++)
1231 const char *subname
;
1233 switch (rtx_format
[i
][aindex
])
1246 subname
= "rt_subreg";
1250 if (i
== MEM
&& aindex
== 1)
1251 t
= mem_attrs_tp
, subname
= "rt_mem";
1252 else if (i
== JUMP_INSN
&& aindex
== 7)
1253 t
= rtx_tp
, subname
= "rt_rtx";
1254 else if (i
== CODE_LABEL
&& aindex
== 4)
1255 t
= scalar_tp
, subname
= "rt_int";
1256 else if (i
== CODE_LABEL
&& aindex
== 3)
1257 t
= rtx_tp
, subname
= "rt_rtx";
1258 else if (i
== LABEL_REF
&& (aindex
== 1 || aindex
== 2))
1259 t
= rtx_tp
, subname
= "rt_rtx";
1260 else if (i
== NOTE
&& aindex
== 3)
1261 t
= note_union_tp
, subname
= "";
1262 else if (i
== NOTE
&& aindex
== 4)
1263 t
= scalar_tp
, subname
= "rt_int";
1264 else if (i
== NOTE
&& aindex
>= 6)
1265 t
= scalar_tp
, subname
= "rt_int";
1266 else if (i
== ADDR_DIFF_VEC
&& aindex
== 4)
1267 t
= scalar_tp
, subname
= "rt_int";
1268 else if (i
== VALUE
&& aindex
== 0)
1269 t
= scalar_tp
, subname
= "rt_int";
1270 else if (i
== DEBUG_EXPR
&& aindex
== 0)
1271 t
= tree_tp
, subname
= "rt_tree";
1272 else if (i
== SYMBOL_REF
&& aindex
== 1)
1273 t
= symbol_union_tp
, subname
= "";
1274 else if (i
== JUMP_TABLE_DATA
&& aindex
>= 4)
1275 t
= scalar_tp
, subname
= "rt_int";
1276 else if (i
== BARRIER
&& aindex
>= 2)
1277 t
= scalar_tp
, subname
= "rt_int";
1278 else if (i
== ENTRY_VALUE
&& aindex
== 0)
1279 t
= rtx_tp
, subname
= "rt_rtx";
1284 "rtx type `%s' has `0' in position %lu, can't handle",
1285 rtx_name
[i
], (unsigned long) aindex
);
1307 subname
= "rt_rtvec";
1312 subname
= "rt_tree";
1323 "rtx type `%s' has `%c' in position %lu, can't handle",
1324 rtx_name
[i
], rtx_format
[i
][aindex
],
1325 (unsigned long) aindex
);
1331 subfields
= create_field (subfields
, t
,
1332 xasprintf (".fld[%lu].%s",
1333 (unsigned long) aindex
,
1335 subfields
->opt
= nodot
;
1336 if (t
== note_union_tp
)
1338 create_string_option (subfields
->opt
, "desc",
1340 if (t
== symbol_union_tp
)
1342 create_string_option (subfields
->opt
, "desc",
1343 "CONSTANT_POOL_ADDRESS_P (&%0)");
1347 subfields
= create_field (subfields
, reg_attrs_tp
, "reg.attrs");
1349 if (i
== SYMBOL_REF
)
1351 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P
1353 type_p field_tp
= find_structure ("block_symbol", TYPE_STRUCT
);
1355 = create_optional_field (subfields
, field_tp
, "block_sym",
1356 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1359 sname
= xasprintf ("rtx_def_%s", rtx_name
[i
]);
1360 substruct
= new_structure (sname
, TYPE_STRUCT
, &lexer_line
, subfields
,
1363 ftag
= xstrdup (rtx_name
[i
]);
1364 for (nmindex
= 0; nmindex
< strlen (ftag
); nmindex
++)
1365 ftag
[nmindex
] = TOUPPER (ftag
[nmindex
]);
1366 flds
= create_field (flds
, substruct
, "");
1367 flds
->opt
= create_string_option (nodot
, "tag", ftag
);
1369 return new_structure ("rtx_def_subunion", TYPE_UNION
, &lexer_line
, flds
,
1373 /* Handle `special("tree_exp")'. This is a special case for
1374 field `operands' of struct tree_exp, which although it claims to contain
1375 pointers to trees, actually sometimes contains pointers to RTL too.
1376 Passed T, the old type of the field, and OPT its options. Returns
1377 a new type for the field. */
1380 adjust_field_tree_exp (type_p t
, options_p opt ATTRIBUTE_UNUSED
)
1385 if (t
->kind
!= TYPE_ARRAY
)
1387 error_at_line (&lexer_line
,
1388 "special `tree_exp' must be applied to an array");
1389 return &string_type
;
1392 nodot
= create_string_option (NULL
, "dot", "");
1394 flds
= create_field (NULL
, t
, "");
1395 flds
->opt
= create_string_option (nodot
, "length",
1396 "TREE_OPERAND_LENGTH ((tree) &%0)");
1397 flds
->opt
= create_string_option (flds
->opt
, "default", "");
1399 return new_structure ("tree_exp_subunion", TYPE_UNION
, &lexer_line
, flds
,
1403 /* Perform any special processing on a type T, about to become the type
1404 of a field. Return the appropriate type for the field.
1406 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1407 - Similarly for arrays of pointer-to-char;
1408 - Converts structures for which a parameter is provided to
1410 - Handles "special" options.
1414 adjust_field_type (type_p t
, options_p opt
)
1417 const int pointer_p
= t
->kind
== TYPE_POINTER
;
1419 for (; opt
; opt
= opt
->next
)
1420 if (strcmp (opt
->name
, "length") == 0)
1423 error_at_line (&lexer_line
, "duplicate `%s' option", opt
->name
);
1424 if (t
->u
.p
->kind
== TYPE_SCALAR
|| t
->u
.p
->kind
== TYPE_STRING
)
1426 error_at_line (&lexer_line
,
1427 "option `%s' may not be applied to "
1428 "arrays of atomic types", opt
->name
);
1432 else if (strcmp (opt
->name
, "special") == 0
1433 && opt
->kind
== OPTION_STRING
)
1435 const char *special_name
= opt
->info
.string
;
1436 if (strcmp (special_name
, "tree_exp") == 0)
1437 t
= adjust_field_tree_exp (t
, opt
);
1438 else if (strcmp (special_name
, "rtx_def") == 0)
1439 t
= adjust_field_rtx_def (t
, opt
);
1441 error_at_line (&lexer_line
, "unknown special `%s'", special_name
);
1445 && pointer_p
&& t
->u
.p
->kind
== TYPE_SCALAR
&& t
->u
.p
->u
.scalar_is_char
)
1446 return &string_type
;
1447 if (t
->kind
== TYPE_ARRAY
&& t
->u
.a
.p
->kind
== TYPE_POINTER
1448 && t
->u
.a
.p
->u
.p
->kind
== TYPE_SCALAR
1449 && t
->u
.a
.p
->u
.p
->u
.scalar_is_char
)
1450 return create_array (&string_type
, t
->u
.a
.len
);
1456 static void set_gc_used_type (type_p
, enum gc_used_enum
, bool = false);
1457 static void set_gc_used (pair_p
);
1459 /* Handle OPT for set_gc_used_type. */
1462 process_gc_options (options_p opt
, enum gc_used_enum level
, int *maybe_undef
,
1463 int *length
, int *skip
, type_p
*nested_ptr
)
1466 for (o
= opt
; o
; o
= o
->next
)
1467 if (strcmp (o
->name
, "ptr_alias") == 0 && level
== GC_POINTED_TO
1468 && o
->kind
== OPTION_TYPE
)
1469 set_gc_used_type (o
->info
.type
,
1471 else if (strcmp (o
->name
, "maybe_undef") == 0)
1473 else if (strcmp (o
->name
, "length") == 0)
1475 else if (strcmp (o
->name
, "skip") == 0)
1477 else if (strcmp (o
->name
, "nested_ptr") == 0
1478 && o
->kind
== OPTION_NESTED
)
1479 *nested_ptr
= ((const struct nested_ptr_data
*) o
->info
.nested
)->type
;
1483 /* Set the gc_used field of T to LEVEL, and handle the types it references.
1485 If ALLOWED_UNDEFINED_TYPES is true, types of kind TYPE_UNDEFINED
1486 are set to GC_UNUSED. Otherwise, an error is emitted for
1487 TYPE_UNDEFINED types. This is used to support user-defined
1488 template types with non-type arguments.
1490 For instance, when we parse a template type with enum arguments
1491 (e.g. MyType<AnotherType, EnumValue>), the parser created two
1492 artificial fields for 'MyType', one for 'AnotherType', the other
1493 one for 'EnumValue'.
1495 At the time that we parse this type we don't know that 'EnumValue'
1496 is really an enum value, so the parser creates a TYPE_UNDEFINED
1497 type for it. Since 'EnumValue' is never resolved to a known
1498 structure, it will stay with TYPE_UNDEFINED.
1500 Since 'MyType' is a TYPE_USER_STRUCT, we can simply ignore
1501 'EnumValue'. Generating marking code for it would cause
1502 compilation failures since the marking routines assumes that
1503 'EnumValue' is a type. */
1506 set_gc_used_type (type_p t
, enum gc_used_enum level
,
1507 bool allow_undefined_types
)
1509 if (t
->gc_used
>= level
)
1518 case TYPE_USER_STRUCT
:
1523 bool allow_undefined_field_types
= (t
->kind
== TYPE_USER_STRUCT
);
1525 process_gc_options (t
->u
.s
.opt
, level
, &dummy
, &dummy
, &dummy
,
1528 if (t
->u
.s
.base_class
)
1529 set_gc_used_type (t
->u
.s
.base_class
, level
, allow_undefined_types
);
1530 /* Anything pointing to a base class might actually be pointing
1532 for (type_p subclass
= t
->u
.s
.first_subclass
; subclass
;
1533 subclass
= subclass
->u
.s
.next_sibling_class
)
1534 set_gc_used_type (subclass
, level
, allow_undefined_types
);
1536 FOR_ALL_INHERITED_FIELDS(t
, f
)
1538 int maybe_undef
= 0;
1541 type_p nested_ptr
= NULL
;
1542 process_gc_options (f
->opt
, level
, &maybe_undef
, &length
, &skip
,
1545 if (nested_ptr
&& f
->type
->kind
== TYPE_POINTER
)
1546 set_gc_used_type (nested_ptr
, GC_POINTED_TO
);
1547 else if (length
&& f
->type
->kind
== TYPE_POINTER
)
1548 set_gc_used_type (f
->type
->u
.p
, GC_USED
);
1549 else if (maybe_undef
&& f
->type
->kind
== TYPE_POINTER
)
1550 set_gc_used_type (f
->type
->u
.p
, GC_MAYBE_POINTED_TO
);
1552 ; /* target type is not used through this field */
1554 set_gc_used_type (f
->type
, GC_USED
, allow_undefined_field_types
);
1559 case TYPE_UNDEFINED
:
1560 if (level
> GC_UNUSED
)
1562 if (!allow_undefined_types
)
1563 error_at_line (&t
->u
.s
.line
, "undefined type `%s'", t
->u
.s
.tag
);
1564 t
->gc_used
= GC_UNUSED
;
1569 set_gc_used_type (t
->u
.p
, GC_POINTED_TO
);
1573 set_gc_used_type (t
->u
.a
.p
, GC_USED
);
1576 case TYPE_LANG_STRUCT
:
1577 for (t
= t
->u
.s
.lang_struct
; t
; t
= t
->next
)
1578 set_gc_used_type (t
, level
);
1586 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1589 set_gc_used (pair_p variables
)
1593 for (p
= variables
; p
; p
= p
->next
)
1595 set_gc_used_type (p
->type
, GC_USED
);
1598 if (verbosity_level
>= 2)
1599 printf ("%s used %d GTY-ed variables\n", progname
, nbvars
);
1602 /* File mapping routines. For each input file, there is one output .c file
1603 (but some output files have many input files), and there is one .h file
1604 for the whole build. */
1606 /* Output file handling. */
1608 /* Create and return an outf_p for a new file for NAME, to be called
1612 create_file (const char *name
, const char *oname
)
1614 static const char *const hdr
[] = {
1615 " Copyright (C) 2004-2017 Free Software Foundation, Inc.\n",
1617 "This file is part of GCC.\n",
1619 "GCC is free software; you can redistribute it and/or modify it under\n",
1620 "the terms of the GNU General Public License as published by the Free\n",
1621 "Software Foundation; either version 3, or (at your option) any later\n",
1624 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1625 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1626 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1627 "for more details.\n",
1629 "You should have received a copy of the GNU General Public License\n",
1630 "along with GCC; see the file COPYING3. If not see\n",
1631 "<http://www.gnu.org/licenses/>. */\n",
1633 "/* This file is machine generated. Do not edit. */\n"
1638 gcc_assert (name
!= NULL
);
1639 gcc_assert (oname
!= NULL
);
1640 f
= XCNEW (struct outf
);
1641 f
->next
= output_files
;
1645 oprintf (f
, "/* Type information for %s.\n", name
);
1646 for (i
= 0; i
< ARRAY_SIZE (hdr
); i
++)
1647 oprintf (f
, "%s", hdr
[i
]);
1651 /* Print, like fprintf, to O.
1652 N.B. You might think this could be implemented more efficiently
1653 with vsnprintf(). Unfortunately, there are C libraries that
1654 provide that function but without the C99 semantics for its return
1655 value, making it impossible to know how much space is required. */
1657 oprintf (outf_p o
, const char *format
, ...)
1663 /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1668 va_start (ap
, format
);
1669 slength
= vasprintf (&s
, format
, ap
);
1670 if (s
== NULL
|| (int) slength
< 0)
1671 fatal ("out of memory");
1674 if (o
->bufused
+ slength
> o
->buflength
)
1676 size_t new_len
= o
->buflength
;
1683 while (o
->bufused
+ slength
>= new_len
);
1684 o
->buf
= XRESIZEVEC (char, o
->buf
, new_len
);
1685 o
->buflength
= new_len
;
1687 memcpy (o
->buf
+ o
->bufused
, s
, slength
);
1688 o
->bufused
+= slength
;
1692 /* Open the global header file and the language-specific header files. */
1695 open_base_files (void)
1699 if (nb_plugin_files
> 0 && plugin_files
)
1702 header_file
= create_file ("GCC", "gtype-desc.h");
1704 base_files
= XNEWVEC (outf_p
, num_lang_dirs
);
1706 for (i
= 0; i
< num_lang_dirs
; i
++)
1707 base_files
[i
] = create_file (lang_dir_names
[i
],
1708 xasprintf ("gtype-%s.h", lang_dir_names
[i
]));
1710 /* gtype-desc.c is a little special, so we create it here. */
1712 /* The order of files here matters very much. */
1713 static const char *const ifiles
[] = {
1714 "config.h", "system.h", "coretypes.h",
1715 "backend.h", "predict.h", "tree.h",
1716 "rtl.h", "gimple.h", "fold-const.h", "insn-codes.h", "splay-tree.h",
1717 "alias.h", "insn-config.h", "flags.h", "expmed.h", "dojump.h",
1718 "explow.h", "calls.h", "memmodel.h", "emit-rtl.h", "varasm.h",
1719 "stmt.h", "expr.h", "alloc-pool.h", "cselib.h", "insn-addr.h",
1720 "optabs.h", "libfuncs.h", "debug.h", "internal-fn.h", "gimple-fold.h",
1721 "tree-eh.h", "gimple-iterator.h", "gimple-ssa.h", "tree-cfg.h",
1722 "tree-vrp.h", "tree-phinodes.h", "ssa-iterators.h", "stringpool.h",
1723 "tree-ssanames.h", "tree-ssa-loop.h", "tree-ssa-loop-ivopts.h",
1724 "tree-ssa-loop-manip.h", "tree-ssa-loop-niter.h", "tree-into-ssa.h",
1725 "tree-dfa.h", "tree-ssa.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1726 "except.h", "output.h", "cfgloop.h", "target.h", "lto-streamer.h",
1727 "target-globals.h", "ipa-ref.h", "cgraph.h", "symbol-summary.h",
1728 "ipa-prop.h", "ipa-fnsummary.h", "dwarf2out.h", "omp-offload.h", NULL
1730 const char *const *ifp
;
1731 outf_p gtype_desc_c
;
1733 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1734 for (ifp
= ifiles
; *ifp
; ifp
++)
1735 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1737 /* Make sure we handle "cfun" specially. */
1738 oprintf (gtype_desc_c
, "\n/* See definition in function.h. */\n");
1739 oprintf (gtype_desc_c
, "#undef cfun\n");
1741 oprintf (gtype_desc_c
,
1743 "/* Types with a \"gcc::\" namespace have it stripped\n"
1744 " during gengtype parsing. Provide a \"using\" directive\n"
1745 " to ensure that the fully-qualified types are found. */\n"
1746 "using namespace gcc;\n");
1750 /* For INPF an input file, return the real basename of INPF, with all
1751 the directory components skipped. */
1754 get_file_realbasename (const input_file
*inpf
)
1756 return lbasename (get_input_file_name (inpf
));
1759 /* For INPF a filename, return the relative path to INPF from
1760 $(srcdir) if the latter is a prefix in INPF, NULL otherwise. */
1763 get_file_srcdir_relative_path (const input_file
*inpf
)
1765 const char *f
= get_input_file_name (inpf
);
1766 if (strlen (f
) > srcdir_len
1767 && IS_DIR_SEPARATOR (f
[srcdir_len
])
1768 && strncmp (f
, srcdir
, srcdir_len
) == 0)
1769 return f
+ srcdir_len
+ 1;
1774 /* For INPF an input_file, return the relative path to INPF from
1775 $(srcdir) if the latter is a prefix in INPF, or the real basename
1776 of INPF otherwise. */
1779 get_file_basename (const input_file
*inpf
)
1781 const char *srcdir_path
= get_file_srcdir_relative_path (inpf
);
1783 return (srcdir_path
!= NULL
) ? srcdir_path
: get_file_realbasename (inpf
);
1786 /* For F a filename, return the lang_dir_names relative index of the language
1787 directory that is a prefix in F, if any, -1 otherwise. */
1790 get_prefix_langdir_index (const char *f
)
1792 size_t f_len
= strlen (f
);
1795 for (lang_index
= 0; lang_index
< num_lang_dirs
; lang_index
++)
1797 const char *langdir
= lang_dir_names
[lang_index
];
1798 size_t langdir_len
= strlen (langdir
);
1800 if (f_len
> langdir_len
1801 && IS_DIR_SEPARATOR (f
[langdir_len
])
1802 && memcmp (f
, langdir
, langdir_len
) == 0)
1809 /* For INPF an input file, return the name of language directory where
1810 F is located, if any, NULL otherwise. */
1813 get_file_langdir (const input_file
*inpf
)
1815 /* Get the relative path to INPF from $(srcdir) and find the
1816 language by comparing the prefix with language directory names.
1817 If INPF is not even srcdir relative, no point in looking
1821 const char *srcdir_relative_path
= get_file_srcdir_relative_path (inpf
);
1824 if (!srcdir_relative_path
)
1827 lang_index
= get_prefix_langdir_index (srcdir_relative_path
);
1828 if (lang_index
< 0 && strncmp (srcdir_relative_path
, "c-family", 8) == 0)
1830 else if (lang_index
>= 0)
1831 r
= lang_dir_names
[lang_index
];
1838 /* The gt- output file name for INPF. */
1841 get_file_gtfilename (const input_file
*inpf
)
1843 /* Cook up an initial version of the gt- file name from the file real
1844 basename and the language name, if any. */
1846 const char *basename
= get_file_realbasename (inpf
);
1847 const char *langdir
= get_file_langdir (inpf
);
1850 (langdir
? xasprintf ("gt-%s-%s", langdir
, basename
)
1851 : xasprintf ("gt-%s", basename
));
1853 /* Then replace all non alphanumerics characters by '-' and change the
1854 extension to ".h". We expect the input filename extension was at least
1855 one character long. */
1859 for (; *s
!= '.'; s
++)
1860 if (!ISALNUM (*s
) && *s
!= '-')
1863 memcpy (s
, ".h", sizeof (".h"));
1868 /* Each input_file has its associated output file outf_p. The
1869 association is computed by the function
1870 get_output_file_with_visibility. The associated file is cached
1871 inside input_file in its inpoutf field, so is really computed only
1872 once. Associated output file paths (i.e. output_name-s) are
1873 computed by a rule based regexp machinery, using the files_rules
1874 array of struct file_rule_st. A for_name is also computed, giving
1875 the source file name for which the output_file is generated; it is
1876 often the last component of the input_file path. */
1880 Regexpr machinery to compute the output_name and for_name-s of each
1881 input_file. We have a sequence of file rules which gives the POSIX
1882 extended regular expression to match an input file path, and two
1883 transformed strings for the corresponding output_name and the
1884 corresponding for_name. The transformed string contain dollars: $0
1885 is replaced by the entire match, $1 is replaced by the substring
1886 matching the first parenthesis in the regexp, etc. And $$ is replaced
1887 by a single verbatim dollar. The rule order is important. The
1888 general case is last, and the particular cases should come before.
1889 An action routine can, when needed, update the out_name & for_name
1890 and/or return the appropriate output file. It is invoked only when a
1891 rule is triggered. When a rule is triggered, the output_name and
1892 for_name are computed using their transform string in while $$, $0,
1893 $1, ... are suitably replaced. If there is an action, it is called.
1894 In some few cases, the action can directly return the outf_p, but
1895 usually it just updates the output_name and for_name so should free
1896 them before replacing them. The get_output_file_with_visibility
1897 function creates an outf_p only once per each output_name, so it
1898 scans the output_files list for previously seen output file names.
1901 /* Signature of actions in file rules. */
1902 typedef outf_p (frul_actionrout_t
) (input_file
*, char**, char**);
1905 struct file_rule_st
{
1906 const char* frul_srcexpr
; /* Source string for regexp. */
1907 int frul_rflags
; /* Flags passed to regcomp, usually
1909 regex_t
* frul_re
; /* Compiled regular expression
1910 obtained by regcomp. */
1911 const char* frul_tr_out
; /* Transformation string for making
1912 * the output_name, with $1 ... $9 for
1913 * subpatterns and $0 for the whole
1914 * matched filename. */
1915 const char* frul_tr_for
; /* Tranformation string for making the
1917 frul_actionrout_t
* frul_action
; /* The action, if non null, is
1918 * called once the rule matches, on
1919 * the transformed out_name &
1920 * for_name. It could change them
1921 * and/or give the output file. */
1924 /* File rule action handling *.h files. */
1925 static outf_p
header_dot_h_frul (input_file
*, char**, char**);
1927 /* File rule action handling *.c files. */
1928 static outf_p
source_dot_c_frul (input_file
*, char**, char**);
1930 #define NULL_REGEX (regex_t*)0
1932 /* The prefix in our regexp-s matching the directory. */
1933 #define DIR_PREFIX_REGEX "^(([^/]*/)*)"
1935 #define NULL_FRULACT (frul_actionrout_t*)0
1937 /* The array of our rules governing file name generation. Rules order
1938 matters, so change with extreme care! */
1940 struct file_rule_st files_rules
[] = {
1941 /* The general rule assumes that files in subdirectories belong to a
1942 particular front-end, and files not in subdirectories are shared.
1943 The following rules deal with exceptions - files that are in
1944 subdirectories and yet are shared, and files that are top-level,
1945 but are not shared. */
1947 /* the c-family/ source directory is special. */
1948 { DIR_PREFIX_REGEX
"c-family/([[:alnum:]_-]*)\\.c$",
1949 REG_EXTENDED
, NULL_REGEX
,
1950 "gt-c-family-$3.h", "c-family/$3.c", NULL_FRULACT
},
1952 { DIR_PREFIX_REGEX
"c-family/([[:alnum:]_-]*)\\.h$",
1953 REG_EXTENDED
, NULL_REGEX
,
1954 "gt-c-family-$3.h", "c-family/$3.h", NULL_FRULACT
},
1956 /* Both c-lang.h & c-tree.h gives gt-c-c-decl.h for c-decl.c ! */
1957 { DIR_PREFIX_REGEX
"c/c-lang\\.h$",
1958 REG_EXTENDED
, NULL_REGEX
, "gt-c-c-decl.h", "c/c-decl.c", NULL_FRULACT
},
1960 { DIR_PREFIX_REGEX
"c/c-tree\\.h$",
1961 REG_EXTENDED
, NULL_REGEX
, "gt-c-c-decl.h", "c/c-decl.c", NULL_FRULACT
},
1963 /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.c ! */
1964 { DIR_PREFIX_REGEX
"cp/cp-tree\\.h$",
1965 REG_EXTENDED
, NULL_REGEX
,
1966 "gt-cp-tree.h", "cp/tree.c", NULL_FRULACT
},
1968 /* cp/decl.h & cp/decl.c gives gt-cp-decl.h for cp/decl.c ! */
1969 { DIR_PREFIX_REGEX
"cp/decl\\.[ch]$",
1970 REG_EXTENDED
, NULL_REGEX
,
1971 "gt-cp-decl.h", "cp/decl.c", NULL_FRULACT
},
1973 /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.c ! */
1974 { DIR_PREFIX_REGEX
"cp/name-lookup\\.h$",
1975 REG_EXTENDED
, NULL_REGEX
,
1976 "gt-cp-name-lookup.h", "cp/name-lookup.c", NULL_FRULACT
},
1978 /* cp/parser.h gives gt-cp-parser.h for cp/parser.c ! */
1979 { DIR_PREFIX_REGEX
"cp/parser\\.h$",
1980 REG_EXTENDED
, NULL_REGEX
,
1981 "gt-cp-parser.h", "cp/parser.c", NULL_FRULACT
},
1983 /* objc/objc-act.h gives gt-objc-objc-act.h for objc/objc-act.c ! */
1984 { DIR_PREFIX_REGEX
"objc/objc-act\\.h$",
1985 REG_EXTENDED
, NULL_REGEX
,
1986 "gt-objc-objc-act.h", "objc/objc-act.c", NULL_FRULACT
},
1988 /* objc/objc-map.h gives gt-objc-objc-map.h for objc/objc-map.c ! */
1989 { DIR_PREFIX_REGEX
"objc/objc-map\\.h$",
1990 REG_EXTENDED
, NULL_REGEX
,
1991 "gt-objc-objc-map.h", "objc/objc-map.c", NULL_FRULACT
},
1993 /* General cases. For header *.h and source *.c or *.cc files, we
1994 * need special actions to handle the language. */
1996 /* Source *.c files are using get_file_gtfilename to compute their
1997 output_name and get_file_basename to compute their for_name
1998 through the source_dot_c_frul action. */
1999 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.c$",
2000 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.c", source_dot_c_frul
},
2002 /* Source *.cc files are using get_file_gtfilename to compute their
2003 output_name and get_file_basename to compute their for_name
2004 through the source_dot_c_frul action. */
2005 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.cc$",
2006 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.cc", source_dot_c_frul
},
2008 /* Common header files get "gtype-desc.c" as their output_name,
2009 * while language specific header files are handled specially. So
2010 * we need the header_dot_h_frul action. */
2011 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.h$",
2012 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.h", header_dot_h_frul
},
2014 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.in$",
2015 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.in", NULL_FRULACT
},
2017 /* Mandatory null last entry signaling end of rules. */
2018 {NULL
, 0, NULL_REGEX
, NULL
, NULL
, NULL_FRULACT
}
2021 /* Special file rules action for handling *.h header files. It gives
2022 "gtype-desc.c" for common headers and corresponding output
2023 files for language-specific header files. */
2025 header_dot_h_frul (input_file
* inpf
, char**poutname
,
2026 char**pforname ATTRIBUTE_UNUSED
)
2028 const char *basename
= 0;
2030 DBGPRINTF ("inpf %p inpname %s outname %s forname %s",
2031 (void*) inpf
, get_input_file_name (inpf
),
2032 *poutname
, *pforname
);
2033 basename
= get_file_basename (inpf
);
2034 lang_index
= get_prefix_langdir_index (basename
);
2035 DBGPRINTF ("basename %s lang_index %d", basename
, lang_index
);
2037 if (lang_index
>= 0)
2039 /* The header is language specific. Given output_name &
2040 for_name remains unchanged. The base_files array gives the
2042 DBGPRINTF ("header_dot_h found language specific @ %p '%s'",
2043 (void*) base_files
[lang_index
],
2044 (base_files
[lang_index
])->name
);
2045 return base_files
[lang_index
];
2049 /* The header is common to all front-end languages. So
2050 output_name is "gtype-desc.c" file. The calling function
2051 get_output_file_with_visibility will find its outf_p. */
2053 *poutname
= xstrdup ("gtype-desc.c");
2054 DBGPRINTF ("special 'gtype-desc.c' for inpname %s",
2055 get_input_file_name (inpf
));
2061 /* Special file rules action for handling *.c source files using
2062 * get_file_gtfilename to compute their output_name and
2063 * get_file_basename to compute their for_name. The output_name is
2064 * gt-<LANG>-<BASE>.h for language specific source files, and
2065 * gt-<BASE>.h for common source files. */
2067 source_dot_c_frul (input_file
* inpf
, char**poutname
, char**pforname
)
2069 char *newbasename
= CONST_CAST (char*, get_file_basename (inpf
));
2070 char *newoutname
= CONST_CAST (char*, get_file_gtfilename (inpf
));
2071 DBGPRINTF ("inpf %p inpname %s original outname %s forname %s",
2072 (void*) inpf
, get_input_file_name (inpf
),
2073 *poutname
, *pforname
);
2074 DBGPRINTF ("newoutname %s", newoutname
);
2075 DBGPRINTF ("newbasename %s", newbasename
);
2078 *poutname
= newoutname
;
2079 *pforname
= newbasename
;
2083 /* Utility function for get_output_file_with_visibility which returns
2084 * a malloc-ed substituted string using TRS on matching of the FILNAM
2085 * file name, using the PMATCH array. */
2087 matching_file_name_substitute (const char *filnam
, regmatch_t pmatch
[10],
2090 struct obstack str_obstack
;
2092 char *rawstr
= NULL
;
2093 const char *pt
= NULL
;
2094 DBGPRINTF ("filnam %s", filnam
);
2095 obstack_init (&str_obstack
);
2096 for (pt
= trs
; *pt
; pt
++) {
2102 /* A double dollar $$ is substituted by a single verbatim
2103 dollar, but who really uses dollar signs in file
2105 obstack_1grow (&str_obstack
, '$');
2107 else if (ISDIGIT (pt
[1]))
2109 /* Handle $0 $1 ... $9 by appropriate substitution. */
2110 int dolnum
= pt
[1] - '0';
2111 int so
= pmatch
[dolnum
].rm_so
;
2112 int eo
= pmatch
[dolnum
].rm_eo
;
2113 DBGPRINTF ("so=%d eo=%d dolnum=%d", so
, eo
, dolnum
);
2114 if (so
>=0 && eo
>=so
)
2115 obstack_grow (&str_obstack
, filnam
+ so
, eo
- so
);
2119 /* This can happen only when files_rules is buggy! */
2122 /* Always skip the character after the dollar. */
2126 obstack_1grow (&str_obstack
, c
);
2128 obstack_1grow (&str_obstack
, '\0');
2129 rawstr
= XOBFINISH (&str_obstack
, char *);
2130 str
= xstrdup (rawstr
);
2131 obstack_free (&str_obstack
, NULL
);
2132 DBGPRINTF ("matched replacement %s", str
);
2138 /* An output file, suitable for definitions, that can see declarations
2139 made in INPF and is linked into every language that uses INPF.
2140 Since the result is cached inside INPF, that argument cannot be
2141 declared constant, but is "almost" constant. */
2144 get_output_file_with_visibility (input_file
*inpf
)
2147 char *for_name
= NULL
;
2148 char *output_name
= NULL
;
2149 const char* inpfname
;
2151 /* This can happen when we need a file with visibility on a
2152 structure that we've never seen. We have to just hope that it's
2153 globally visible. */
2155 inpf
= system_h_file
;
2157 /* The result is cached in INPF, so return it if already known. */
2159 return inpf
->inpoutf
;
2161 /* In plugin mode, return NULL unless the input_file is one of the
2166 for (i
= 0; i
< nb_plugin_files
; i
++)
2167 if (inpf
== plugin_files
[i
])
2169 inpf
->inpoutf
= plugin_output
;
2170 return plugin_output
;
2176 inpfname
= get_input_file_name (inpf
);
2178 /* Try each rule in sequence in files_rules until one is triggered. */
2181 DBGPRINTF ("passing input file @ %p named %s through the files_rules",
2182 (void*) inpf
, inpfname
);
2184 for (; files_rules
[rulix
].frul_srcexpr
!= NULL
; rulix
++)
2186 DBGPRINTF ("rulix#%d srcexpr %s",
2187 rulix
, files_rules
[rulix
].frul_srcexpr
);
2189 if (!files_rules
[rulix
].frul_re
)
2191 /* Compile the regexpr lazily. */
2193 files_rules
[rulix
].frul_re
= XCNEW (regex_t
);
2194 err
= regcomp (files_rules
[rulix
].frul_re
,
2195 files_rules
[rulix
].frul_srcexpr
,
2196 files_rules
[rulix
].frul_rflags
);
2199 /* The regular expression compilation fails only when
2200 file_rules is buggy. */
2208 /* Match the regexpr and trigger the rule if matched. */
2210 /* We have exactly ten pmatch-s, one for each $0, $1, $2,
2212 regmatch_t pmatch
[10];
2213 memset (pmatch
, 0, sizeof (pmatch
));
2214 if (!regexec (files_rules
[rulix
].frul_re
,
2215 inpfname
, 10, pmatch
, 0))
2217 DBGPRINTF ("input @ %p filename %s matched rulix#%d pattern %s",
2218 (void*) inpf
, inpfname
, rulix
,
2219 files_rules
[rulix
].frul_srcexpr
);
2221 matching_file_name_substitute (inpfname
, pmatch
,
2222 files_rules
[rulix
].frul_tr_for
);
2223 DBGPRINTF ("for_name %s", for_name
);
2225 matching_file_name_substitute (inpfname
, pmatch
,
2226 files_rules
[rulix
].frul_tr_out
);
2227 DBGPRINTF ("output_name %s", output_name
);
2228 if (files_rules
[rulix
].frul_action
)
2230 /* Invoke our action routine. */
2232 DBGPRINTF ("before action rulix#%d output_name %s for_name %s",
2233 rulix
, output_name
, for_name
);
2235 (files_rules
[rulix
].frul_action
) (inpf
,
2236 &output_name
, &for_name
);
2237 DBGPRINTF ("after action rulix#%d of=%p output_name %s for_name %s",
2238 rulix
, (void*)of
, output_name
, for_name
);
2239 /* If the action routine returned something, give it back
2240 immediately and cache it in inpf. */
2247 /* The rule matched, and had no action, or that action did
2248 not return any output file but could have changed the
2249 output_name or for_name. We break out of the loop on the
2255 /* The regexpr did not match. */
2256 DBGPRINTF ("rulix#%d did not match %s pattern %s",
2257 rulix
, inpfname
, files_rules
[rulix
].frul_srcexpr
);
2263 if (!output_name
|| !for_name
)
2265 /* This should not be possible, and could only happen if the
2266 files_rules is incomplete or buggy. */
2267 fatal ("failed to compute output name for %s", inpfname
);
2270 /* Look through to see if we've ever seen this output filename
2271 before. If found, cache the result in inpf. */
2272 for (r
= output_files
; r
; r
= r
->next
)
2273 if (filename_cmp (r
->name
, output_name
) == 0)
2276 DBGPRINTF ("found r @ %p for output_name %s for_name %s", (void*)r
,
2277 output_name
, for_name
);
2281 /* If not found, create it, and cache it in inpf. */
2282 r
= create_file (for_name
, output_name
);
2284 gcc_assert (r
&& r
->name
);
2285 DBGPRINTF ("created r @ %p for output_name %s for_name %s", (void*) r
,
2286 output_name
, for_name
);
2293 /* The name of an output file, suitable for definitions, that can see
2294 declarations made in INPF and is linked into every language that
2298 get_output_file_name (input_file
* inpf
)
2300 outf_p o
= get_output_file_with_visibility (inpf
);
2306 /* Check if existing file is equal to the in memory buffer. */
2309 is_file_equal (outf_p of
)
2311 FILE *newfile
= fopen (of
->name
, "r");
2314 if (newfile
== NULL
)
2318 for (i
= 0; i
< of
->bufused
; i
++)
2321 ch
= fgetc (newfile
);
2322 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
2328 if (equal
&& EOF
!= fgetc (newfile
))
2334 /* Copy the output to its final destination,
2335 but don't unnecessarily change modification times. */
2338 close_output_files (void)
2340 int nbwrittenfiles
= 0;
2343 for (of
= output_files
; of
; of
= of
->next
)
2345 if (!is_file_equal (of
))
2347 FILE *newfile
= NULL
;
2348 char *backupname
= NULL
;
2349 /* Back up the old version of the output file gt-FOO.c as
2350 BACKUPDIR/gt-FOO.c~ if we have a backup directory. */
2353 backupname
= concat (backup_dir
, "/",
2354 lbasename (of
->name
), "~", NULL
);
2355 if (!access (of
->name
, F_OK
) && rename (of
->name
, backupname
))
2356 fatal ("failed to back up %s as %s: %s",
2357 of
->name
, backupname
, xstrerror (errno
));
2360 newfile
= fopen (of
->name
, "w");
2361 if (newfile
== NULL
)
2362 fatal ("opening output file %s: %s", of
->name
, xstrerror (errno
));
2363 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
2364 fatal ("writing output file %s: %s", of
->name
, xstrerror (errno
));
2365 if (fclose (newfile
) != 0)
2366 fatal ("closing output file %s: %s", of
->name
, xstrerror (errno
));
2368 if (verbosity_level
>= 2 && backupname
)
2369 printf ("%s wrote #%-3d %s backed-up in %s\n",
2370 progname
, nbwrittenfiles
, of
->name
, backupname
);
2371 else if (verbosity_level
>= 1)
2372 printf ("%s write #%-3d %s\n", progname
, nbwrittenfiles
, of
->name
);
2377 /* output file remains unchanged. */
2378 if (verbosity_level
>= 2)
2379 printf ("%s keep %s\n", progname
, of
->name
);
2383 of
->bufused
= of
->buflength
= 0;
2385 if (verbosity_level
>= 1)
2386 printf ("%s wrote %d files.\n", progname
, nbwrittenfiles
);
2393 const input_file
* file
;
2397 struct walk_type_data
;
2399 /* For scalars and strings, given the item in 'val'.
2400 For structures, given a pointer to the item in 'val'.
2401 For misc. pointers, given the item in 'val'.
2403 typedef void (*process_field_fn
) (type_p f
, const struct walk_type_data
* p
);
2404 typedef void (*func_name_fn
) (type_p s
, const struct walk_type_data
* p
);
2406 /* Parameters for write_types. */
2408 struct write_types_data
2411 const char *param_prefix
;
2412 const char *subfield_marker_routine
;
2413 const char *marker_routine
;
2414 const char *reorder_note_routine
;
2415 const char *comment
;
2416 enum write_types_kinds kind
;
2419 static void output_escaped_param (struct walk_type_data
*d
,
2420 const char *, const char *);
2421 static void output_mangled_typename (outf_p
, const_type_p
);
2422 static void walk_type (type_p t
, struct walk_type_data
*d
);
2423 static void write_func_for_structure (type_p orig_s
, type_p s
,
2424 const struct write_types_data
*wtd
);
2425 static void write_types_process_field
2426 (type_p f
, const struct walk_type_data
*d
);
2427 static void write_types (outf_p output_header
,
2429 const struct write_types_data
*wtd
);
2430 static void write_types_local_process_field
2431 (type_p f
, const struct walk_type_data
*d
);
2432 static void write_local_func_for_structure (const_type_p orig_s
, type_p s
);
2433 static void write_local (outf_p output_header
,
2435 static int contains_scalar_p (type_p t
);
2436 static void put_mangled_filename (outf_p
, const input_file
*);
2437 static void finish_root_table (struct flist
*flp
, const char *pfx
,
2438 const char *tname
, const char *lastname
,
2440 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
2441 struct fileloc
*, bool);
2442 static void write_array (outf_p f
, pair_p v
,
2443 const struct write_types_data
*wtd
);
2444 static void write_roots (pair_p
, bool);
2446 /* Parameters for walk_type. */
2448 struct walk_type_data
2450 process_field_fn process_field
;
2455 const char *prev_val
[4];
2458 const struct fileloc
*line
;
2462 const char *reorder_fn
;
2464 bool fn_wants_lvalue
;
2472 /* Given a string TYPE_NAME, representing a C++ typename, return a valid
2473 pre-processor identifier to use in a #define directive. This replaces
2474 special characters used in C++ identifiers like '>', '<' and ':' with
2477 If no C++ special characters are found in TYPE_NAME, return
2478 TYPE_NAME. Otherwise, return a copy of TYPE_NAME with the special
2479 characters replaced with '_'. In this case, the caller is
2480 responsible for freeing the allocated string. */
2483 filter_type_name (const char *type_name
)
2485 if (strchr (type_name
, '<') || strchr (type_name
, ':'))
2488 char *s
= xstrdup (type_name
);
2489 for (i
= 0; i
< strlen (s
); i
++)
2490 if (s
[i
] == '<' || s
[i
] == '>' || s
[i
] == ':' || s
[i
] == ','
2500 /* Print a mangled name representing T to OF. */
2503 output_mangled_typename (outf_p of
, const_type_p t
)
2511 case TYPE_UNDEFINED
:
2516 output_mangled_typename (of
, t
->u
.p
);
2526 case TYPE_LANG_STRUCT
:
2527 case TYPE_USER_STRUCT
:
2529 /* For references to classes within an inheritance hierarchy,
2530 only ever reference the ultimate base class, since only
2531 it will have gt_ functions. */
2532 t
= get_ultimate_base_class (t
);
2533 const char *id_for_tag
= filter_type_name (t
->u
.s
.tag
);
2534 oprintf (of
, "%lu%s", (unsigned long) strlen (id_for_tag
),
2536 if (id_for_tag
!= t
->u
.s
.tag
)
2537 free (CONST_CAST (char *, id_for_tag
));
2545 /* Print PARAM to D->OF processing escapes. D->VAL references the
2546 current object, D->PREV_VAL the object containing the current
2547 object, ONAME is the name of the option and D->LINE is used to
2548 print error messages. */
2551 output_escaped_param (struct walk_type_data
*d
, const char *param
,
2556 for (p
= param
; *p
; p
++)
2558 oprintf (d
->of
, "%c", *p
);
2563 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
2566 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
2569 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
2573 const char *pp
= d
->val
+ strlen (d
->val
);
2574 while (pp
[-1] == ']')
2577 oprintf (d
->of
, "%s", pp
);
2581 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
2587 get_string_option (options_p opt
, const char *key
)
2589 for (; opt
; opt
= opt
->next
)
2590 if (strcmp (opt
->name
, key
) == 0)
2591 return opt
->info
.string
;
2595 /* Machinery for avoiding duplicate tags within switch statements. */
2599 struct seen_tag
*next
;
2603 already_seen_tag (struct seen_tag
*seen_tags
, const char *tag
)
2605 /* Linear search, so O(n^2), but n is currently small. */
2608 if (!strcmp (seen_tags
->tag
, tag
))
2610 seen_tags
= seen_tags
->next
;
2612 /* Not yet seen this tag. */
2617 mark_tag_as_seen (struct seen_tag
**seen_tags
, const char *tag
)
2619 /* Add to front of linked list. */
2620 struct seen_tag
*new_node
= XCNEW (struct seen_tag
);
2621 new_node
->tag
= tag
;
2622 new_node
->next
= *seen_tags
;
2623 *seen_tags
= new_node
;
2627 walk_subclasses (type_p base
, struct walk_type_data
*d
,
2628 struct seen_tag
**seen_tags
)
2630 for (type_p sub
= base
->u
.s
.first_subclass
; sub
!= NULL
;
2631 sub
= sub
->u
.s
.next_sibling_class
)
2633 const char *type_tag
= get_string_option (sub
->u
.s
.opt
, "tag");
2634 if (type_tag
&& !already_seen_tag (*seen_tags
, type_tag
))
2636 mark_tag_as_seen (seen_tags
, type_tag
);
2637 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", type_tag
);
2639 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2641 oprintf (d
->of
, "%*s%s *sub = static_cast <%s *> (x);\n",
2642 d
->indent
, "", sub
->u
.s
.tag
, sub
->u
.s
.tag
);
2643 const char *old_val
= d
->val
;
2648 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2649 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2652 walk_subclasses (sub
, d
, seen_tags
);
2656 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2657 which is of type T. Write code to D->OF to constrain execution (at
2658 the point that D->PROCESS_FIELD is called) to the appropriate
2659 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2660 pointers to those objects. D->PREV_VAL lists the objects
2661 containing the current object, D->OPT is a list of options to
2662 apply, D->INDENT is the current indentation level, D->LINE is used
2663 to print error messages, D->BITMAP indicates which languages to
2664 print the structure for. */
2667 walk_type (type_p t
, struct walk_type_data
*d
)
2669 const char *length
= NULL
;
2670 const char *desc
= NULL
;
2671 const char *type_tag
= NULL
;
2672 int maybe_undef_p
= 0;
2675 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
2677 d
->needs_cast_p
= false;
2678 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
2679 if (strcmp (oo
->name
, "length") == 0 && oo
->kind
== OPTION_STRING
)
2680 length
= oo
->info
.string
;
2681 else if (strcmp (oo
->name
, "maybe_undef") == 0)
2683 else if (strcmp (oo
->name
, "desc") == 0 && oo
->kind
== OPTION_STRING
)
2684 desc
= oo
->info
.string
;
2685 else if (strcmp (oo
->name
, "nested_ptr") == 0
2686 && oo
->kind
== OPTION_NESTED
)
2687 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
.nested
;
2688 else if (strcmp (oo
->name
, "dot") == 0)
2690 else if (strcmp (oo
->name
, "tag") == 0)
2691 type_tag
= oo
->info
.string
;
2692 else if (strcmp (oo
->name
, "special") == 0)
2694 else if (strcmp (oo
->name
, "skip") == 0)
2696 else if (strcmp (oo
->name
, "atomic") == 0)
2698 else if (strcmp (oo
->name
, "default") == 0)
2700 else if (strcmp (oo
->name
, "chain_next") == 0)
2702 else if (strcmp (oo
->name
, "chain_prev") == 0)
2704 else if (strcmp (oo
->name
, "chain_circular") == 0)
2706 else if (strcmp (oo
->name
, "reorder") == 0)
2708 else if (strcmp (oo
->name
, "variable_size") == 0)
2710 else if (strcmp (oo
->name
, "for_user") == 0)
2713 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
2719 && (t
->kind
!= TYPE_POINTER
|| !union_or_struct_p (t
->u
.p
)))
2721 error_at_line (d
->line
,
2722 "field `%s' has invalid option `maybe_undef_p'\n",
2727 if (atomic_p
&& (t
->kind
!= TYPE_POINTER
) && (t
->kind
!= TYPE_STRING
))
2729 error_at_line (d
->line
, "field `%s' has invalid option `atomic'\n", d
->val
);
2737 d
->process_field (t
, d
);
2742 d
->in_ptr_field
= true;
2743 if (maybe_undef_p
&& t
->u
.p
->u
.s
.line
.file
== NULL
)
2745 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2749 /* If a pointer type is marked as "atomic", we process the
2750 field itself, but we don't walk the data that they point to.
2752 There are two main cases where we walk types: to mark
2753 pointers that are reachable, and to relocate pointers when
2754 writing a PCH file. In both cases, an atomic pointer is
2755 itself marked or relocated, but the memory that it points
2756 to is left untouched. In the case of PCH, that memory will
2757 be read/written unchanged to the PCH file. */
2760 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2762 d
->process_field (t
, d
);
2764 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2770 if (!union_or_struct_p (t
->u
.p
))
2772 error_at_line (d
->line
,
2773 "field `%s' is pointer to unimplemented type",
2780 const char *oldprevval2
= d
->prev_val
[2];
2782 if (!union_or_struct_p (nested_ptr_d
->type
))
2784 error_at_line (d
->line
,
2785 "field `%s' has invalid "
2786 "option `nested_ptr'\n", d
->val
);
2790 d
->prev_val
[2] = d
->val
;
2791 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2793 d
->val
= xasprintf ("x%d", d
->counter
++);
2794 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2795 (nested_ptr_d
->type
->kind
== TYPE_UNION
2796 ? "union" : "struct"),
2797 nested_ptr_d
->type
->u
.s
.tag
,
2798 d
->fn_wants_lvalue
? "" : "const ", d
->val
);
2799 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2800 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2802 oprintf (d
->of
, ";\n");
2804 d
->process_field (nested_ptr_d
->type
, d
);
2806 if (d
->fn_wants_lvalue
)
2808 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2810 d
->prev_val
[2] = d
->val
;
2811 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2813 oprintf (d
->of
, ";\n");
2817 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2818 d
->val
= d
->prev_val
[2];
2819 d
->prev_val
[2] = oldprevval2
;
2822 d
->process_field (t
->u
.p
, d
);
2826 int loopcounter
= d
->loopcounter
;
2827 const char *oldval
= d
->val
;
2828 const char *oldprevval3
= d
->prev_val
[3];
2831 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2833 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2834 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
,
2835 "", loopcounter
, loopcounter
);
2836 if (!d
->in_record_p
)
2837 output_escaped_param (d
, length
, "length");
2839 oprintf (d
->of
, "l%d", loopcounter
);
2840 if (d
->have_this_obj
)
2841 /* Try to unswitch loops (see PR53880). */
2842 oprintf (d
->of
, ") && ((void *)%s == this_obj", oldval
);
2843 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2845 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2847 d
->prev_val
[3] = oldval
;
2848 walk_type (t
->u
.p
, d
);
2851 d
->prev_val
[3] = oldprevval3
;
2854 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2855 d
->process_field (t
, d
);
2857 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2859 d
->in_ptr_field
= false;
2866 const char *oldval
= d
->val
;
2869 /* If it's an array of scalars, we optimize by not generating
2871 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2875 loopcounter
= d
->loopcounter
;
2877 loopcounter
= d
->counter
++;
2879 /* When walking an array, compute the length and store it in a
2880 local variable before walking the array elements, instead of
2881 recomputing the length expression each time through the loop.
2882 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2883 where the length is stored in the first array element,
2884 because otherwise that operand can get overwritten on the
2886 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2888 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2889 if (!d
->in_record_p
|| !length
)
2891 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2892 d
->indent
, "", loopcounter
);
2894 output_escaped_param (d
, length
, "length");
2896 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2897 oprintf (d
->of
, ");\n");
2900 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2902 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2904 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2906 walk_type (t
->u
.a
.p
, d
);
2911 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2913 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2921 const char *oldval
= d
->val
;
2922 const char *oldprevval1
= d
->prev_val
[1];
2923 const char *oldprevval2
= d
->prev_val
[2];
2924 const int union_p
= t
->kind
== TYPE_UNION
;
2925 int seen_default_p
= 0;
2927 int lengths_seen
= 0;
2929 bool any_length_seen
= false;
2931 if (!t
->u
.s
.line
.file
)
2932 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2934 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2936 error_at_line (d
->line
,
2937 "structure `%s' defined for mismatching languages",
2939 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2942 /* Some things may also be defined in the structure's options. */
2943 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2944 if (!desc
&& strcmp (o
->name
, "desc") == 0
2945 && o
->kind
== OPTION_STRING
)
2946 desc
= o
->info
.string
;
2948 d
->prev_val
[2] = oldval
;
2949 d
->prev_val
[1] = oldprevval2
;
2954 error_at_line (d
->line
,
2955 "missing `desc' option for union `%s'",
2959 oprintf (d
->of
, "%*sswitch ((int) (", d
->indent
, "");
2960 output_escaped_param (d
, desc
, "desc");
2961 oprintf (d
->of
, "))\n");
2963 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2967 /* We have a "desc" option on a struct, signifying the
2968 base class within a GC-managed inheritance hierarchy.
2969 The current code specialcases the base class, then walks
2970 into subclasses, recursing into this routine to handle them.
2971 This organization requires the base class to have a case in
2972 the switch statement, and hence a tag value is mandatory
2973 for the base class. This restriction could be removed, but
2974 it would require some restructing of this code. */
2977 error_at_line (d
->line
,
2978 "missing `tag' option for type `%s'",
2981 oprintf (d
->of
, "%*sswitch ((int) (", d
->indent
, "");
2982 output_escaped_param (d
, desc
, "desc");
2983 oprintf (d
->of
, "))\n");
2985 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2986 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", type_tag
);
2990 FOR_ALL_INHERITED_FIELDS (t
, f
)
2994 const char *fieldlength
= NULL
;
2996 d
->reorder_fn
= NULL
;
2997 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2998 if (strcmp (oo
->name
, "skip") == 0)
3000 else if (strcmp (oo
->name
, "length") == 0
3001 && oo
->kind
== OPTION_STRING
)
3002 fieldlength
= oo
->info
.string
;
3012 if (!any_length_seen
)
3014 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
3017 any_length_seen
= true;
3019 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
3020 d
->indent
, "", d
->counter
- 1);
3021 output_escaped_param (d
, fieldlength
, "length");
3022 oprintf (d
->of
, ");\n");
3026 endcounter
= d
->counter
;
3028 FOR_ALL_INHERITED_FIELDS (t
, f
)
3031 const char *dot
= ".";
3032 const char *tagid
= NULL
;
3035 const char *fieldlength
= NULL
;
3038 d
->reorder_fn
= NULL
;
3039 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
3040 if (strcmp (oo
->name
, "dot") == 0
3041 && oo
->kind
== OPTION_STRING
)
3042 dot
= oo
->info
.string
;
3043 else if (strcmp (oo
->name
, "tag") == 0
3044 && oo
->kind
== OPTION_STRING
)
3045 tagid
= oo
->info
.string
;
3046 else if (strcmp (oo
->name
, "skip") == 0)
3048 else if (strcmp (oo
->name
, "default") == 0)
3050 else if (strcmp (oo
->name
, "reorder") == 0
3051 && oo
->kind
== OPTION_STRING
)
3052 d
->reorder_fn
= oo
->info
.string
;
3053 else if (strcmp (oo
->name
, "length") == 0
3054 && oo
->kind
== OPTION_STRING
)
3055 fieldlength
= oo
->info
.string
;
3060 if (union_p
&& tagid
)
3062 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
3065 else if (union_p
&& default_p
)
3067 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
3071 else if (!union_p
&& (default_p
|| tagid
))
3072 error_at_line (d
->line
,
3073 "can't use `%s' outside a union on field `%s'",
3074 default_p
? "default" : "tag", f
->name
);
3075 else if (union_p
&& !(default_p
|| tagid
)
3076 && f
->type
->kind
== TYPE_SCALAR
)
3079 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
3080 get_input_file_name (d
->line
->file
), d
->line
->line
,
3084 else if (union_p
&& !(default_p
|| tagid
))
3085 error_at_line (d
->line
,
3086 "field `%s' is missing `tag' or `default' option",
3091 d
->loopcounter
= endcounter
- lengths_seen
--;
3095 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
3097 d
->used_length
= false;
3098 d
->in_record_p
= !union_p
;
3100 walk_type (f
->type
, d
);
3102 d
->in_record_p
= false;
3108 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
3112 d
->reorder_fn
= NULL
;
3115 d
->prev_val
[1] = oldprevval1
;
3116 d
->prev_val
[2] = oldprevval2
;
3118 if (union_p
&& !seen_default_p
)
3120 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
3121 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
3124 if (desc
&& !union_p
)
3126 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
3131 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
3136 /* Add cases to handle subclasses. */
3137 struct seen_tag
*tags
= NULL
;
3138 walk_subclasses (t
, d
, &tags
);
3140 /* Ensure that if someone forgets a "tag" option that we don't
3141 silent fail to traverse that subclass's fields. */
3142 if (!seen_default_p
)
3144 oprintf (d
->of
, "%*s/* Unrecognized tag value. */\n",
3146 oprintf (d
->of
, "%*sdefault: gcc_unreachable (); \n",
3150 /* End of the switch statement */
3151 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
3154 if (any_length_seen
)
3157 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
3162 case TYPE_LANG_STRUCT
:
3165 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
3166 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
3169 error_at_line (d
->line
, "structure `%s' differs between languages",
3176 case TYPE_USER_STRUCT
:
3177 d
->process_field (t
, d
);
3181 case TYPE_UNDEFINED
:
3186 /* process_field routine for marking routines. */
3189 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
3191 const struct write_types_data
*wtd
;
3192 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
3193 wtd
= (const struct write_types_data
*) d
->cookie
;
3198 case TYPE_UNDEFINED
:
3201 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
3202 wtd
->subfield_marker_routine
, cast
, d
->val
);
3203 if (wtd
->param_prefix
)
3205 if (f
->u
.p
->kind
== TYPE_SCALAR
)
3206 /* The current type is a pointer to a scalar (so not
3207 considered like a pointer to instances of user defined
3208 types) and we are seeing it; it means we must be even
3209 more careful about the second argument of the
3210 SUBFIELD_MARKER_ROUTINE call. That argument must
3211 always be the instance of the type for which
3212 write_func_for_structure was called - this really is
3213 what the function SUBFIELD_MARKER_ROUTINE expects.
3214 That is, it must be an instance of the ORIG_S type
3215 parameter of write_func_for_structure. The convention
3216 is that that argument must be "x" in that case (as set
3217 by write_func_for_structure). The problem is, we can't
3218 count on d->prev_val[3] to be always set to "x" in that
3219 case. Sometimes walk_type can set it to something else
3220 (to e.g cooperate with write_array when called from
3221 write_roots). So let's set it to "x" here then. */
3222 oprintf (d
->of
, ", x");
3224 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
3227 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
3228 output_mangled_typename (d
->of
, d
->orig_s
);
3231 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
3233 oprintf (d
->of
, ");\n");
3234 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
3235 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
3236 wtd
->reorder_note_routine
, cast
, d
->val
,
3237 d
->prev_val
[3], d
->reorder_fn
);
3243 case TYPE_LANG_STRUCT
:
3244 case TYPE_USER_STRUCT
:
3245 if (f
->kind
== TYPE_USER_STRUCT
&& !d
->in_ptr_field
)
3247 /* If F is a user-defined type and the field is not a
3248 pointer to the type, then we should not generate the
3249 standard pointer-marking code. All we need to do is call
3250 the user-provided marking function to process the fields
3252 oprintf (d
->of
, "%*sgt_%sx (&(%s));\n", d
->indent
, "", wtd
->prefix
,
3257 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
3258 output_mangled_typename (d
->of
, f
);
3259 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
3260 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
3261 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
3262 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
3275 /* Return an output file that is suitable for definitions which can
3276 reference struct S */
3279 get_output_file_for_structure (const_type_p s
)
3281 const input_file
*fn
;
3283 gcc_assert (union_or_struct_p (s
));
3284 fn
= s
->u
.s
.line
.file
;
3286 /* The call to get_output_file_with_visibility may update fn by
3287 caching its result inside, so we need the CONST_CAST. */
3288 return get_output_file_with_visibility (CONST_CAST (input_file
*, fn
));
3292 /* Returns the specifier keyword for a string or union type S, empty string
3296 get_type_specifier (const type_p s
)
3298 if (s
->kind
== TYPE_STRUCT
)
3300 else if (s
->kind
== TYPE_LANG_STRUCT
)
3301 return get_type_specifier (s
->u
.s
.lang_struct
);
3302 else if (s
->kind
== TYPE_UNION
)
3308 /* Emits a declaration for type TY (assumed to be a union or a
3309 structure) on stream OUT. */
3312 write_type_decl (outf_p out
, type_p ty
)
3314 if (union_or_struct_p (ty
))
3315 oprintf (out
, "%s%s", get_type_specifier (ty
), ty
->u
.s
.tag
);
3316 else if (ty
->kind
== TYPE_SCALAR
)
3318 if (ty
->u
.scalar_is_char
)
3319 oprintf (out
, "const char");
3321 oprintf (out
, "void");
3323 else if (ty
->kind
== TYPE_POINTER
)
3325 write_type_decl (out
, ty
->u
.p
);
3326 oprintf (out
, " *");
3328 else if (ty
->kind
== TYPE_ARRAY
)
3330 write_type_decl (out
, ty
->u
.a
.p
);
3331 oprintf (out
, " *");
3333 else if (ty
->kind
== TYPE_STRING
)
3335 oprintf (out
, "const char *");
3342 /* Write on OF the name of the marker function for structure S. PREFIX
3343 is the prefix to use (to distinguish ggc from pch markers). */
3346 write_marker_function_name (outf_p of
, type_p s
, const char *prefix
)
3348 if (union_or_struct_p (s
))
3350 const char *id_for_tag
= filter_type_name (s
->u
.s
.tag
);
3351 oprintf (of
, "gt_%sx_%s", prefix
, id_for_tag
);
3352 if (id_for_tag
!= s
->u
.s
.tag
)
3353 free (CONST_CAST (char *, id_for_tag
));
3359 /* Write on OF a user-callable routine to act as an entry point for
3360 the marking routine for S, generated by write_func_for_structure.
3361 WTD distinguishes between ggc and pch markers. */
3364 write_user_func_for_structure_ptr (outf_p of
, type_p s
, const write_types_data
*wtd
)
3366 gcc_assert (union_or_struct_p (s
));
3368 type_p alias_of
= NULL
;
3369 for (options_p opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3370 if (strcmp (opt
->name
, "ptr_alias") == 0)
3372 /* ALIAS_OF is set if ORIG_S is marked "ptr_alias". This means that
3373 we do not generate marking code for ORIG_S here. Instead, a
3374 forwarder #define in gtype-desc.h will cause every call to its
3375 marker to call the target of this alias.
3377 However, we still want to create a user entry code for the
3378 aliased type. So, if ALIAS_OF is set, we only generate the
3379 user-callable marker function. */
3380 alias_of
= opt
->info
.type
;
3384 DBGPRINTF ("write_user_func_for_structure_ptr: %s %s", s
->u
.s
.tag
,
3387 /* Only write the function once. */
3388 if (s
->u
.s
.wrote_user_func_for_ptr
[wtd
->kind
])
3390 s
->u
.s
.wrote_user_func_for_ptr
[wtd
->kind
] = true;
3392 oprintf (of
, "\nvoid\n");
3393 oprintf (of
, "gt_%sx (", wtd
->prefix
);
3394 write_type_decl (of
, s
);
3395 oprintf (of
, " *& x)\n");
3396 oprintf (of
, "{\n");
3397 oprintf (of
, " if (x)\n ");
3398 write_marker_function_name (of
,
3399 alias_of
? alias_of
: get_ultimate_base_class (s
),
3401 oprintf (of
, " ((void *) x);\n");
3402 oprintf (of
, "}\n");
3406 /* Write a function to mark all the fields of type S on OF. PREFIX
3407 and D are as in write_user_marking_functions. */
3410 write_user_func_for_structure_body (type_p s
, const char *prefix
,
3411 struct walk_type_data
*d
)
3413 oprintf (d
->of
, "\nvoid\n");
3414 oprintf (d
->of
, "gt_%sx (", prefix
);
3415 write_type_decl (d
->of
, s
);
3416 oprintf (d
->of
, "& x_r ATTRIBUTE_UNUSED)\n");
3417 oprintf (d
->of
, "{\n");
3418 oprintf (d
->of
, " ");
3419 write_type_decl (d
->of
, s
);
3420 oprintf (d
->of
, " * ATTRIBUTE_UNUSED x = &x_r;\n");
3424 oprintf (d
->of
, "}\n");
3427 /* Emit the user-callable functions needed to mark all the types used
3428 by the user structure S. PREFIX is the prefix to use to
3429 distinguish ggc and pch markers. D contains data needed to pass to
3430 walk_type when traversing the fields of a type.
3432 For every type T referenced by S, two routines are generated: one
3433 that takes 'T *', marks the pointer and calls the second routine,
3434 which just marks the fields of T. */
3437 write_user_marking_functions (type_p s
,
3438 const write_types_data
*w
,
3439 struct walk_type_data
*d
)
3441 gcc_assert (s
->kind
== TYPE_USER_STRUCT
);
3443 for (pair_p fld
= s
->u
.s
.fields
; fld
; fld
= fld
->next
)
3445 type_p fld_type
= fld
->type
;
3446 if (fld_type
->kind
== TYPE_POINTER
)
3448 type_p pointed_to_type
= fld_type
->u
.p
;
3449 if (union_or_struct_p (pointed_to_type
))
3450 write_user_func_for_structure_ptr (d
->of
, pointed_to_type
, w
);
3452 else if (union_or_struct_p (fld_type
))
3453 write_user_func_for_structure_body (fld_type
, w
->prefix
, d
);
3458 /* For S, a structure that's part of ORIG_S write out a routine that:
3459 - Takes a parameter, a void * but actually of type *S
3460 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
3461 field of S or its substructures and (in some cases) things
3462 that are pointed to by S. */
3465 write_func_for_structure (type_p orig_s
, type_p s
,
3466 const struct write_types_data
*wtd
)
3468 const char *chain_next
= NULL
;
3469 const char *chain_prev
= NULL
;
3470 const char *chain_circular
= NULL
;
3472 struct walk_type_data d
;
3474 if (s
->u
.s
.base_class
)
3476 /* Verify that the base class has a "desc", since otherwise
3477 the traversal hooks there won't attempt to visit fields of
3478 subclasses such as this one. */
3479 const_type_p ubc
= get_ultimate_base_class (s
);
3480 if ((!opts_have (ubc
->u
.s
.opt
, "user")
3481 && !opts_have (ubc
->u
.s
.opt
, "desc")))
3482 error_at_line (&s
->u
.s
.line
,
3483 ("'%s' is a subclass of non-GTY(user) GTY class '%s'"
3484 ", but '%s' lacks a discriminator 'desc' option"),
3485 s
->u
.s
.tag
, ubc
->u
.s
.tag
, ubc
->u
.s
.tag
);
3487 /* Don't write fns for subclasses, only for the ultimate base class
3488 within an inheritance hierarchy. */
3492 memset (&d
, 0, sizeof (d
));
3493 d
.of
= get_output_file_for_structure (s
);
3495 bool for_user
= false;
3496 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3497 if (strcmp (opt
->name
, "chain_next") == 0
3498 && opt
->kind
== OPTION_STRING
)
3499 chain_next
= opt
->info
.string
;
3500 else if (strcmp (opt
->name
, "chain_prev") == 0
3501 && opt
->kind
== OPTION_STRING
)
3502 chain_prev
= opt
->info
.string
;
3503 else if (strcmp (opt
->name
, "chain_circular") == 0
3504 && opt
->kind
== OPTION_STRING
)
3505 chain_circular
= opt
->info
.string
;
3506 else if (strcmp (opt
->name
, "for_user") == 0)
3508 if (chain_prev
!= NULL
&& chain_next
== NULL
)
3509 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
3510 if (chain_circular
!= NULL
&& chain_next
!= NULL
)
3511 error_at_line (&s
->u
.s
.line
, "chain_circular with chain_next");
3512 if (chain_circular
!= NULL
)
3513 chain_next
= chain_circular
;
3515 d
.process_field
= write_types_process_field
;
3519 d
.line
= &s
->u
.s
.line
;
3520 d
.bitmap
= s
->u
.s
.bitmap
;
3521 d
.prev_val
[0] = "*x";
3522 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
3523 d
.prev_val
[3] = "x";
3525 d
.have_this_obj
= false;
3527 oprintf (d
.of
, "\n");
3528 oprintf (d
.of
, "void\n");
3529 write_marker_function_name (d
.of
, orig_s
, wtd
->prefix
);
3530 oprintf (d
.of
, " (void *x_p)\n");
3531 oprintf (d
.of
, "{\n ");
3532 write_type_decl (d
.of
, s
);
3533 oprintf (d
.of
, " * %sx = (", chain_next
== NULL
? "const " : "");
3534 write_type_decl (d
.of
, s
);
3535 oprintf (d
.of
, " *)x_p;\n");
3536 if (chain_next
!= NULL
)
3538 /* TYPE_USER_STRUCTs should not occur here. These structures
3539 are completely handled by user code. */
3540 gcc_assert (orig_s
->kind
!= TYPE_USER_STRUCT
);
3542 oprintf (d
.of
, " ");
3543 write_type_decl (d
.of
, s
);
3544 oprintf (d
.of
, " * xlimit = x;\n");
3546 if (chain_next
== NULL
)
3548 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
3549 if (wtd
->param_prefix
)
3551 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
3552 output_mangled_typename (d
.of
, orig_s
);
3554 oprintf (d
.of
, "))\n");
3558 if (chain_circular
!= NULL
)
3559 oprintf (d
.of
, " if (!%s (xlimit", wtd
->marker_routine
);
3561 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
3562 if (wtd
->param_prefix
)
3564 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
3565 output_mangled_typename (d
.of
, orig_s
);
3567 oprintf (d
.of
, "))\n");
3568 if (chain_circular
!= NULL
)
3569 oprintf (d
.of
, " return;\n do\n");
3571 oprintf (d
.of
, " xlimit = (");
3572 d
.prev_val
[2] = "*xlimit";
3573 output_escaped_param (&d
, chain_next
, "chain_next");
3574 oprintf (d
.of
, ");\n");
3575 if (chain_prev
!= NULL
)
3577 oprintf (d
.of
, " if (x != xlimit)\n");
3578 oprintf (d
.of
, " for (;;)\n");
3579 oprintf (d
.of
, " {\n");
3580 oprintf (d
.of
, " %s %s * const xprev = (",
3581 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
3583 d
.prev_val
[2] = "*x";
3584 output_escaped_param (&d
, chain_prev
, "chain_prev");
3585 oprintf (d
.of
, ");\n");
3586 oprintf (d
.of
, " if (xprev == NULL) break;\n");
3587 oprintf (d
.of
, " x = xprev;\n");
3588 oprintf (d
.of
, " (void) %s (xprev", wtd
->marker_routine
);
3589 if (wtd
->param_prefix
)
3591 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
3592 output_mangled_typename (d
.of
, orig_s
);
3594 oprintf (d
.of
, ");\n");
3595 oprintf (d
.of
, " }\n");
3597 if (chain_circular
!= NULL
)
3599 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
3600 if (wtd
->param_prefix
)
3602 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
3603 output_mangled_typename (d
.of
, orig_s
);
3605 oprintf (d
.of
, "));\n");
3606 oprintf (d
.of
, " do\n");
3609 oprintf (d
.of
, " while (x != xlimit)\n");
3611 oprintf (d
.of
, " {\n");
3613 d
.prev_val
[2] = "*x";
3615 if (orig_s
->kind
!= TYPE_USER_STRUCT
)
3619 /* User structures have no fields to walk. Simply generate a call
3620 to the user-provided structure marker. */
3621 oprintf (d
.of
, "%*sgt_%sx (x);\n", d
.indent
, "", wtd
->prefix
);
3624 if (chain_next
!= NULL
)
3626 oprintf (d
.of
, " x = (");
3627 output_escaped_param (&d
, chain_next
, "chain_next");
3628 oprintf (d
.of
, ");\n");
3631 oprintf (d
.of
, " }\n");
3632 if (chain_circular
!= NULL
)
3633 oprintf (d
.of
, " while (x != xlimit);\n");
3634 oprintf (d
.of
, "}\n");
3636 if (orig_s
->kind
== TYPE_USER_STRUCT
)
3637 write_user_marking_functions (orig_s
, wtd
, &d
);
3641 write_user_func_for_structure_body (orig_s
, wtd
->prefix
, &d
);
3642 write_user_func_for_structure_ptr (d
.of
, orig_s
, wtd
);
3647 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
3650 write_types (outf_p output_header
, type_p structures
,
3651 const struct write_types_data
*wtd
)
3653 int nbfun
= 0; /* Count the emitted functions. */
3656 oprintf (output_header
, "\n/* %s*/\n", wtd
->comment
);
3658 /* We first emit the macros and the declarations. Functions' code is
3659 emitted afterwards. This is needed in plugin mode. */
3660 oprintf (output_header
, "/* Macros and declarations. */\n");
3661 for (s
= structures
; s
; s
= s
->next
)
3662 /* Do not emit handlers for derived classes; we only ever deal with
3663 the ultimate base class within an inheritance hierarchy. */
3664 if ((s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3665 && !s
->u
.s
.base_class
)
3669 if (s
->gc_used
== GC_MAYBE_POINTED_TO
&& s
->u
.s
.line
.file
== NULL
)
3672 const char *s_id_for_tag
= filter_type_name (s
->u
.s
.tag
);
3674 oprintf (output_header
, "#define gt_%s_", wtd
->prefix
);
3675 output_mangled_typename (output_header
, s
);
3676 oprintf (output_header
, "(X) do { \\\n");
3677 oprintf (output_header
,
3678 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
3680 oprintf (output_header
, " } while (0)\n");
3682 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3683 if (strcmp (opt
->name
, "ptr_alias") == 0
3684 && opt
->kind
== OPTION_TYPE
)
3686 const_type_p
const t
= (const_type_p
) opt
->info
.type
;
3687 if (t
->kind
== TYPE_STRUCT
3688 || t
->kind
== TYPE_UNION
|| t
->kind
== TYPE_LANG_STRUCT
)
3690 const char *t_id_for_tag
= filter_type_name (t
->u
.s
.tag
);
3691 oprintf (output_header
,
3692 "#define gt_%sx_%s gt_%sx_%s\n",
3693 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t_id_for_tag
);
3694 if (t_id_for_tag
!= t
->u
.s
.tag
)
3695 free (CONST_CAST (char *, t_id_for_tag
));
3698 error_at_line (&s
->u
.s
.line
,
3699 "structure alias is not a structure");
3705 /* Declare the marker procedure only once. */
3706 oprintf (output_header
,
3707 "extern void gt_%sx_%s (void *);\n",
3708 wtd
->prefix
, s_id_for_tag
);
3710 if (s_id_for_tag
!= s
->u
.s
.tag
)
3711 free (CONST_CAST (char *, s_id_for_tag
));
3713 if (s
->u
.s
.line
.file
== NULL
)
3715 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3721 /* At last we emit the functions code. */
3722 oprintf (output_header
, "\n/* functions code */\n");
3723 for (s
= structures
; s
; s
= s
->next
)
3724 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3728 if (s
->gc_used
== GC_MAYBE_POINTED_TO
&& s
->u
.s
.line
.file
== NULL
)
3730 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3731 if (strcmp (opt
->name
, "ptr_alias") == 0)
3736 if (s
->kind
== TYPE_LANG_STRUCT
)
3739 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3742 DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'",
3743 nbfun
, (void*) ss
, ss
->u
.s
.tag
);
3744 write_func_for_structure (s
, ss
, wtd
);
3750 DBGPRINTF ("writing func #%d struct s @ %p '%s'",
3751 nbfun
, (void*) s
, s
->u
.s
.tag
);
3752 write_func_for_structure (s
, s
, wtd
);
3757 /* Structure s is not possibly pointed to, so can be ignored. */
3758 DBGPRINTF ("ignored s @ %p '%s' gc_used#%d",
3759 (void*)s
, s
->u
.s
.tag
,
3763 if (verbosity_level
>= 2)
3764 printf ("%s emitted %d routines for %s\n",
3765 progname
, nbfun
, wtd
->comment
);
3768 static const struct write_types_data ggc_wtd
= {
3769 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
3770 "GC marker procedures. ",
3774 static const struct write_types_data pch_wtd
= {
3775 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
3776 "gt_pch_note_reorder",
3777 "PCH type-walking procedures. ",
3781 /* Write out the local pointer-walking routines. */
3783 /* process_field routine for local pointer-walking for user-callable
3784 routines. The difference between this and
3785 write_types_local_process_field is that, in this case, we do not
3786 need to check whether the given pointer matches the address of the
3787 parent structure. This check was already generated by the call
3788 to gt_pch_nx in the main gt_pch_p_*() function that is calling
3792 write_types_local_user_process_field (type_p f
, const struct walk_type_data
*d
)
3799 case TYPE_LANG_STRUCT
:
3801 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
3804 case TYPE_USER_STRUCT
:
3805 if (d
->in_ptr_field
)
3806 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
3808 oprintf (d
->of
, "%*s gt_pch_nx (&(%s), op, cookie);\n",
3809 d
->indent
, "", d
->val
);
3817 case TYPE_UNDEFINED
:
3823 /* Write a function to PCH walk all the fields of type S on OF.
3824 D contains data needed by walk_type to recurse into the fields of S. */
3827 write_pch_user_walking_for_structure_body (type_p s
, struct walk_type_data
*d
)
3829 oprintf (d
->of
, "\nvoid\n");
3830 oprintf (d
->of
, "gt_pch_nx (");
3831 write_type_decl (d
->of
, s
);
3832 oprintf (d
->of
, "* x ATTRIBUTE_UNUSED,\n"
3833 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3834 "\tATTRIBUTE_UNUSED void *cookie)\n");
3835 oprintf (d
->of
, "{\n");
3838 d
->process_field
= write_types_local_user_process_field
;
3840 oprintf (d
->of
, "}\n");
3844 /* Emit the user-callable functions needed to mark all the types used
3845 by the user structure S. PREFIX is the prefix to use to
3846 distinguish ggc and pch markers. CHAIN_NEXT is set if S has the
3847 chain_next option defined. D contains data needed to pass to
3848 walk_type when traversing the fields of a type.
3850 For every type T referenced by S, two routines are generated: one
3851 that takes 'T *', marks the pointer and calls the second routine,
3852 which just marks the fields of T. */
3855 write_pch_user_walking_functions (type_p s
, struct walk_type_data
*d
)
3857 gcc_assert (s
->kind
== TYPE_USER_STRUCT
);
3859 for (pair_p fld
= s
->u
.s
.fields
; fld
; fld
= fld
->next
)
3861 type_p fld_type
= fld
->type
;
3862 if (union_or_struct_p (fld_type
))
3863 write_pch_user_walking_for_structure_body (fld_type
, d
);
3868 /* process_field routine for local pointer-walking. */
3871 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
3873 gcc_assert (d
->have_this_obj
);
3879 case TYPE_LANG_STRUCT
:
3881 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
3883 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
3886 case TYPE_USER_STRUCT
:
3887 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
3889 if (d
->in_ptr_field
)
3890 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
3892 oprintf (d
->of
, "%*s gt_pch_nx (&(%s), op, cookie);\n",
3893 d
->indent
, "", d
->val
);
3901 case TYPE_UNDEFINED
:
3907 /* For S, a structure that's part of ORIG_S, and using parameters
3908 PARAM, write out a routine that:
3909 - Is of type gt_note_pointers
3910 - Calls PROCESS_FIELD on each field of S or its substructures.
3914 write_local_func_for_structure (const_type_p orig_s
, type_p s
)
3916 struct walk_type_data d
;
3918 /* Don't write fns for subclasses, only for the ultimate base class
3919 within an inheritance hierarchy. */
3920 if (s
->u
.s
.base_class
)
3923 memset (&d
, 0, sizeof (d
));
3924 d
.of
= get_output_file_for_structure (s
);
3925 d
.process_field
= write_types_local_process_field
;
3927 d
.line
= &s
->u
.s
.line
;
3928 d
.bitmap
= s
->u
.s
.bitmap
;
3929 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
3930 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
3931 d
.prev_val
[3] = "x";
3933 d
.fn_wants_lvalue
= true;
3935 oprintf (d
.of
, "\n");
3936 oprintf (d
.of
, "void\n");
3937 oprintf (d
.of
, "gt_pch_p_");
3938 output_mangled_typename (d
.of
, orig_s
);
3939 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
3941 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3942 "\tATTRIBUTE_UNUSED void *cookie)\n");
3943 oprintf (d
.of
, "{\n");
3944 oprintf (d
.of
, " %s %s * x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
3945 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
3946 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
3948 d
.have_this_obj
= true;
3950 if (s
->kind
!= TYPE_USER_STRUCT
)
3954 /* User structures have no fields to walk. Simply generate a
3955 call to the user-provided PCH walker. */
3956 oprintf (d
.of
, "%*sif ((void *)(%s) == this_obj)\n", d
.indent
, "",
3958 oprintf (d
.of
, "%*s gt_pch_nx (&(%s), op, cookie);\n",
3959 d
.indent
, "", d
.val
);
3962 oprintf (d
.of
, "}\n");
3964 /* Write user-callable entry points for the PCH walking routines. */
3965 if (orig_s
->kind
== TYPE_USER_STRUCT
)
3966 write_pch_user_walking_functions (s
, &d
);
3968 for (options_p o
= s
->u
.s
.opt
; o
; o
= o
->next
)
3969 if (strcmp (o
->name
, "for_user") == 0)
3971 write_pch_user_walking_for_structure_body (s
, &d
);
3976 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
3979 write_local (outf_p output_header
, type_p structures
)
3986 oprintf (output_header
, "\n/* Local pointer-walking routines. */\n");
3987 for (s
= structures
; s
; s
= s
->next
)
3988 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3992 if (s
->u
.s
.line
.file
== NULL
)
3994 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3995 if (strcmp (opt
->name
, "ptr_alias") == 0
3996 && opt
->kind
== OPTION_TYPE
)
3998 const_type_p
const t
= (const_type_p
) opt
->info
.type
;
3999 if (t
->kind
== TYPE_STRUCT
4000 || t
->kind
== TYPE_UNION
|| t
->kind
== TYPE_LANG_STRUCT
)
4002 oprintf (output_header
, "#define gt_pch_p_");
4003 output_mangled_typename (output_header
, s
);
4004 oprintf (output_header
, " gt_pch_p_");
4005 output_mangled_typename (output_header
, t
);
4006 oprintf (output_header
, "\n");
4009 error_at_line (&s
->u
.s
.line
,
4010 "structure alias is not a structure");
4016 /* Declare the marker procedure only once. */
4017 oprintf (output_header
, "extern void gt_pch_p_");
4018 output_mangled_typename (output_header
, s
);
4019 oprintf (output_header
,
4020 "\n (void *, void *, gt_pointer_operator, void *);\n");
4022 if (s
->kind
== TYPE_LANG_STRUCT
)
4025 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
4026 write_local_func_for_structure (s
, ss
);
4029 write_local_func_for_structure (s
, s
);
4033 /* Nonzero if S is a type for which typed GC allocators should be output. */
4035 #define USED_BY_TYPED_GC_P(s) \
4036 ((s->kind == TYPE_POINTER \
4037 && (s->u.p->gc_used == GC_POINTED_TO \
4038 || s->u.p->gc_used == GC_USED)) \
4039 || (union_or_struct_p (s) \
4040 && ((s)->gc_used == GC_POINTED_TO \
4041 || ((s)->gc_used == GC_MAYBE_POINTED_TO \
4042 && s->u.s.line.file != NULL) \
4043 || ((s)->gc_used == GC_USED \
4044 && strncmp (s->u.s.tag, "anonymous", strlen ("anonymous"))) \
4045 || (s->u.s.base_class && opts_have (s->u.s.opt, "tag")))))
4049 /* Might T contain any non-pointer elements? */
4052 contains_scalar_p (type_p t
)
4060 return contains_scalar_p (t
->u
.a
.p
);
4061 case TYPE_USER_STRUCT
:
4062 /* User-marked structures will typically contain pointers. */
4065 /* Could also check for structures that have no non-pointer
4066 fields, but there aren't enough of those to worry about. */
4071 /* Mangle INPF and print it to F. */
4074 put_mangled_filename (outf_p f
, const input_file
*inpf
)
4076 /* The call to get_output_file_name may indirectly update fn since
4077 get_output_file_with_visibility caches its result inside, so we
4078 need the CONST_CAST. */
4079 const char *name
= get_output_file_name (CONST_CAST (input_file
*, inpf
));
4082 for (; *name
!= 0; name
++)
4083 if (ISALNUM (*name
))
4084 oprintf (f
, "%c", *name
);
4086 oprintf (f
, "%c", '_');
4089 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
4090 LASTNAME, and NAME are all strings to insert in various places in
4091 the resulting code. */
4094 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
4095 const char *tname
, const char *name
)
4099 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
4100 if (fli2
->started_p
)
4102 oprintf (fli2
->f
, " %s\n", lastname
);
4103 oprintf (fli2
->f
, "};\n\n");
4106 for (fli2
= flp
; fli2
&& base_files
; fli2
= fli2
->next
)
4107 if (fli2
->started_p
)
4109 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
4112 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
4115 oprintf (base_files
[fnum
],
4116 "extern const struct %s gt_%s_", tname
, pfx
);
4117 put_mangled_filename (base_files
[fnum
], fli2
->file
);
4118 oprintf (base_files
[fnum
], "[];\n");
4124 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
4125 oprintf (base_files
[fnum
],
4126 "EXPORTED_CONST struct %s * const %s[] = {\n", tname
, name
);
4130 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
4131 if (fli2
->started_p
)
4133 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
4136 fli2
->started_p
= 0;
4138 for (fnum
= 0; base_files
&& bitmap
!= 0; fnum
++, bitmap
>>= 1)
4141 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
4142 put_mangled_filename (base_files
[fnum
], fli2
->file
);
4143 oprintf (base_files
[fnum
], ",\n");
4149 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
4151 oprintf (base_files
[fnum
], " NULL\n");
4152 oprintf (base_files
[fnum
], "};\n");
4157 /* Finish off the created gt_clear_caches_file_c functions. */
4160 finish_cache_funcs (flist
*flp
)
4164 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
4165 if (fli2
->started_p
)
4167 oprintf (fli2
->f
, "}\n\n");
4170 for (fli2
= flp
; fli2
&& base_files
; fli2
= fli2
->next
)
4171 if (fli2
->started_p
)
4173 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
4176 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
4179 oprintf (base_files
[fnum
], "extern void gt_clear_caches_");
4180 put_mangled_filename (base_files
[fnum
], fli2
->file
);
4181 oprintf (base_files
[fnum
], " ();\n");
4185 for (size_t fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
4186 oprintf (base_files
[fnum
], "void\ngt_clear_caches ()\n{\n");
4188 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
4189 if (fli2
->started_p
)
4191 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
4194 fli2
->started_p
= 0;
4196 for (fnum
= 0; base_files
&& bitmap
!= 0; fnum
++, bitmap
>>= 1)
4199 oprintf (base_files
[fnum
], " gt_clear_caches_");
4200 put_mangled_filename (base_files
[fnum
], fli2
->file
);
4201 oprintf (base_files
[fnum
], " ();\n");
4205 for (size_t fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
4207 oprintf (base_files
[fnum
], "}\n");
4211 /* Write the first three fields (pointer, count and stride) for
4212 root NAME to F. V and LINE are as for write_root.
4214 Return true if the entry could be written; return false on error. */
4217 start_root_entry (outf_p f
, pair_p v
, const char *name
, struct fileloc
*line
)
4223 error_at_line (line
, "`%s' is too complex to be a root", name
);
4227 oprintf (f
, " {\n");
4228 oprintf (f
, " &%s,\n", name
);
4231 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
4233 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
4234 else if (ap
== v
->type
)
4235 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
4237 oprintf (f
, " sizeof (%s", v
->name
);
4238 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
4240 oprintf (f
, "),\n");
4244 /* A subroutine of write_root for writing the roots for field FIELD_NAME,
4245 which has type FIELD_TYPE. Parameters F to EMIT_PCH are the parameters
4249 write_field_root (outf_p f
, pair_p v
, type_p type
, const char *name
,
4250 int has_length
, struct fileloc
*line
,
4251 bool emit_pch
, type_p field_type
, const char *field_name
)
4254 /* If the field reference is relative to V, rather than to some
4255 subcomponent of V, we can mark any subarrays with a single stride.
4256 We're effectively treating the field as a global variable in its
4258 if (v
&& type
== v
->type
)
4261 newv
.type
= field_type
;
4262 newv
.name
= ACONCAT ((v
->name
, ".", field_name
, NULL
));
4265 /* Otherwise, any arrays nested in the structure are too complex to
4267 else if (field_type
->kind
== TYPE_ARRAY
)
4269 write_root (f
, v
, field_type
, ACONCAT ((name
, ".", field_name
, NULL
)),
4270 has_length
, line
, emit_pch
);
4273 /* Write out to F the table entry and any marker routines needed to
4274 mark NAME as TYPE. V can be one of three values:
4276 - null, if NAME is too complex to represent using a single
4277 count and stride. In this case, it is an error for NAME to
4278 contain any gc-ed data.
4280 - the outermost array that contains NAME, if NAME is part of an array.
4282 - the C variable that contains NAME, if NAME is not part of an array.
4284 LINE is the line of the C source that declares the root variable.
4285 HAS_LENGTH is nonzero iff V was a variable-length array. */
4288 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
4289 struct fileloc
*line
, bool emit_pch
)
4296 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
4299 const char *desc
= NULL
;
4302 for (o
= fld
->opt
; o
; o
= o
->next
)
4303 if (strcmp (o
->name
, "skip") == 0)
4305 else if (strcmp (o
->name
, "desc") == 0
4306 && o
->kind
== OPTION_STRING
)
4307 desc
= o
->info
.string
;
4309 error_at_line (line
,
4310 "field `%s' of global `%s' has unknown option `%s'",
4311 fld
->name
, name
, o
->name
);
4315 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
4317 pair_p validf
= NULL
;
4320 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
4322 const char *tag
= NULL
;
4324 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
4325 if (strcmp (oo
->name
, "tag") == 0
4326 && oo
->kind
== OPTION_STRING
)
4327 tag
= oo
->info
.string
;
4328 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
4331 error_at_line (line
,
4332 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
4333 name
, fld
->name
, validf
->name
,
4334 name
, fld
->name
, ufld
->name
, tag
);
4338 write_field_root (f
, v
, type
, name
, 0, line
, emit_pch
,
4340 ACONCAT ((fld
->name
, ".",
4341 validf
->name
, NULL
)));
4344 error_at_line (line
,
4345 "global `%s.%s' has `desc' option but is not union",
4348 write_field_root (f
, v
, type
, name
, 0, line
, emit_pch
, fld
->type
,
4357 newname
= xasprintf ("%s[0]", name
);
4358 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, emit_pch
);
4363 case TYPE_USER_STRUCT
:
4364 error_at_line (line
, "`%s' must be a pointer type, because it is "
4365 "a GC root and its type is marked with GTY((user))",
4373 if (!start_root_entry (f
, v
, name
, line
))
4378 if (!has_length
&& union_or_struct_p (tp
))
4380 tp
= get_ultimate_base_class (tp
);
4381 const char *id_for_tag
= filter_type_name (tp
->u
.s
.tag
);
4382 oprintf (f
, " >_ggc_mx_%s,\n", id_for_tag
);
4384 oprintf (f
, " >_pch_nx_%s", id_for_tag
);
4386 oprintf (f
, " NULL");
4387 if (id_for_tag
!= tp
->u
.s
.tag
)
4388 free (CONST_CAST (char *, id_for_tag
));
4391 && (tp
->kind
== TYPE_POINTER
|| union_or_struct_p (tp
)))
4393 oprintf (f
, " >_ggc_ma_%s,\n", name
);
4395 oprintf (f
, " >_pch_na_%s", name
);
4397 oprintf (f
, " NULL");
4401 error_at_line (line
,
4402 "global `%s' is pointer to unimplemented type",
4405 oprintf (f
, "\n },\n");
4411 if (!start_root_entry (f
, v
, name
, line
))
4414 oprintf (f
, " (gt_pointer_walker) >_ggc_m_S,\n");
4415 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
4416 oprintf (f
, " },\n");
4424 case TYPE_UNDEFINED
:
4426 case TYPE_LANG_STRUCT
:
4427 error_at_line (line
, "global `%s' is unimplemented type", name
);
4431 /* This generates a routine to walk an array. */
4434 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
4436 struct walk_type_data d
;
4439 memset (&d
, 0, sizeof (d
));
4445 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
4447 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
4449 if (wtd
->param_prefix
)
4451 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
4452 oprintf (f
, " (void *, void *, gt_pointer_operator, void *);\n");
4453 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
4454 wtd
->param_prefix
, v
->name
);
4456 " ATTRIBUTE_UNUSED void *x_p,\n"
4457 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
4458 " ATTRIBUTE_UNUSED void * cookie)\n");
4459 oprintf (d
.of
, "{\n");
4460 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
4461 d
.process_field
= write_types_local_process_field
;
4462 d
.have_this_obj
= true;
4463 walk_type (v
->type
, &d
);
4464 oprintf (f
, "}\n\n");
4468 oprintf (f
, "static void gt_%sa_%s (void *);\n", wtd
->prefix
, v
->name
);
4469 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
4470 wtd
->prefix
, v
->name
);
4472 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
4473 d
.process_field
= write_types_process_field
;
4474 d
.have_this_obj
= false;
4475 walk_type (v
->type
, &d
);
4477 oprintf (f
, "}\n\n");
4480 /* Output a table describing the locations and types of VARIABLES. */
4483 write_roots (pair_p variables
, bool emit_pch
)
4486 struct flist
*flp
= NULL
;
4488 for (v
= variables
; v
; v
= v
->next
)
4491 get_output_file_with_visibility (CONST_CAST (input_file
*,
4494 const char *length
= NULL
;
4495 int deletable_p
= 0;
4497 for (o
= v
->opt
; o
; o
= o
->next
)
4498 if (strcmp (o
->name
, "length") == 0
4499 && o
->kind
== OPTION_STRING
)
4500 length
= o
->info
.string
;
4501 else if (strcmp (o
->name
, "deletable") == 0)
4503 else if (strcmp (o
->name
, "cache") == 0)
4506 error_at_line (&v
->line
,
4507 "global `%s' has unknown option `%s'",
4510 for (fli
= flp
; fli
; fli
= fli
->next
)
4511 if (fli
->f
== f
&& f
)
4515 fli
= XNEW (struct flist
);
4519 fli
->file
= v
->line
.file
;
4520 gcc_assert (fli
->file
);
4523 oprintf (f
, "\n/* GC roots. */\n\n");
4528 && v
->type
->kind
== TYPE_POINTER
4529 && (v
->type
->u
.p
->kind
== TYPE_POINTER
4530 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
4532 write_array (f
, v
, &ggc_wtd
);
4533 write_array (f
, v
, &pch_wtd
);
4537 for (v
= variables
; v
; v
= v
->next
)
4539 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4546 for (o
= v
->opt
; o
; o
= o
->next
)
4547 if (strcmp (o
->name
, "length") == 0)
4549 else if (strcmp (o
->name
, "deletable") == 0)
4555 for (fli
= flp
; fli
; fli
= fli
->next
)
4558 if (!fli
->started_p
)
4562 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
4563 put_mangled_filename (f
, v
->line
.file
);
4564 oprintf (f
, "[] = {\n");
4567 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, emit_pch
);
4570 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4573 for (v
= variables
; v
; v
= v
->next
)
4575 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4581 for (o
= v
->opt
; o
; o
= o
->next
)
4582 if (strcmp (o
->name
, "deletable") == 0)
4588 for (fli
= flp
; fli
; fli
= fli
->next
)
4591 if (!fli
->started_p
)
4595 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
4596 put_mangled_filename (f
, v
->line
.file
);
4597 oprintf (f
, "[] = {\n");
4600 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
4604 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4605 "gt_ggc_deletable_rtab");
4607 for (v
= variables
; v
; v
= v
->next
)
4609 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4615 for (o
= v
->opt
; o
; o
= o
->next
)
4616 if (strcmp (o
->name
, "cache") == 0)
4621 for (fli
= flp
; fli
; fli
= fli
->next
)
4624 if (!fli
->started_p
)
4628 oprintf (f
, "void\ngt_clear_caches_");
4629 put_mangled_filename (f
, v
->line
.file
);
4630 oprintf (f
, " ()\n{\n");
4633 oprintf (f
, " gt_cleare_cache (%s);\n", v
->name
);
4636 finish_cache_funcs (flp
);
4641 for (v
= variables
; v
; v
= v
->next
)
4643 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4649 for (o
= v
->opt
; o
; o
= o
->next
)
4650 if (strcmp (o
->name
, "deletable") == 0)
4659 if (!contains_scalar_p (v
->type
))
4662 for (fli
= flp
; fli
; fli
= fli
->next
)
4665 if (!fli
->started_p
)
4669 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
4670 put_mangled_filename (f
, v
->line
.file
);
4671 oprintf (f
, "[] = {\n");
4674 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
4678 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4679 "gt_pch_scalar_rtab");
4682 /* Prints not-as-ugly version of a typename of T to OF. Trades the uniquness
4683 guaranteee for somewhat increased readability. If name conflicts do happen,
4684 this funcion will have to be adjusted to be more like
4685 output_mangled_typename. */
4689 /* Dumps the value of typekind KIND. */
4692 dump_typekind (int indent
, enum typekind kind
)
4694 printf ("%*ckind = ", indent
, ' ');
4698 printf ("TYPE_SCALAR");
4701 printf ("TYPE_STRING");
4704 printf ("TYPE_STRUCT");
4706 case TYPE_UNDEFINED
:
4707 printf ("TYPE_UNDEFINED");
4709 case TYPE_USER_STRUCT
:
4710 printf ("TYPE_USER_STRUCT");
4713 printf ("TYPE_UNION");
4716 printf ("TYPE_POINTER");
4719 printf ("TYPE_ARRAY");
4721 case TYPE_LANG_STRUCT
:
4722 printf ("TYPE_LANG_STRUCT");
4730 /* Dumps the value of GC_USED flag. */
4733 dump_gc_used (int indent
, enum gc_used_enum gc_used
)
4735 printf ("%*cgc_used = ", indent
, ' ');
4739 printf ("GC_UNUSED");
4744 case GC_MAYBE_POINTED_TO
:
4745 printf ("GC_MAYBE_POINTED_TO");
4748 printf ("GC_POINTED_TO");
4756 /* Dumps the type options OPT. */
4759 dump_options (int indent
, options_p opt
)
4762 printf ("%*coptions = ", indent
, ' ');
4769 printf ("%s:string %s ", o
->name
, o
->info
.string
);
4772 printf ("%s:type ", o
->name
);
4773 dump_type (indent
+1, o
->info
.type
);
4776 printf ("%s:nested ", o
->name
);
4786 /* Dumps the source file location in LINE. */
4789 dump_fileloc (int indent
, struct fileloc line
)
4791 printf ("%*cfileloc: file = %s, line = %d\n", indent
, ' ',
4792 get_input_file_name (line
.file
),
4796 /* Recursively dumps the struct, union, or a language-specific
4800 dump_type_u_s (int indent
, type_p t
)
4804 gcc_assert (union_or_struct_p (t
));
4805 printf ("%*cu.s.tag = %s\n", indent
, ' ', t
->u
.s
.tag
);
4806 dump_fileloc (indent
, t
->u
.s
.line
);
4807 printf ("%*cu.s.fields =\n", indent
, ' ');
4808 fields
= t
->u
.s
.fields
;
4811 dump_pair (indent
+ INDENT
, fields
);
4812 fields
= fields
->next
;
4814 printf ("%*cend of fields of type %p\n", indent
, ' ', (void *) t
);
4815 dump_options (indent
, t
->u
.s
.opt
);
4816 printf ("%*cu.s.bitmap = %X\n", indent
, ' ', t
->u
.s
.bitmap
);
4817 if (t
->kind
== TYPE_LANG_STRUCT
)
4819 printf ("%*cu.s.lang_struct:\n", indent
, ' ');
4820 dump_type_list (indent
+ INDENT
, t
->u
.s
.lang_struct
);
4824 /* Recursively dumps the array T. */
4827 dump_type_u_a (int indent
, type_p t
)
4829 gcc_assert (t
->kind
== TYPE_ARRAY
);
4830 printf ("%*clen = %s, u.a.p:\n", indent
, ' ', t
->u
.a
.len
);
4831 dump_type_list (indent
+ INDENT
, t
->u
.a
.p
);
4834 /* Recursively dumps the type list T. */
4837 dump_type_list (int indent
, type_p t
)
4842 dump_type (indent
, p
);
4847 static htab_t seen_types
;
4849 /* Recursively dumps the type T if it was not dumped previously. */
4852 dump_type (int indent
, type_p t
)
4856 printf ("%*cType at %p: ", indent
, ' ', (void *) t
);
4857 if (t
->kind
== TYPE_UNDEFINED
)
4859 gcc_assert (t
->gc_used
== GC_UNUSED
);
4860 printf ("undefined.\n");
4864 if (seen_types
== NULL
)
4865 seen_types
= htab_create (100, htab_hash_pointer
, htab_eq_pointer
, NULL
);
4867 slot
= htab_find_slot (seen_types
, t
, INSERT
);
4870 printf ("already seen.\n");
4876 dump_typekind (indent
, t
->kind
);
4877 printf ("%*cpointer_to = %p\n", indent
+ INDENT
, ' ',
4878 (void *) t
->pointer_to
);
4879 dump_gc_used (indent
+ INDENT
, t
->gc_used
);
4883 printf ("%*cscalar_is_char = %s\n", indent
+ INDENT
, ' ',
4884 t
->u
.scalar_is_char
? "true" : "false");
4890 case TYPE_LANG_STRUCT
:
4891 case TYPE_USER_STRUCT
:
4892 dump_type_u_s (indent
+ INDENT
, t
);
4895 printf ("%*cp:\n", indent
+ INDENT
, ' ');
4896 dump_type (indent
+ INDENT
, t
->u
.p
);
4899 dump_type_u_a (indent
+ INDENT
, t
);
4904 printf ("%*cEnd of type at %p\n", indent
, ' ', (void *) t
);
4907 /* Dumps the pair P. */
4910 dump_pair (int indent
, pair_p p
)
4912 printf ("%*cpair: name = %s\n", indent
, ' ', p
->name
);
4913 dump_type (indent
, p
->type
);
4914 dump_fileloc (indent
, p
->line
);
4915 dump_options (indent
, p
->opt
);
4916 printf ("%*cEnd of pair %s\n", indent
, ' ', p
->name
);
4919 /* Dumps the list of pairs PP. */
4922 dump_pair_list (const char *name
, pair_p pp
)
4925 printf ("%s:\n", name
);
4926 for (p
= pp
; p
!= NULL
; p
= p
->next
)
4928 printf ("End of %s\n\n", name
);
4931 /* Dumps the STRUCTURES. */
4934 dump_structures (const char *name
, type_p structures
)
4936 printf ("%s:\n", name
);
4937 dump_type_list (0, structures
);
4938 printf ("End of %s\n\n", name
);
4941 /* Dumps the internal structures of gengtype. This is useful to debug
4942 gengtype itself, or to understand what it does, e.g. for plugin
4946 dump_everything (void)
4948 dump_pair_list ("typedefs", typedefs
);
4949 dump_structures ("structures", structures
);
4950 dump_pair_list ("variables", variables
);
4952 /* Allocated with the first call to dump_type. */
4953 htab_delete (seen_types
);
4958 /* Option specification for getopt_long. */
4959 static const struct option gengtype_long_options
[] = {
4960 {"help", no_argument
, NULL
, 'h'},
4961 {"version", no_argument
, NULL
, 'V'},
4962 {"verbose", no_argument
, NULL
, 'v'},
4963 {"dump", no_argument
, NULL
, 'd'},
4964 {"debug", no_argument
, NULL
, 'D'},
4965 {"plugin", required_argument
, NULL
, 'P'},
4966 {"srcdir", required_argument
, NULL
, 'S'},
4967 {"backupdir", required_argument
, NULL
, 'B'},
4968 {"inputs", required_argument
, NULL
, 'I'},
4969 {"read-state", required_argument
, NULL
, 'r'},
4970 {"write-state", required_argument
, NULL
, 'w'},
4971 /* Terminating NULL placeholder. */
4972 {NULL
, no_argument
, NULL
, 0},
4979 printf ("Usage: %s\n", progname
);
4980 printf ("\t -h | --help " " \t# Give this help.\n");
4981 printf ("\t -D | --debug "
4982 " \t# Give debug output to debug %s itself.\n", progname
);
4983 printf ("\t -V | --version " " \t# Give version information.\n");
4984 printf ("\t -v | --verbose \t# Increase verbosity. Can be given several times.\n");
4985 printf ("\t -d | --dump " " \t# Dump state for debugging.\n");
4986 printf ("\t -P | --plugin <output-file> <plugin-src> ... "
4987 " \t# Generate for plugin.\n");
4988 printf ("\t -S | --srcdir <GCC-directory> "
4989 " \t# Specify the GCC source directory.\n");
4990 printf ("\t -B | --backupdir <directory> "
4991 " \t# Specify the backup directory for updated files.\n");
4992 printf ("\t -I | --inputs <input-list> "
4993 " \t# Specify the file with source files list.\n");
4994 printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n");
4995 printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n");
4999 print_version (void)
5001 printf ("%s %s%s\n", progname
, pkgversion_string
, version_string
);
5002 printf ("Report bugs: %s\n", bug_report_url
);
5005 /* Parse the program options using getopt_long... */
5007 parse_program_options (int argc
, char **argv
)
5010 while ((opt
= getopt_long (argc
, argv
, "hVvdP:S:B:I:w:r:D",
5011 gengtype_long_options
, NULL
)) >= 0)
5015 case 'h': /* --help */
5018 case 'V': /* --version */
5021 case 'd': /* --dump */
5024 case 'D': /* --debug */
5027 case 'v': /* --verbose */
5030 case 'P': /* --plugin */
5032 plugin_output_filename
= optarg
;
5034 fatal ("missing plugin output file name");
5036 case 'S': /* --srcdir */
5040 fatal ("missing source directory");
5041 srcdir_len
= strlen (srcdir
);
5043 case 'B': /* --backupdir */
5045 backup_dir
= optarg
;
5047 fatal ("missing backup directory");
5049 case 'I': /* --inputs */
5053 fatal ("missing input list");
5055 case 'r': /* --read-state */
5057 read_state_filename
= optarg
;
5059 fatal ("missing read state file");
5060 DBGPRINTF ("read state %s\n", optarg
);
5062 case 'w': /* --write-state */
5063 DBGPRINTF ("write state %s\n", optarg
);
5065 write_state_filename
= optarg
;
5067 fatal ("missing write state file");
5070 fprintf (stderr
, "%s: unknown flag '%c'\n", progname
, opt
);
5072 fatal ("unexpected flag");
5075 if (plugin_output_filename
)
5077 /* In plugin mode we require some input files. */
5080 fatal ("no source files given in plugin mode");
5081 nb_plugin_files
= argc
- optind
;
5082 plugin_files
= XNEWVEC (input_file
*, nb_plugin_files
);
5083 for (i
= 0; i
< (int) nb_plugin_files
; i
++)
5085 char *name
= argv
[i
+ optind
];
5086 plugin_files
[i
] = input_file_by_name (name
);
5093 /******* Manage input files. ******/
5095 /* Hash table of unique input file names. */
5096 static htab_t input_file_htab
;
5098 /* Find or allocate a new input_file by hash-consing it. */
5100 input_file_by_name (const char* name
)
5103 input_file
* f
= NULL
;
5107 namlen
= strlen (name
);
5108 f
= XCNEWVAR (input_file
, sizeof (input_file
)+namlen
+2);
5111 f
->inpisplugin
= false;
5112 strcpy (f
->inpname
, name
);
5113 slot
= htab_find_slot (input_file_htab
, f
, INSERT
);
5114 gcc_assert (slot
!= NULL
);
5117 /* Already known input file. */
5119 return (input_file
*)(*slot
);
5121 /* New input file. */
5126 /* Hash table support routines for input_file-s. */
5128 htab_hash_inputfile (const void *p
)
5130 const input_file
*inpf
= (const input_file
*) p
;
5132 return htab_hash_string (get_input_file_name (inpf
));
5136 htab_eq_inputfile (const void *x
, const void *y
)
5138 const input_file
*inpfx
= (const input_file
*) x
;
5139 const input_file
*inpfy
= (const input_file
*) y
;
5140 gcc_assert (inpfx
!= NULL
&& inpfy
!= NULL
);
5141 return !filename_cmp (get_input_file_name (inpfx
), get_input_file_name (inpfy
));
5146 main (int argc
, char **argv
)
5149 static struct fileloc pos
= { NULL
, 0 };
5150 outf_p output_header
;
5152 /* Mandatory common initializations. */
5153 progname
= "gengtype"; /* For fatal and messages. */
5154 /* Create the hash-table used to hash-cons input files. */
5156 htab_create (800, htab_hash_inputfile
, htab_eq_inputfile
, NULL
);
5157 /* Initialize our special input files. */
5158 this_file
= input_file_by_name (__FILE__
);
5159 system_h_file
= input_file_by_name ("system.h");
5160 /* Set the scalar_is_char union number for predefined scalar types. */
5161 scalar_nonchar
.u
.scalar_is_char
= FALSE
;
5162 scalar_char
.u
.scalar_is_char
= TRUE
;
5164 parse_program_options (argc
, argv
);
5168 time_t now
= (time_t) 0;
5170 DBGPRINTF ("gengtype started pid %d at %s",
5171 (int) getpid (), ctime (&now
));
5174 /* Parse the input list and the input files. */
5175 DBGPRINTF ("inputlist %s", inputlist
);
5176 if (read_state_filename
)
5179 fatal ("input list %s cannot be given with a read state file %s",
5180 inputlist
, read_state_filename
);
5181 read_state (read_state_filename
);
5182 DBGPRINT_COUNT_TYPE ("structures after read_state", structures
);
5186 /* These types are set up with #define or else outside of where
5187 we can see them. We should initialize them before calling
5189 #define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \
5191 POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos
));
5192 POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos
));
5193 POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos
));
5194 POS_HERE (do_scalar_typedef ("double_int", &pos
));
5195 POS_HERE (do_scalar_typedef ("offset_int", &pos
));
5196 POS_HERE (do_scalar_typedef ("widest_int", &pos
));
5197 POS_HERE (do_scalar_typedef ("int64_t", &pos
));
5198 POS_HERE (do_scalar_typedef ("poly_int64", &pos
));
5199 POS_HERE (do_scalar_typedef ("uint64_t", &pos
));
5200 POS_HERE (do_scalar_typedef ("uint8", &pos
));
5201 POS_HERE (do_scalar_typedef ("uintptr_t", &pos
));
5202 POS_HERE (do_scalar_typedef ("jword", &pos
));
5203 POS_HERE (do_scalar_typedef ("JCF_u2", &pos
));
5204 POS_HERE (do_scalar_typedef ("void", &pos
));
5205 POS_HERE (do_scalar_typedef ("machine_mode", &pos
));
5206 POS_HERE (do_scalar_typedef ("fixed_size_mode", &pos
));
5207 POS_HERE (do_typedef ("PTR",
5208 create_pointer (resolve_typedef ("void", &pos
)),
5211 read_input_list (inputlist
);
5212 for (i
= 0; i
< num_gt_files
; i
++)
5214 parse_file (get_input_file_name (gt_files
[i
]));
5215 DBGPRINTF ("parsed file #%d %s",
5216 (int) i
, get_input_file_name (gt_files
[i
]));
5218 if (verbosity_level
>= 1)
5219 printf ("%s parsed %d files with %d GTY types\n",
5220 progname
, (int) num_gt_files
, type_count
);
5222 DBGPRINT_COUNT_TYPE ("structures after parsing", structures
);
5225 fatal ("either an input list or a read state file should be given");
5230 if (plugin_output_filename
)
5233 /* In plugin mode, we should have read a state file, and have
5234 given at least one plugin file. */
5235 if (!read_state_filename
)
5236 fatal ("No read state given in plugin mode for %s",
5237 plugin_output_filename
);
5239 if (nb_plugin_files
== 0 || !plugin_files
)
5240 fatal ("No plugin files given in plugin mode for %s",
5241 plugin_output_filename
);
5243 /* Parse our plugin files and augment the state. */
5244 for (ix
= 0; ix
< nb_plugin_files
; ix
++)
5246 input_file
* pluginput
= plugin_files
[ix
];
5247 pluginput
->inpisplugin
= true;
5248 parse_file (get_input_file_name (pluginput
));
5253 plugin_output
= create_file ("GCC", plugin_output_filename
);
5254 DBGPRINTF ("created plugin_output %p named %s",
5255 (void *) plugin_output
, plugin_output
->name
);
5258 { /* No plugin files, we are in normal mode. */
5260 fatal ("gengtype needs a source directory in normal mode");
5267 set_gc_used (variables
);
5269 for (type_p t
= structures
; t
; t
= t
->next
)
5271 bool for_user
= false;
5272 for (options_p o
= t
->u
.s
.opt
; o
; o
= o
->next
)
5273 if (strcmp (o
->name
, "for_user") == 0)
5280 set_gc_used_type (t
, GC_POINTED_TO
);
5282 /* The state at this point is read from the state input file or by
5283 parsing source files and optionally augmented by parsing plugin
5284 source files. Write it now. */
5285 if (write_state_filename
)
5287 DBGPRINT_COUNT_TYPE ("structures before write_state", structures
);
5290 fatal ("didn't write state file %s after errors",
5291 write_state_filename
);
5293 DBGPRINTF ("before write_state %s", write_state_filename
);
5294 write_state (write_state_filename
);
5299 /* After having written the state file we return immediately to
5300 avoid generating any output file. */
5310 output_header
= plugin_output
? plugin_output
: header_file
;
5311 DBGPRINT_COUNT_TYPE ("structures before write_types outputheader",
5314 write_types (output_header
, structures
, &ggc_wtd
);
5315 if (plugin_files
== NULL
)
5317 DBGPRINT_COUNT_TYPE ("structures before write_types headerfil",
5319 write_types (header_file
, structures
, &pch_wtd
);
5320 write_local (header_file
, structures
);
5322 write_roots (variables
, plugin_files
== NULL
);
5324 close_output_files ();
5329 /* Don't bother about free-ing any input or plugin file, etc. */