1 /* Process source files and output type information.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
24 #include "errors.h" /* for fatal */
25 #include "double-int.h"
27 /* Data types, macros, etc. used only in this file. */
29 /* Kinds of types we can understand. */
41 typedef unsigned lang_bitmap;
43 /* A way to pass data through to the output end. */
51 /* Option data for the 'nested_ptr' option. */
52 struct nested_ptr_data
55 const char *convert_to;
56 const char *convert_from;
59 /* A name and a type. */
71 /* A description of a type. */
85 enum gc_used_enum gc_used;
103 type_p param[NUM_PARAM];
110 ((x)->kind == TYPE_UNION || \
111 ((x)->kind == TYPE_LANG_STRUCT \
112 && (x)->u.s.lang_struct->kind == TYPE_UNION))
113 #define UNION_OR_STRUCT_P(x) \
114 ((x)->kind == TYPE_UNION \
115 || (x)->kind == TYPE_STRUCT \
116 || (x)->kind == TYPE_LANG_STRUCT)
118 /* Structure representing an output file. */
127 typedef struct outf * outf_p;
129 /* An output file, suitable for definitions, that can see declarations
130 made in INPUT_FILE and is linked into every language that uses
131 INPUT_FILE. May return NULL in plugin mode. */
132 extern outf_p get_output_file_with_visibility
133 (const char *input_file);
134 const char *get_output_file_name (const char *);
136 /* Print, like fprintf, to O. No-op if O is NULL. */
137 static void oprintf (outf_p o, const char *S, ...)
140 /* The list of output files. */
141 static outf_p output_files;
143 /* The plugin input files and their number; in that case only
144 corresponding gt-<plugin>.h are generated in the current
146 static char** plugin_files;
147 static size_t nb_plugin_files;
148 /* the generated plugin output name & file */
149 static outf_p plugin_output;
151 /* The output header file that is included into pretty much every
153 static outf_p header_file;
155 /* Source directory. */
156 static const char *srcdir;
158 /* Length of srcdir name. */
159 static size_t srcdir_len = 0;
161 static outf_p create_file (const char *, const char *);
163 static const char * get_file_basename (const char *);
164 static const char * get_file_realbasename (const char *);
165 static const char * get_file_srcdir_relative_path (const char *);
167 static int get_prefix_langdir_index (const char *);
168 static const char * get_file_langdir (const char *);
171 /* Nonzero iff an error has occurred. */
172 bool hit_error = false;
174 static void gen_rtx_next (void);
175 static void write_rtx_next (void);
176 static void open_base_files (void);
177 static void close_output_files (void);
179 /* Report an error at POS, printing MSG. */
182 error_at_line (struct fileloc *pos, const char *msg, ...)
188 fprintf (stderr, "%s:%d: ", pos->file, pos->line);
189 vfprintf (stderr, msg, ap);
190 fputc ('\n', stderr);
196 /* asprintf, but produces fatal message on out-of-memory. */
198 xasprintf (const char *format, ...)
204 va_start (ap, format);
205 n = vasprintf (&result, format, ap);
206 if (result == NULL || n < 0)
207 fatal ("out of memory");
213 /* Input file handling. */
215 /* Table of all input files. */
216 static const char **gt_files;
217 static size_t num_gt_files;
219 /* A number of places use the name of this file for a location for
220 things that we can't rely on the source to define. Make sure we
221 can still use pointer comparison on filenames. */
222 static const char this_file[] = __FILE__;
224 /* Vector of per-language directories. */
225 static const char **lang_dir_names;
226 static size_t num_lang_dirs;
228 /* An array of output files suitable for definitions. There is one
229 BASE_FILES entry for each language. */
230 static outf_p *base_files;
232 /* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
233 INPUT_FILE is used by <lang>.
235 This function should be written to assume that a file _is_ used
236 if the situation is unclear. If it wrongly assumes a file _is_ used,
237 a linker error will result. If it wrongly assumes a file _is not_ used,
238 some GC roots may be missed, which is a much harder-to-debug problem.
240 The relevant bitmap is stored immediately before the file's name in the
241 buffer set up by read_input_list. It may be unaligned, so we have to
242 read it byte-by-byte. */
245 get_lang_bitmap (const char *gtfile)
248 if (gtfile == this_file)
249 /* Things defined in this file are universal. */
250 return (((lang_bitmap)1) << num_lang_dirs) - 1;
255 for (i = -(int) sizeof (lang_bitmap); i < 0; i++)
256 n = (n << CHAR_BIT) + (unsigned char)gtfile[i];
261 /* Set the bitmap returned by get_lang_bitmap. The only legitimate
262 caller of this function is read_input_list. */
264 set_lang_bitmap (char *gtfile, lang_bitmap n)
267 for (i = -1; i >= -(int) sizeof (lang_bitmap); i--)
269 gtfile[i] = n & ((1U << CHAR_BIT)-1);
274 /* Scan the input file, LIST, and determine how much space we need to
275 store strings in. Also, count the number of language directories
276 and files. The numbers returned are overestimates as they does not
277 consider repeated files. */
279 measure_input_list (FILE *list)
285 num_gt_files = plugin_files ? nb_plugin_files : 0;
286 while ((c = getc (list)) != EOF)
295 /* Add space for a lang_bitmap before the input file name. */
296 n += sizeof (lang_bitmap);
310 /* Read one input line from LIST to HEREP (which is updated). A
311 pointer to the string is returned via LINEP. If it was a language
312 subdirectory in square brackets, strip off the square brackets and
313 return true. Otherwise, leave space before the string for a
314 lang_bitmap, and return false. At EOF, returns false, does not
315 touch *HEREP, and sets *LINEP to NULL. POS is used for
318 read_input_line (FILE *list, char **herep, char **linep,
325 /* Read over whitespace. */
326 while (c == '\n' || c == ' ')
336 /* No space for a lang_bitmap is necessary. Discard the '['. */
339 while (c != ']' && c != '\n' && c != EOF)
348 c = getc (list); /* eat what should be a newline */
349 if (c != '\n' && c != EOF)
350 error_at_line (pos, "junk on line after language tag [%s]", line);
353 error_at_line (pos, "missing close bracket for language tag [%s", line);
361 /* Leave space for a lang_bitmap. */
362 memset (here, 0, sizeof (lang_bitmap));
363 here += sizeof (lang_bitmap);
370 while (c != EOF && c != '\n');
378 /* Read the list of input files from LIST and compute all of the
379 relevant tables. There is one file per line of the list. At
380 first, all the files on the list are language-generic, but
381 eventually a line will appear which is the name of a language
382 subdirectory in square brackets, like this: [cp]. All subsequent
383 files are specific to that language, until another language
384 subdirectory tag appears. Files can appear more than once, if
385 they apply to more than one language. */
387 read_input_list (const char *listname)
389 FILE *list = fopen (listname, "r");
391 fatal ("cannot open %s: %s", listname, strerror (errno));
395 size_t bufsz = measure_input_list (list);
396 char *buf = XNEWVEC (char, bufsz);
398 char *committed = buf;
399 char *limit = buf + bufsz;
404 lang_bitmap curlangs = (1 << num_lang_dirs) - 1;
406 epos.file = listname;
409 lang_dir_names = XNEWVEC (const char *, num_lang_dirs);
410 gt_files = XNEWVEC (const char *, num_gt_files);
417 is_language = read_input_line (list, &here, &line, &epos);
418 gcc_assert (here <= limit);
421 else if (is_language)
424 gcc_assert (langno <= num_lang_dirs);
425 for (i = 0; i < langno; i++)
426 if (strcmp (lang_dir_names[i], line) == 0)
428 error_at_line (&epos, "duplicate language tag [%s]", line);
434 curlangs = 1 << langno;
435 lang_dir_names[langno++] = line;
440 gcc_assert (nfiles <= num_gt_files);
441 for (i = 0; i < nfiles; i++)
442 if (strcmp (gt_files[i], line) == 0)
444 /* Throw away the string we just read, and add the
445 current language to the existing string's bitmap. */
446 lang_bitmap bmap = get_lang_bitmap (gt_files[i]);
448 error_at_line (&epos, "file %s specified more than once "
449 "for language %s", line, langno == 0
451 : lang_dir_names[langno - 1]);
454 set_lang_bitmap (CONST_CAST(char *, gt_files[i]), bmap);
459 set_lang_bitmap (line, curlangs);
460 gt_files[nfiles++] = line;
463 /* Update the global counts now that we know accurately how many
464 things there are. (We do not bother resizing the arrays down.) */
465 num_lang_dirs = langno;
466 /* Add the plugin files if provided. */
470 for (i = 0; i < nb_plugin_files; i++)
471 gt_files[nfiles++] = plugin_files[i];
473 num_gt_files = nfiles;
476 /* Sanity check: any file that resides in a language subdirectory
477 (e.g. 'cp') ought to belong to the corresponding language.
478 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
479 (Can you even do that? Should you be allowed to?) */
482 for (f = 0; f < num_gt_files; f++)
484 lang_bitmap bitmap = get_lang_bitmap (gt_files[f]);
485 const char *basename = get_file_basename (gt_files[f]);
486 const char *slashpos = strchr (basename, '/');
491 for (l = 0; l < num_lang_dirs; l++)
492 if ((size_t)(slashpos - basename) == strlen (lang_dir_names [l])
493 && memcmp (basename, lang_dir_names[l],
494 strlen (lang_dir_names[l])) == 0)
496 if (!(bitmap & (1 << l)))
497 error ("%s is in language directory '%s' but is not "
498 "tagged for that language",
499 basename, lang_dir_names[l]);
507 fatal ("error reading %s: %s", listname, strerror (errno));
514 /* The one and only TYPE_STRING. */
516 static struct type string_type = {
517 TYPE_STRING, 0, 0, GC_USED, {0}
520 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
521 set to appropriate values at the beginning of main. */
523 static struct type scalar_nonchar = {
524 TYPE_SCALAR, 0, 0, GC_USED, {0}
526 static struct type scalar_char = {
527 TYPE_SCALAR, 0, 0, GC_USED, {0}
530 /* Lists of various things. */
532 static pair_p typedefs;
533 static type_p structures;
534 static type_p param_structs;
535 static pair_p variables;
537 static type_p find_param_structure
538 (type_p t, type_p param[NUM_PARAM]);
539 static type_p adjust_field_tree_exp (type_p t, options_p opt);
540 static type_p adjust_field_rtx_def (type_p t, options_p opt);
542 /* Define S as a typedef to T at POS. */
545 do_typedef (const char *s, type_p t, struct fileloc *pos)
549 /* temporary kludge - gengtype doesn't handle conditionals or
550 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
551 is coming from this file (main() sets them up with safe dummy
553 if (!strcmp (s, "CUMULATIVE_ARGS") && pos->file != this_file)
556 for (p = typedefs; p != NULL; p = p->next)
557 if (strcmp (p->name, s) == 0)
561 error_at_line (pos, "type `%s' previously defined", s);
562 error_at_line (&p->line, "previously defined here");
567 p = XNEW (struct pair);
575 /* Define S as a typename of a scalar. Cannot be used to define
576 typedefs of 'char'. Note: is also used for pointer-to-function
577 typedefs (which are therefore not treated as pointers). */
580 do_scalar_typedef (const char *s, struct fileloc *pos)
582 do_typedef (s, &scalar_nonchar, pos);
585 /* Return the type previously defined for S. Use POS to report errors. */
588 resolve_typedef (const char *s, struct fileloc *pos)
591 for (p = typedefs; p != NULL; p = p->next)
592 if (strcmp (p->name, s) == 0)
594 error_at_line (pos, "unidentified type `%s'", s);
595 return &scalar_nonchar; /* treat as "int" */
598 /* Create and return a new structure with tag NAME (or a union iff
599 ISUNION is nonzero), at POS with fields FIELDS and options O. */
602 new_structure (const char *name, int isunion, struct fileloc *pos,
603 pair_p fields, options_p o)
607 lang_bitmap bitmap = get_lang_bitmap (pos->file);
609 /* temporary kludge - gengtype doesn't handle conditionals or
610 macros. Ignore any attempt to define struct location_s, unless
611 it is coming from this file (main() sets it up safely). */
612 if (!strcmp (name, "location_s") && !isunion
613 && pos->file != this_file)
614 return find_structure (name, 0);
616 for (si = structures; si != NULL; si = si->next)
617 if (strcmp (name, si->u.s.tag) == 0
618 && UNION_P (si) == isunion)
621 if (si->kind == TYPE_LANG_STRUCT)
625 for (si = ls->u.s.lang_struct; si != NULL; si = si->next)
626 if (si->u.s.bitmap == bitmap)
629 else if (si->u.s.line.file != NULL && si->u.s.bitmap != bitmap)
632 si = XCNEW (struct type);
633 memcpy (si, ls, sizeof (struct type));
634 ls->kind = TYPE_LANG_STRUCT;
635 ls->u.s.lang_struct = si;
636 ls->u.s.fields = NULL;
638 si->pointer_to = NULL;
639 si->u.s.lang_struct = ls;
644 if (ls != NULL && s == NULL)
646 s = XCNEW (struct type);
647 s->next = ls->u.s.lang_struct;
648 ls->u.s.lang_struct = s;
649 s->u.s.lang_struct = ls;
656 s = XCNEW (struct type);
657 s->next = structures;
661 if (s->u.s.line.file != NULL
662 || (s->u.s.lang_struct && (s->u.s.lang_struct->u.s.bitmap & bitmap)))
664 error_at_line (pos, "duplicate definition of '%s %s'",
665 isunion ? "union" : "struct", s->u.s.tag);
666 error_at_line (&s->u.s.line, "previous definition here");
669 s->kind = isunion ? TYPE_UNION : TYPE_STRUCT;
672 s->u.s.fields = fields;
674 s->u.s.bitmap = bitmap;
675 if (s->u.s.lang_struct)
676 s->u.s.lang_struct->u.s.bitmap |= bitmap;
678 /* Reset location_s's location to input.h so that we know where to
679 write out its mark routine. */
680 if (!strcmp (name, "location_s") && !isunion
681 && pos->file == this_file)
684 for (n = 0; n < num_gt_files; n++)
685 if (!strcmp (gt_files[n] + strlen (gt_files[n]) - strlen ("input.h"),
688 s->u.s.line.file = gt_files[n];
696 /* Return the previously-defined structure with tag NAME (or a union
697 iff ISUNION is nonzero), or a new empty structure or union if none
698 was defined previously. */
701 find_structure (const char *name, int isunion)
705 for (s = structures; s != NULL; s = s->next)
706 if (strcmp (name, s->u.s.tag) == 0
707 && UNION_P (s) == isunion)
710 s = XCNEW (struct type);
711 s->next = structures;
713 s->kind = isunion ? TYPE_UNION : TYPE_STRUCT;
719 /* Return the previously-defined parameterized structure for structure
720 T and parameters PARAM, or a new parameterized empty structure or
721 union if none was defined previously. */
724 find_param_structure (type_p t, type_p param[NUM_PARAM])
728 for (res = param_structs; res; res = res->next)
729 if (res->u.param_struct.stru == t
730 && memcmp (res->u.param_struct.param, param,
731 sizeof (type_p) * NUM_PARAM) == 0)
735 res = XCNEW (struct type);
736 res->kind = TYPE_PARAM_STRUCT;
737 res->next = param_structs;
739 res->u.param_struct.stru = t;
740 memcpy (res->u.param_struct.param, param, sizeof (type_p) * NUM_PARAM);
745 /* Return a scalar type with name NAME. */
748 create_scalar_type (const char *name)
750 if (!strcmp (name, "char") || !strcmp (name, "unsigned char"))
753 return &scalar_nonchar;
756 /* Return a pointer to T. */
759 create_pointer (type_p t)
763 type_p r = XCNEW (struct type);
764 r->kind = TYPE_POINTER;
768 return t->pointer_to;
771 /* Return an array of length LEN. */
774 create_array (type_p t, const char *len)
778 v = XCNEW (struct type);
779 v->kind = TYPE_ARRAY;
785 /* Return an options structure with name NAME and info INFO. NEXT is the
786 next option in the chain. */
789 create_option (options_p next, const char *name, const void *info)
791 options_p o = XNEW (struct options);
794 o->info = (const char*) info;
798 /* Return an options structure for a "nested_ptr" option. */
800 create_nested_ptr_option (options_p next, type_p t,
801 const char *to, const char *from)
803 struct nested_ptr_data *d = XNEW (struct nested_ptr_data);
805 d->type = adjust_field_type (t, 0);
807 d->convert_from = from;
808 return create_option (next, "nested_ptr", d);
811 /* Add a variable named S of type T with options O defined at POS,
815 note_variable (const char *s, type_p t, options_p o, struct fileloc *pos)
818 n = XNEW (struct pair);
827 /* Most-general structure field creator. */
829 create_field_all (pair_p next, type_p type, const char *name, options_p opt,
830 const char *file, int line)
834 field = XNEW (struct pair);
839 field->line.file = file;
840 field->line.line = line;
844 /* Create a field that came from the source code we are scanning,
845 i.e. we have a 'struct fileloc', and possibly options; also,
846 adjust_field_type should be called. */
848 create_field_at (pair_p next, type_p type, const char *name, options_p opt,
851 return create_field_all (next, adjust_field_type (type, opt),
852 name, opt, pos->file, pos->line);
855 /* Create a fake field with the given type and name. NEXT is the next
856 field in the chain. */
857 #define create_field(next,type,name) \
858 create_field_all(next,type,name, 0, this_file, __LINE__)
860 /* Like create_field, but the field is only valid when condition COND
864 create_optional_field_ (pair_p next, type_p type, const char *name,
865 const char *cond, int line)
871 /* Create a fake union type with a single nameless field of type TYPE.
872 The field has a tag of "1". This allows us to make the presence
873 of a field of type TYPE depend on some boolean "desc" being true. */
874 union_fields = create_field (NULL, type, "");
875 union_fields->opt = create_option (union_fields->opt, "dot", "");
876 union_fields->opt = create_option (union_fields->opt, "tag", "1");
877 union_type = new_structure (xasprintf ("%s_%d", "fake_union", id++), 1,
878 &lexer_line, union_fields, NULL);
880 /* Create the field and give it the new fake union type. Add a "desc"
881 tag that specifies the condition under which the field is valid. */
882 return create_field_all (next, union_type, name,
883 create_option (0, "desc", cond),
886 #define create_optional_field(next,type,name,cond) \
887 create_optional_field_(next,type,name,cond,__LINE__)
889 /* Reverse a linked list of 'struct pair's in place. */
891 nreverse_pairs (pair_p list)
893 pair_p prev = 0, p, next;
894 for (p = list; p; p = next)
904 /* We don't care how long a CONST_DOUBLE is. */
905 #define CONST_DOUBLE_FORMAT "ww"
906 /* We don't want to see codes that are only for generator files. */
907 #undef GENERATOR_FILE
910 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
916 static const char * const rtx_name[NUM_RTX_CODE] = {
917 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
922 static const char * const rtx_format[NUM_RTX_CODE] = {
923 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
928 static int rtx_next_new[NUM_RTX_CODE];
930 /* We also need codes and names for insn notes (not register notes).
931 Note that we do *not* bias the note values here. */
933 #define DEF_INSN_NOTE(NAME) NAME,
934 #include "insn-notes.def"
940 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
941 default field for line number notes. */
942 static const char *const note_insn_name[NOTE_INSN_MAX+1] = {
943 #define DEF_INSN_NOTE(NAME) #NAME,
944 #include "insn-notes.def"
948 #undef CONST_DOUBLE_FORMAT
949 #define GENERATOR_FILE
951 /* Generate the contents of the rtx_next array. This really doesn't belong
952 in gengtype at all, but it's needed for adjust_field_rtx_def. */
958 for (i = 0; i < NUM_RTX_CODE; i++)
962 rtx_next_new[i] = -1;
963 if (strncmp (rtx_format[i], "iuu", 3) == 0)
965 else if (i == COND_EXEC || i == SET || i == EXPR_LIST || i == INSN_LIST)
968 for (k = strlen (rtx_format[i]) - 1; k >= 0; k--)
969 if (rtx_format[i][k] == 'e' || rtx_format[i][k] == 'u')
974 /* Write out the contents of the rtx_next array. */
976 write_rtx_next (void)
978 outf_p f = get_output_file_with_visibility (NULL);
983 oprintf (f, "\n/* Used to implement the RTX_NEXT macro. */\n");
984 oprintf (f, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
985 for (i = 0; i < NUM_RTX_CODE; i++)
986 if (rtx_next_new[i] == -1)
987 oprintf (f, " 0,\n");
990 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n",
995 /* Handle `special("rtx_def")'. This is a special case for field
996 `fld' of struct rtx_def, which is an array of unions whose values
997 are based in a complex way on the type of RTL. */
1000 adjust_field_rtx_def (type_p t, options_p ARG_UNUSED (opt))
1005 type_p rtx_tp, rtvec_tp, tree_tp, mem_attrs_tp, note_union_tp, scalar_tp;
1006 type_p bitmap_tp, basic_block_tp, reg_attrs_tp, constant_tp, symbol_union_tp;
1008 if (t->kind != TYPE_UNION)
1010 error_at_line (&lexer_line,
1011 "special `rtx_def' must be applied to a union");
1012 return &string_type;
1015 nodot = create_option (NULL, "dot", "");
1017 rtx_tp = create_pointer (find_structure ("rtx_def", 0));
1018 rtvec_tp = create_pointer (find_structure ("rtvec_def", 0));
1019 tree_tp = create_pointer (find_structure ("tree_node", 1));
1020 mem_attrs_tp = create_pointer (find_structure ("mem_attrs", 0));
1021 reg_attrs_tp = create_pointer (find_structure ("reg_attrs", 0));
1022 bitmap_tp = create_pointer (find_structure ("bitmap_element_def", 0));
1023 basic_block_tp = create_pointer (find_structure ("basic_block_def", 0));
1024 constant_tp = create_pointer (find_structure ("constant_descriptor_rtx", 0));
1025 scalar_tp = &scalar_nonchar; /* rtunion int */
1028 pair_p note_flds = NULL;
1031 for (c = 0; c <= NOTE_INSN_MAX; c++)
1036 case NOTE_INSN_DELETED_LABEL:
1037 note_flds = create_field (note_flds, &string_type, "rt_str");
1040 case NOTE_INSN_BLOCK_BEG:
1041 case NOTE_INSN_BLOCK_END:
1042 note_flds = create_field (note_flds, tree_tp, "rt_tree");
1045 case NOTE_INSN_VAR_LOCATION:
1046 note_flds = create_field (note_flds, rtx_tp, "rt_rtx");
1050 note_flds = create_field (note_flds, scalar_tp, "rt_int");
1053 /* NOTE_INSN_MAX is used as the default field for line
1055 if (c == NOTE_INSN_MAX)
1056 note_flds->opt = create_option (nodot, "default", "");
1058 note_flds->opt = create_option (nodot, "tag", note_insn_name[c]);
1060 note_union_tp = new_structure ("rtx_def_note_subunion", 1,
1061 &lexer_line, note_flds, NULL);
1063 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1067 sym_flds = create_field (NULL, tree_tp, "rt_tree");
1068 sym_flds->opt = create_option (nodot, "default", "");
1070 sym_flds = create_field (sym_flds, constant_tp, "rt_constant");
1071 sym_flds->opt = create_option (nodot, "tag", "1");
1073 symbol_union_tp = new_structure ("rtx_def_symbol_subunion", 1,
1074 &lexer_line, sym_flds, NULL);
1076 for (i = 0; i < NUM_RTX_CODE; i++)
1078 pair_p subfields = NULL;
1079 size_t aindex, nmindex;
1084 for (aindex = 0; aindex < strlen (rtx_format[i]); aindex++)
1087 const char *subname;
1089 switch (rtx_format[i][aindex])
1100 if (i == MEM && aindex == 1)
1101 t = mem_attrs_tp, subname = "rt_mem";
1102 else if (i == JUMP_INSN && aindex == 8)
1103 t = rtx_tp, subname = "rt_rtx";
1104 else if (i == CODE_LABEL && aindex == 4)
1105 t = scalar_tp, subname = "rt_int";
1106 else if (i == CODE_LABEL && aindex == 5)
1107 t = rtx_tp, subname = "rt_rtx";
1108 else if (i == LABEL_REF
1109 && (aindex == 1 || aindex == 2))
1110 t = rtx_tp, subname = "rt_rtx";
1111 else if (i == NOTE && aindex == 4)
1112 t = note_union_tp, subname = "";
1113 else if (i == NOTE && aindex == 5)
1114 t = scalar_tp, subname = "rt_int";
1115 else if (i == NOTE && aindex >= 7)
1116 t = scalar_tp, subname = "rt_int";
1117 else if (i == ADDR_DIFF_VEC && aindex == 4)
1118 t = scalar_tp, subname = "rt_int";
1119 else if (i == VALUE && aindex == 0)
1120 t = scalar_tp, subname = "rt_int";
1121 else if (i == REG && aindex == 1)
1122 t = scalar_tp, subname = "rt_int";
1123 else if (i == REG && aindex == 2)
1124 t = reg_attrs_tp, subname = "rt_reg";
1125 else if (i == SCRATCH && aindex == 0)
1126 t = scalar_tp, subname = "rt_int";
1127 else if (i == SYMBOL_REF && aindex == 1)
1128 t = scalar_tp, subname = "rt_int";
1129 else if (i == SYMBOL_REF && aindex == 2)
1130 t = symbol_union_tp, subname = "";
1131 else if (i == BARRIER && aindex >= 3)
1132 t = scalar_tp, subname = "rt_int";
1135 error_at_line (&lexer_line,
1136 "rtx type `%s' has `0' in position %lu, can't handle",
1137 rtx_name[i], (unsigned long) aindex);
1159 subname = "rt_rtvec";
1164 subname = "rt_tree";
1178 error_at_line (&lexer_line,
1179 "rtx type `%s' has `%c' in position %lu, can't handle",
1180 rtx_name[i], rtx_format[i][aindex],
1181 (unsigned long)aindex);
1187 subfields = create_field (subfields, t,
1188 xasprintf (".fld[%lu].%s",
1189 (unsigned long) aindex,
1191 subfields->opt = nodot;
1192 if (t == note_union_tp)
1193 subfields->opt = create_option (subfields->opt, "desc",
1195 if (t == symbol_union_tp)
1196 subfields->opt = create_option (subfields->opt, "desc",
1197 "CONSTANT_POOL_ADDRESS_P (&%0)");
1200 if (i == SYMBOL_REF)
1202 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds. */
1203 type_p field_tp = find_structure ("block_symbol", 0);
1205 = create_optional_field (subfields, field_tp, "block_sym",
1206 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1209 sname = xasprintf ("rtx_def_%s", rtx_name[i]);
1210 substruct = new_structure (sname, 0, &lexer_line, subfields, NULL);
1212 ftag = xstrdup (rtx_name[i]);
1213 for (nmindex = 0; nmindex < strlen (ftag); nmindex++)
1214 ftag[nmindex] = TOUPPER (ftag[nmindex]);
1216 flds = create_field (flds, substruct, "");
1217 flds->opt = create_option (nodot, "tag", ftag);
1220 return new_structure ("rtx_def_subunion", 1, &lexer_line, flds, nodot);
1223 /* Handle `special("tree_exp")'. This is a special case for
1224 field `operands' of struct tree_exp, which although it claims to contain
1225 pointers to trees, actually sometimes contains pointers to RTL too.
1226 Passed T, the old type of the field, and OPT its options. Returns
1227 a new type for the field. */
1230 adjust_field_tree_exp (type_p t, options_p opt ATTRIBUTE_UNUSED)
1235 if (t->kind != TYPE_ARRAY)
1237 error_at_line (&lexer_line,
1238 "special `tree_exp' must be applied to an array");
1239 return &string_type;
1242 nodot = create_option (NULL, "dot", "");
1244 flds = create_field (NULL, t, "");
1245 flds->opt = create_option (nodot, "length",
1246 "TREE_OPERAND_LENGTH ((tree) &%0)");
1247 flds->opt = create_option (flds->opt, "default", "");
1249 return new_structure ("tree_exp_subunion", 1, &lexer_line, flds, nodot);
1252 /* Perform any special processing on a type T, about to become the type
1253 of a field. Return the appropriate type for the field.
1255 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1256 - Similarly for arrays of pointer-to-char;
1257 - Converts structures for which a parameter is provided to
1259 - Handles "special" options.
1263 adjust_field_type (type_p t, options_p opt)
1266 const int pointer_p = t->kind == TYPE_POINTER;
1267 type_p params[NUM_PARAM];
1271 for (i = 0; i < NUM_PARAM; i++)
1274 for (; opt; opt = opt->next)
1275 if (strcmp (opt->name, "length") == 0)
1277 else if (strcmp (opt->name, "param_is") == 0
1278 || (strncmp (opt->name, "param", 5) == 0
1279 && ISDIGIT (opt->name[5])
1280 && strcmp (opt->name + 6, "_is") == 0))
1282 int num = ISDIGIT (opt->name[5]) ? opt->name[5] - '0' : 0;
1284 if (! UNION_OR_STRUCT_P (t)
1285 && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p)))
1287 error_at_line (&lexer_line,
1288 "option `%s' may only be applied to structures or structure pointers",
1294 if (params[num] != NULL)
1295 error_at_line (&lexer_line, "duplicate `%s' option", opt->name);
1296 if (! ISDIGIT (opt->name[5]))
1297 params[num] = create_pointer (CONST_CAST2(type_p, const char *, opt->info));
1299 params[num] = CONST_CAST2 (type_p, const char *, opt->info);
1301 else if (strcmp (opt->name, "special") == 0)
1303 const char *special_name = opt->info;
1304 if (strcmp (special_name, "tree_exp") == 0)
1305 t = adjust_field_tree_exp (t, opt);
1306 else if (strcmp (special_name, "rtx_def") == 0)
1307 t = adjust_field_rtx_def (t, opt);
1309 error_at_line (&lexer_line, "unknown special `%s'", special_name);
1318 realt = find_param_structure (t, params);
1319 t = pointer_p ? create_pointer (realt) : realt;
1324 && t->u.p->kind == TYPE_SCALAR
1325 && t->u.p->u.scalar_is_char)
1326 return &string_type;
1327 if (t->kind == TYPE_ARRAY && t->u.a.p->kind == TYPE_POINTER
1328 && t->u.a.p->u.p->kind == TYPE_SCALAR
1329 && t->u.a.p->u.p->u.scalar_is_char)
1330 return create_array (&string_type, t->u.a.len);
1336 static void set_gc_used_type (type_p, enum gc_used_enum, type_p *);
1337 static void set_gc_used (pair_p);
1339 /* Handle OPT for set_gc_used_type. */
1342 process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef,
1343 int *pass_param, int *length, int *skip, type_p *nested_ptr)
1346 for (o = opt; o; o = o->next)
1347 if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO)
1348 set_gc_used_type (CONST_CAST2 (type_p, const char *, o->info),
1349 GC_POINTED_TO, NULL);
1350 else if (strcmp (o->name, "maybe_undef") == 0)
1352 else if (strcmp (o->name, "use_params") == 0)
1354 else if (strcmp (o->name, "length") == 0)
1356 else if (strcmp (o->name, "skip") == 0)
1358 else if (strcmp (o->name, "nested_ptr") == 0)
1359 *nested_ptr = ((const struct nested_ptr_data *) o->info)->type;
1362 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1365 set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM])
1367 if (t->gc_used >= level)
1381 process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, &dummy,
1384 for (f = t->u.s.fields; f; f = f->next)
1386 int maybe_undef = 0;
1390 type_p nested_ptr = NULL;
1391 process_gc_options (f->opt, level, &maybe_undef, &pass_param,
1392 &length, &skip, &nested_ptr);
1394 if (nested_ptr && f->type->kind == TYPE_POINTER)
1395 set_gc_used_type (nested_ptr, GC_POINTED_TO,
1396 pass_param ? param : NULL);
1397 else if (length && f->type->kind == TYPE_POINTER)
1398 set_gc_used_type (f->type->u.p, GC_USED, NULL);
1399 else if (maybe_undef && f->type->kind == TYPE_POINTER)
1400 set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO, NULL);
1401 else if (pass_param && f->type->kind == TYPE_POINTER && param)
1402 set_gc_used_type (find_param_structure (f->type->u.p, param),
1403 GC_POINTED_TO, NULL);
1405 ; /* target type is not used through this field */
1407 set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL);
1413 set_gc_used_type (t->u.p, GC_POINTED_TO, NULL);
1417 set_gc_used_type (t->u.a.p, GC_USED, param);
1420 case TYPE_LANG_STRUCT:
1421 for (t = t->u.s.lang_struct; t; t = t->next)
1422 set_gc_used_type (t, level, param);
1425 case TYPE_PARAM_STRUCT:
1428 for (i = 0; i < NUM_PARAM; i++)
1429 if (t->u.param_struct.param[i] != 0)
1430 set_gc_used_type (t->u.param_struct.param[i], GC_USED, NULL);
1432 if (t->u.param_struct.stru->gc_used == GC_POINTED_TO)
1433 level = GC_POINTED_TO;
1436 t->u.param_struct.stru->gc_used = GC_UNUSED;
1437 set_gc_used_type (t->u.param_struct.stru, level,
1438 t->u.param_struct.param);
1446 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1449 set_gc_used (pair_p variables)
1452 for (p = variables; p; p = p->next)
1453 set_gc_used_type (p->type, GC_USED, NULL);
1456 /* File mapping routines. For each input file, there is one output .c file
1457 (but some output files have many input files), and there is one .h file
1458 for the whole build. */
1460 /* Output file handling. */
1462 /* Create and return an outf_p for a new file for NAME, to be called
1466 create_file (const char *name, const char *oname)
1468 static const char *const hdr[] = {
1469 " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n",
1471 "This file is part of GCC.\n",
1473 "GCC is free software; you can redistribute it and/or modify it under\n",
1474 "the terms of the GNU General Public License as published by the Free\n",
1475 "Software Foundation; either version 3, or (at your option) any later\n",
1478 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1479 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1480 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1481 "for more details.\n",
1483 "You should have received a copy of the GNU General Public License\n",
1484 "along with GCC; see the file COPYING3. If not see\n",
1485 "<http://www.gnu.org/licenses/>. */\n",
1487 "/* This file is machine generated. Do not edit. */\n"
1492 gcc_assert (name != NULL);
1493 gcc_assert (oname != NULL);
1494 f = XCNEW (struct outf);
1495 f->next = output_files;
1499 oprintf (f, "/* Type information for %s.\n", name);
1500 for (i = 0; i < ARRAY_SIZE (hdr); i++)
1501 oprintf (f, "%s", hdr[i]);
1505 /* Print, like fprintf, to O.
1506 N.B. You might think this could be implemented more efficiently
1507 with vsnprintf(). Unfortunately, there are C libraries that
1508 provide that function but without the C99 semantics for its return
1509 value, making it impossible to know how much space is required. */
1511 oprintf (outf_p o, const char *format, ...)
1517 /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1522 va_start (ap, format);
1523 slength = vasprintf (&s, format, ap);
1524 if (s == NULL || (int)slength < 0)
1525 fatal ("out of memory");
1528 if (o->bufused + slength > o->buflength)
1530 size_t new_len = o->buflength;
1535 } while (o->bufused + slength >= new_len);
1536 o->buf = XRESIZEVEC (char, o->buf, new_len);
1537 o->buflength = new_len;
1539 memcpy (o->buf + o->bufused, s, slength);
1540 o->bufused += slength;
1544 /* Open the global header file and the language-specific header files. */
1547 open_base_files (void)
1551 if (nb_plugin_files > 0 && plugin_files)
1554 header_file = create_file ("GCC", "gtype-desc.h");
1556 base_files = XNEWVEC (outf_p, num_lang_dirs);
1558 for (i = 0; i < num_lang_dirs; i++)
1559 base_files[i] = create_file (lang_dir_names[i],
1560 xasprintf ("gtype-%s.h", lang_dir_names[i]));
1562 /* gtype-desc.c is a little special, so we create it here. */
1564 /* The order of files here matters very much. */
1565 static const char *const ifiles [] = {
1566 "config.h", "system.h", "coretypes.h", "tm.h", "varray.h",
1567 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1568 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1569 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1570 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1571 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1572 "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h",
1575 const char *const *ifp;
1576 outf_p gtype_desc_c;
1578 gtype_desc_c = create_file ("GCC", "gtype-desc.c");
1579 for (ifp = ifiles; *ifp; ifp++)
1580 oprintf (gtype_desc_c, "#include \"%s\"\n", *ifp);
1582 /* Make sure we handle "cfun" specially. */
1583 oprintf (gtype_desc_c, "\n/* See definition in function.h. */\n");
1584 oprintf (gtype_desc_c, "#undef cfun\n");
1588 /* For F a filename, return the real basename of F, with all the directory
1589 components skipped. */
1592 get_file_realbasename (const char *f)
1594 const char * lastslash = strrchr (f, '/');
1596 return (lastslash != NULL) ? lastslash + 1 : f;
1599 /* For F a filename, return the relative path to F from $(srcdir) if the
1600 latter is a prefix in F, NULL otherwise. */
1603 get_file_srcdir_relative_path (const char *f)
1605 if (strlen (f) > srcdir_len
1606 && IS_DIR_SEPARATOR (f[srcdir_len])
1607 && memcmp (f, srcdir, srcdir_len) == 0)
1608 return f + srcdir_len + 1;
1613 /* For F a filename, return the relative path to F from $(srcdir) if the
1614 latter is a prefix in F, or the real basename of F otherwise. */
1617 get_file_basename (const char *f)
1619 const char * srcdir_path = get_file_srcdir_relative_path (f);
1621 return (srcdir_path != NULL) ? srcdir_path : get_file_realbasename (f);
1624 /* For F a filename, return the lang_dir_names relative index of the language
1625 directory that is a prefix in F, if any, -1 otherwise. */
1628 get_prefix_langdir_index (const char *f)
1630 size_t f_len = strlen (f);
1633 for (lang_index = 0; lang_index < num_lang_dirs; lang_index++)
1635 const char * langdir = lang_dir_names [lang_index];
1636 size_t langdir_len = strlen (langdir);
1638 if (f_len > langdir_len
1639 && IS_DIR_SEPARATOR (f[langdir_len])
1640 && memcmp (f, langdir, langdir_len) == 0)
1647 /* For F a filename, return the name of language directory where F is located,
1648 if any, NULL otherwise. */
1651 get_file_langdir (const char *f)
1653 /* Get the relative path to F from $(srcdir) and find the language by
1654 comparing the prefix with language directory names. If F is not even
1655 srcdir relative, no point in looking further. */
1658 const char * srcdir_relative_path = get_file_srcdir_relative_path (f);
1660 if (!srcdir_relative_path)
1663 lang_index = get_prefix_langdir_index (srcdir_relative_path);
1665 return (lang_index >= 0) ? lang_dir_names [lang_index] : NULL;
1668 /* The gt- output file name for F. */
1671 get_file_gtfilename (const char *f)
1673 /* Cook up an initial version of the gt- file name from the file real
1674 basename and the language name, if any. */
1676 const char *basename = get_file_realbasename (f);
1677 const char *langdir = get_file_langdir (f);
1680 (langdir ? xasprintf ("gt-%s-%s", langdir, basename)
1681 : xasprintf ("gt-%s", basename));
1683 /* Then replace all non alphanumerics characters by '-' and change the
1684 extenstion to ".h". We expect the input filename extension was at least
1685 one character long. */
1689 for (; *s != '.'; s++)
1690 if (! ISALNUM (*s) && *s != '-')
1693 memcpy (s, ".h", sizeof (".h"));
1698 /* An output file, suitable for definitions, that can see declarations
1699 made in INPUT_FILE and is linked into every language that uses
1703 get_output_file_with_visibility (const char *input_file)
1707 const char *basename;
1708 const char *for_name;
1709 const char *output_name;
1711 /* This can happen when we need a file with visibility on a
1712 structure that we've never seen. We have to just hope that it's
1713 globally visible. */
1714 if (input_file == NULL)
1715 input_file = "system.h";
1717 /* In plugin mode, return NULL unless the input_file is one of the
1722 for (i = 0; i < nb_plugin_files; i++)
1723 if (strcmp (input_file, plugin_files[i]) == 0)
1724 return plugin_output;
1729 /* Determine the output file name. */
1730 basename = get_file_basename (input_file);
1732 len = strlen (basename);
1733 if ((len > 2 && memcmp (basename+len-2, ".c", 2) == 0)
1734 || (len > 2 && memcmp (basename+len-2, ".y", 2) == 0)
1735 || (len > 3 && memcmp (basename+len-3, ".in", 3) == 0))
1737 output_name = get_file_gtfilename (input_file);
1738 for_name = basename;
1740 /* Some headers get used by more than one front-end; hence, it
1741 would be inappropriate to spew them out to a single gtype-<lang>.h
1742 (and gengtype doesn't know how to direct spewage into multiple
1743 gtype-<lang>.h headers at this time). Instead, we pair up these
1744 headers with source files (and their special purpose gt-*.h headers). */
1745 else if (strcmp (basename, "c-common.h") == 0)
1746 output_name = "gt-c-common.h", for_name = "c-common.c";
1747 else if (strcmp (basename, "c-lang.h") == 0)
1748 output_name = "gt-c-decl.h", for_name = "c-decl.c";
1749 else if (strcmp (basename, "c-tree.h") == 0)
1750 output_name = "gt-c-decl.h", for_name = "c-decl.c";
1751 else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2])
1752 && strcmp (basename + 3, "cp-tree.h") == 0)
1753 output_name = "gt-cp-tree.h", for_name = "cp/tree.c";
1754 else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2])
1755 && strcmp (basename + 3, "decl.h") == 0)
1756 output_name = "gt-cp-decl.h", for_name = "cp/decl.c";
1757 else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2])
1758 && strcmp (basename + 3, "name-lookup.h") == 0)
1759 output_name = "gt-cp-name-lookup.h", for_name = "cp/name-lookup.c";
1760 else if (strncmp (basename, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename[4])
1761 && strcmp (basename + 5, "objc-act.h") == 0)
1762 output_name = "gt-objc-objc-act.h", for_name = "objc/objc-act.c";
1765 int lang_index = get_prefix_langdir_index (basename);
1767 if (lang_index >= 0)
1768 return base_files[lang_index];
1770 output_name = "gtype-desc.c";
1774 /* Look through to see if we've ever seen this output filename before. */
1775 for (r = output_files; r; r = r->next)
1776 if (strcmp (r->name, output_name) == 0)
1779 /* If not, create it. */
1780 r = create_file (for_name, output_name);
1782 gcc_assert (r && r->name);
1786 /* The name of an output file, suitable for definitions, that can see
1787 declarations made in INPUT_FILE and is linked into every language
1788 that uses INPUT_FILE. */
1791 get_output_file_name (const char *input_file)
1793 outf_p o = get_output_file_with_visibility (input_file);
1799 /* Check if existing file is equal to the in memory buffer. */
1802 is_file_equal (outf_p of)
1804 FILE *newfile = fopen (of->name, "r");
1807 if (newfile == NULL)
1811 for (i = 0; i < of->bufused; i++)
1814 ch = fgetc (newfile);
1815 if (ch == EOF || ch != (unsigned char) of->buf[i])
1825 /* Copy the output to its final destination,
1826 but don't unnecessarily change modification times. */
1829 close_output_files (void)
1833 for (of = output_files; of; of = of->next)
1836 if (!is_file_equal(of))
1838 FILE *newfile = fopen (of->name, "w");
1839 if (newfile == NULL)
1840 fatal ("opening output file %s: %s", of->name, strerror (errno));
1841 if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused)
1842 fatal ("writing output file %s: %s", of->name, strerror (errno));
1843 if (fclose (newfile) != 0)
1844 fatal ("closing output file %s: %s", of->name, strerror (errno));
1848 of->bufused = of->buflength = 0;
1859 struct walk_type_data;
1861 /* For scalars and strings, given the item in 'val'.
1862 For structures, given a pointer to the item in 'val'.
1863 For misc. pointers, given the item in 'val'.
1865 typedef void (*process_field_fn)
1866 (type_p f, const struct walk_type_data *p);
1867 typedef void (*func_name_fn)
1868 (type_p s, const struct walk_type_data *p);
1870 /* Parameters for write_types. */
1872 struct write_types_data
1875 const char *param_prefix;
1876 const char *subfield_marker_routine;
1877 const char *marker_routine;
1878 const char *reorder_note_routine;
1879 const char *comment;
1880 int skip_hooks; /* skip hook generation if non zero */
1883 static void output_escaped_param (struct walk_type_data *d,
1884 const char *, const char *);
1885 static void output_mangled_typename (outf_p, const_type_p);
1886 static void walk_type (type_p t, struct walk_type_data *d);
1887 static void write_func_for_structure
1888 (type_p orig_s, type_p s, type_p * param,
1889 const struct write_types_data *wtd);
1890 static void write_types_process_field
1891 (type_p f, const struct walk_type_data *d);
1892 static void write_types (outf_p output_header,
1894 type_p param_structs,
1895 const struct write_types_data *wtd);
1896 static void write_types_local_process_field
1897 (type_p f, const struct walk_type_data *d);
1898 static void write_local_func_for_structure
1899 (type_p orig_s, type_p s, type_p * param);
1900 static void write_local (outf_p output_header,
1902 type_p param_structs);
1903 static void write_enum_defn (type_p structures, type_p param_structs);
1904 static int contains_scalar_p (type_p t);
1905 static void put_mangled_filename (outf_p , const char *);
1906 static void finish_root_table (struct flist *flp, const char *pfx,
1907 const char *tname, const char *lastname,
1909 static void write_root (outf_p , pair_p, type_p, const char *, int,
1910 struct fileloc *, const char *, bool);
1911 static void write_array (outf_p f, pair_p v,
1912 const struct write_types_data *wtd);
1913 static void write_roots (pair_p, bool);
1915 /* Parameters for walk_type. */
1917 struct walk_type_data
1919 process_field_fn process_field;
1924 const char *prev_val[4];
1927 struct fileloc *line;
1932 const char *reorder_fn;
1934 bool fn_wants_lvalue;
1937 /* Print a mangled name representing T to OF. */
1940 output_mangled_typename (outf_p of, const_type_p t)
1944 else switch (t->kind)
1948 output_mangled_typename (of, t->u.p);
1958 case TYPE_LANG_STRUCT:
1959 oprintf (of, "%lu%s", (unsigned long) strlen (t->u.s.tag), t->u.s.tag);
1961 case TYPE_PARAM_STRUCT:
1964 for (i = 0; i < NUM_PARAM; i++)
1965 if (t->u.param_struct.param[i] != NULL)
1966 output_mangled_typename (of, t->u.param_struct.param[i]);
1967 output_mangled_typename (of, t->u.param_struct.stru);
1975 /* Print PARAM to D->OF processing escapes. D->VAL references the
1976 current object, D->PREV_VAL the object containing the current
1977 object, ONAME is the name of the option and D->LINE is used to
1978 print error messages. */
1981 output_escaped_param (struct walk_type_data *d, const char *param,
1986 for (p = param; *p; p++)
1988 oprintf (d->of, "%c", *p);
1992 oprintf (d->of, "(%s)", d->prev_val[2]);
1995 oprintf (d->of, "(%s)", d->prev_val[0]);
1998 oprintf (d->of, "(%s)", d->prev_val[1]);
2002 const char *pp = d->val + strlen (d->val);
2003 while (pp[-1] == ']')
2006 oprintf (d->of, "%s", pp);
2010 error_at_line (d->line, "`%s' option contains bad escape %c%c",
2015 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2016 which is of type T. Write code to D->OF to constrain execution (at
2017 the point that D->PROCESS_FIELD is called) to the appropriate
2018 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2019 pointers to those objects. D->PREV_VAL lists the objects
2020 containing the current object, D->OPT is a list of options to
2021 apply, D->INDENT is the current indentation level, D->LINE is used
2022 to print error messages, D->BITMAP indicates which languages to
2023 print the structure for, and D->PARAM is the current parameter
2024 (from an enclosing param_is option). */
2027 walk_type (type_p t, struct walk_type_data *d)
2029 const char *length = NULL;
2030 const char *desc = NULL;
2031 int maybe_undef_p = 0;
2032 int use_param_num = -1;
2033 int use_params_p = 0;
2035 const struct nested_ptr_data *nested_ptr_d = NULL;
2037 d->needs_cast_p = false;
2038 for (oo = d->opt; oo; oo = oo->next)
2039 if (strcmp (oo->name, "length") == 0)
2041 else if (strcmp (oo->name, "maybe_undef") == 0)
2043 else if (strncmp (oo->name, "use_param", 9) == 0
2044 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
2045 use_param_num = oo->name[9] == '\0' ? 0 : oo->name[9] - '0';
2046 else if (strcmp (oo->name, "use_params") == 0)
2048 else if (strcmp (oo->name, "desc") == 0)
2050 else if (strcmp (oo->name, "mark_hook") == 0)
2052 else if (strcmp (oo->name, "nested_ptr") == 0)
2053 nested_ptr_d = (const struct nested_ptr_data *) oo->info;
2054 else if (strcmp (oo->name, "dot") == 0)
2056 else if (strcmp (oo->name, "tag") == 0)
2058 else if (strcmp (oo->name, "special") == 0)
2060 else if (strcmp (oo->name, "skip") == 0)
2062 else if (strcmp (oo->name, "default") == 0)
2064 else if (strcmp (oo->name, "descbits") == 0)
2066 else if (strcmp (oo->name, "param_is") == 0)
2068 else if (strncmp (oo->name, "param", 5) == 0
2069 && ISDIGIT (oo->name[5])
2070 && strcmp (oo->name + 6, "_is") == 0)
2072 else if (strcmp (oo->name, "chain_next") == 0)
2074 else if (strcmp (oo->name, "chain_prev") == 0)
2076 else if (strcmp (oo->name, "chain_circular") == 0)
2078 else if (strcmp (oo->name, "reorder") == 0)
2081 error_at_line (d->line, "unknown option `%s'\n", oo->name);
2088 int pointer_p = t->kind == TYPE_POINTER;
2092 if (! UNION_OR_STRUCT_P (t))
2093 error_at_line (d->line, "`use_params' option on unimplemented type");
2095 t = find_param_structure (t, d->param);
2097 t = create_pointer (t);
2100 if (use_param_num != -1)
2102 if (d->param != NULL && d->param[use_param_num] != NULL)
2104 type_p nt = d->param[use_param_num];
2106 if (t->kind == TYPE_ARRAY)
2107 nt = create_array (nt, t->u.a.len);
2108 else if (length != NULL && t->kind == TYPE_POINTER)
2109 nt = create_pointer (nt);
2110 d->needs_cast_p = (t->kind != TYPE_POINTER
2111 && (nt->kind == TYPE_POINTER
2112 || nt->kind == TYPE_STRING));
2116 error_at_line (d->line, "no parameter defined for `%s'",
2121 && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p)))
2123 error_at_line (d->line,
2124 "field `%s' has invalid option `maybe_undef_p'\n",
2133 d->process_field (t, d);
2139 && t->u.p->u.s.line.file == NULL)
2141 oprintf (d->of, "%*sgcc_assert (!%s);\n", d->indent, "", d->val);
2147 if (! UNION_OR_STRUCT_P (t->u.p)
2148 && t->u.p->kind != TYPE_PARAM_STRUCT)
2150 error_at_line (d->line,
2151 "field `%s' is pointer to unimplemented type",
2158 const char *oldprevval2 = d->prev_val[2];
2160 if (! UNION_OR_STRUCT_P (nested_ptr_d->type))
2162 error_at_line (d->line,
2163 "field `%s' has invalid "
2164 "option `nested_ptr'\n",
2169 d->prev_val[2] = d->val;
2170 oprintf (d->of, "%*s{\n", d->indent, "");
2172 d->val = xasprintf ("x%d", d->counter++);
2173 oprintf (d->of, "%*s%s %s * %s%s =\n", d->indent, "",
2174 (nested_ptr_d->type->kind == TYPE_UNION
2175 ? "union" : "struct"),
2176 nested_ptr_d->type->u.s.tag,
2177 d->fn_wants_lvalue ? "" : "const ",
2179 oprintf (d->of, "%*s", d->indent + 2, "");
2180 output_escaped_param (d, nested_ptr_d->convert_from,
2182 oprintf (d->of, ";\n");
2184 d->process_field (nested_ptr_d->type, d);
2186 if (d->fn_wants_lvalue)
2188 oprintf (d->of, "%*s%s = ", d->indent, "",
2190 d->prev_val[2] = d->val;
2191 output_escaped_param (d, nested_ptr_d->convert_to,
2193 oprintf (d->of, ";\n");
2197 oprintf (d->of, "%*s}\n", d->indent, "");
2198 d->val = d->prev_val[2];
2199 d->prev_val[2] = oldprevval2;
2202 d->process_field (t->u.p, d);
2206 int loopcounter = d->counter++;
2207 const char *oldval = d->val;
2208 const char *oldprevval3 = d->prev_val[3];
2211 oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val);
2213 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
2214 oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent, "",
2215 loopcounter, loopcounter);
2216 output_escaped_param (d, length, "length");
2217 oprintf (d->of, "); i%d++) {\n", loopcounter);
2219 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
2221 d->prev_val[3] = oldval;
2222 walk_type (t->u.p, d);
2225 d->prev_val[3] = oldprevval3;
2228 oprintf (d->of, "%*s}\n", d->indent, "");
2229 d->process_field(t, d);
2231 oprintf (d->of, "%*s}\n", d->indent, "");
2238 int loopcounter = d->counter++;
2239 const char *oldval = d->val;
2242 /* If it's an array of scalars, we optimize by not generating
2244 if (t->u.a.p->kind == TYPE_SCALAR)
2247 /* When walking an array, compute the length and store it in a
2248 local variable before walking the array elements, instead of
2249 recomputing the length expression each time through the loop.
2250 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2251 where the length is stored in the first array element,
2252 because otherwise that operand can get overwritten on the
2254 oprintf (d->of, "%*s{\n", d->indent, "");
2256 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
2257 oprintf (d->of, "%*ssize_t l%d = (size_t)(",
2258 d->indent, "", loopcounter);
2260 output_escaped_param (d, length, "length");
2262 oprintf (d->of, "%s", t->u.a.len);
2263 oprintf (d->of, ");\n");
2265 oprintf (d->of, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2267 loopcounter, loopcounter, loopcounter, loopcounter);
2269 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
2271 walk_type (t->u.a.p, d);
2276 oprintf (d->of, "%*s}\n", d->indent, "");
2278 oprintf (d->of, "%*s}\n", d->indent, "");
2286 const char *oldval = d->val;
2287 const char *oldprevval1 = d->prev_val[1];
2288 const char *oldprevval2 = d->prev_val[2];
2289 const int union_p = t->kind == TYPE_UNION;
2290 int seen_default_p = 0;
2293 if (! t->u.s.line.file)
2294 error_at_line (d->line, "incomplete structure `%s'", t->u.s.tag);
2296 if ((d->bitmap & t->u.s.bitmap) != d->bitmap)
2298 error_at_line (d->line,
2299 "structure `%s' defined for mismatching languages",
2301 error_at_line (&t->u.s.line, "one structure defined here");
2304 /* Some things may also be defined in the structure's options. */
2305 for (o = t->u.s.opt; o; o = o->next)
2306 if (! desc && strcmp (o->name, "desc") == 0)
2309 d->prev_val[2] = oldval;
2310 d->prev_val[1] = oldprevval2;
2315 error_at_line (d->line, "missing `desc' option for union `%s'",
2319 oprintf (d->of, "%*sswitch (", d->indent, "");
2320 output_escaped_param (d, desc, "desc");
2321 oprintf (d->of, ")\n");
2323 oprintf (d->of, "%*s{\n", d->indent, "");
2325 for (f = t->u.s.fields; f; f = f->next)
2328 const char *dot = ".";
2329 const char *tagid = NULL;
2332 int use_param_p = 0;
2335 d->reorder_fn = NULL;
2336 for (oo = f->opt; oo; oo = oo->next)
2337 if (strcmp (oo->name, "dot") == 0)
2339 else if (strcmp (oo->name, "tag") == 0)
2341 else if (strcmp (oo->name, "skip") == 0)
2343 else if (strcmp (oo->name, "default") == 0)
2345 else if (strcmp (oo->name, "reorder") == 0)
2346 d->reorder_fn = oo->info;
2347 else if (strncmp (oo->name, "use_param", 9) == 0
2348 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
2354 if (union_p && tagid)
2356 oprintf (d->of, "%*scase %s:\n", d->indent, "", tagid);
2359 else if (union_p && default_p)
2361 oprintf (d->of, "%*sdefault:\n", d->indent, "");
2365 else if (! union_p && (default_p || tagid))
2366 error_at_line (d->line,
2367 "can't use `%s' outside a union on field `%s'",
2368 default_p ? "default" : "tag", f->name);
2369 else if (union_p && ! (default_p || tagid)
2370 && f->type->kind == TYPE_SCALAR)
2373 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2374 d->line->file, d->line->line, f->name);
2377 else if (union_p && ! (default_p || tagid))
2378 error_at_line (d->line,
2379 "field `%s' is missing `tag' or `default' option",
2383 d->val = newval = xasprintf ("%s%s%s", oldval, dot, f->name);
2385 d->used_length = false;
2387 if (union_p && use_param_p && d->param == NULL)
2388 oprintf (d->of, "%*sgcc_unreachable ();\n", d->indent, "");
2390 walk_type (f->type, d);
2396 oprintf (d->of, "%*sbreak;\n", d->indent, "");
2400 d->reorder_fn = NULL;
2403 d->prev_val[1] = oldprevval1;
2404 d->prev_val[2] = oldprevval2;
2406 if (union_p && ! seen_default_p)
2408 oprintf (d->of, "%*sdefault:\n", d->indent, "");
2409 oprintf (d->of, "%*s break;\n", d->indent, "");
2413 oprintf (d->of, "%*s}\n", d->indent, "");
2419 case TYPE_LANG_STRUCT:
2422 for (nt = t->u.s.lang_struct; nt; nt = nt->next)
2423 if ((d->bitmap & nt->u.s.bitmap) == d->bitmap)
2426 error_at_line (d->line, "structure `%s' differs between languages",
2433 case TYPE_PARAM_STRUCT:
2435 type_p *oldparam = d->param;
2437 d->param = t->u.param_struct.param;
2438 walk_type (t->u.param_struct.stru, d);
2439 d->param = oldparam;
2448 /* process_field routine for marking routines. */
2451 write_types_process_field (type_p f, const struct walk_type_data *d)
2453 const struct write_types_data *wtd;
2454 const char *cast = d->needs_cast_p ? "(void *)" : "";
2455 wtd = (const struct write_types_data *) d->cookie;
2460 oprintf (d->of, "%*s%s (%s%s", d->indent, "",
2461 wtd->subfield_marker_routine, cast, d->val);
2462 if (wtd->param_prefix)
2464 oprintf (d->of, ", %s", d->prev_val[3]);
2467 oprintf (d->of, ", gt_%s_", wtd->param_prefix);
2468 output_mangled_typename (d->of, d->orig_s);
2471 oprintf (d->of, ", gt_%sa_%s", wtd->param_prefix, d->prev_val[0]);
2473 if (f->u.p->kind == TYPE_PARAM_STRUCT
2474 && f->u.p->u.s.line.file != NULL)
2476 oprintf (d->of, ", gt_e_");
2477 output_mangled_typename (d->of, f);
2479 else if (UNION_OR_STRUCT_P (f)
2480 && f->u.p->u.s.line.file != NULL)
2482 oprintf (d->of, ", gt_ggc_e_");
2483 output_mangled_typename (d->of, f);
2486 oprintf (d->of, ", gt_types_enum_last");
2488 oprintf (d->of, ");\n");
2489 if (d->reorder_fn && wtd->reorder_note_routine)
2490 oprintf (d->of, "%*s%s (%s%s, %s, %s);\n", d->indent, "",
2491 wtd->reorder_note_routine, cast, d->val,
2492 d->prev_val[3], d->reorder_fn);
2498 case TYPE_LANG_STRUCT:
2499 case TYPE_PARAM_STRUCT:
2500 oprintf (d->of, "%*sgt_%s_", d->indent, "", wtd->prefix);
2501 output_mangled_typename (d->of, f);
2502 oprintf (d->of, " (%s%s);\n", cast, d->val);
2503 if (d->reorder_fn && wtd->reorder_note_routine)
2504 oprintf (d->of, "%*s%s (%s%s, %s%s, %s);\n", d->indent, "",
2505 wtd->reorder_note_routine, cast, d->val, cast, d->val,
2517 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2520 output_type_enum (outf_p of, type_p s)
2522 if (s->kind == TYPE_PARAM_STRUCT && s->u.s.line.file != NULL)
2524 oprintf (of, ", gt_e_");
2525 output_mangled_typename (of, s);
2527 else if (UNION_OR_STRUCT_P (s) && s->u.s.line.file != NULL)
2529 oprintf (of, ", gt_ggc_e_");
2530 output_mangled_typename (of, s);
2533 oprintf (of, ", gt_types_enum_last");
2536 /* For S, a structure that's part of ORIG_S, and using parameters
2537 PARAM, write out a routine that:
2538 - Takes a parameter, a void * but actually of type *S
2539 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2540 field of S or its substructures and (in some cases) things
2541 that are pointed to by S.
2545 write_func_for_structure (type_p orig_s, type_p s, type_p *param,
2546 const struct write_types_data *wtd)
2548 const char *fn = s->u.s.line.file;
2550 const char *chain_next = NULL;
2551 const char *chain_prev = NULL;
2552 const char *chain_circular = NULL;
2553 const char *mark_hook_name = NULL;
2555 struct walk_type_data d;
2557 /* This is a hack, and not the good kind either. */
2558 for (i = NUM_PARAM - 1; i >= 0; i--)
2559 if (param && param[i] && param[i]->kind == TYPE_POINTER
2560 && UNION_OR_STRUCT_P (param[i]->u.p))
2561 fn = param[i]->u.p->u.s.line.file;
2563 memset (&d, 0, sizeof (d));
2564 d.of = get_output_file_with_visibility (fn);
2566 for (opt = s->u.s.opt; opt; opt = opt->next)
2567 if (strcmp (opt->name, "chain_next") == 0)
2568 chain_next = opt->info;
2569 else if (strcmp (opt->name, "chain_prev") == 0)
2570 chain_prev = opt->info;
2571 else if (strcmp (opt->name, "chain_circular") == 0)
2572 chain_circular = opt->info;
2573 else if (strcmp (opt->name, "mark_hook") == 0)
2574 mark_hook_name = opt->info;
2576 if (chain_prev != NULL && chain_next == NULL)
2577 error_at_line (&s->u.s.line, "chain_prev without chain_next");
2578 if (chain_circular != NULL && chain_next != NULL)
2579 error_at_line (&s->u.s.line, "chain_circular with chain_next");
2580 if (chain_circular != NULL)
2581 chain_next = chain_circular;
2583 d.process_field = write_types_process_field;
2587 d.line = &s->u.s.line;
2588 d.bitmap = s->u.s.bitmap;
2590 d.prev_val[0] = "*x";
2591 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
2592 d.prev_val[3] = "x";
2595 oprintf (d.of, "\n");
2596 oprintf (d.of, "void\n");
2598 oprintf (d.of, "gt_%sx_%s", wtd->prefix, orig_s->u.s.tag);
2601 oprintf (d.of, "gt_%s_", wtd->prefix);
2602 output_mangled_typename (d.of, orig_s);
2604 oprintf (d.of, " (void *x_p)\n");
2605 oprintf (d.of, "{\n");
2606 oprintf (d.of, " %s %s * %sx = (%s %s *)x_p;\n",
2607 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag,
2608 chain_next == NULL ? "const " : "",
2609 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2610 if (chain_next != NULL)
2611 oprintf (d.of, " %s %s * xlimit = x;\n",
2612 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2613 if (chain_next == NULL)
2615 oprintf (d.of, " if (%s (x", wtd->marker_routine);
2616 if (wtd->param_prefix)
2618 oprintf (d.of, ", x, gt_%s_", wtd->param_prefix);
2619 output_mangled_typename (d.of, orig_s);
2620 output_type_enum (d.of, orig_s);
2622 oprintf (d.of, "))\n");
2626 if (chain_circular != NULL)
2627 oprintf (d.of, " if (!%s (xlimit", wtd->marker_routine);
2629 oprintf (d.of, " while (%s (xlimit", wtd->marker_routine);
2630 if (wtd->param_prefix)
2632 oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix);
2633 output_mangled_typename (d.of, orig_s);
2634 output_type_enum (d.of, orig_s);
2636 oprintf (d.of, "))\n");
2637 if (chain_circular != NULL)
2638 oprintf (d.of, " return;\n do\n");
2639 if (mark_hook_name && !wtd->skip_hooks)
2641 oprintf (d.of, " {\n");
2642 oprintf (d.of, " %s (xlimit);\n ", mark_hook_name);
2644 oprintf (d.of, " xlimit = (");
2645 d.prev_val[2] = "*xlimit";
2646 output_escaped_param (&d, chain_next, "chain_next");
2647 oprintf (d.of, ");\n");
2648 if (mark_hook_name && !wtd->skip_hooks)
2649 oprintf (d.of, " }\n");
2650 if (chain_prev != NULL)
2652 oprintf (d.of, " if (x != xlimit)\n");
2653 oprintf (d.of, " for (;;)\n");
2654 oprintf (d.of, " {\n");
2655 oprintf (d.of, " %s %s * const xprev = (",
2656 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2658 d.prev_val[2] = "*x";
2659 output_escaped_param (&d, chain_prev, "chain_prev");
2660 oprintf (d.of, ");\n");
2661 oprintf (d.of, " if (xprev == NULL) break;\n");
2662 oprintf (d.of, " x = xprev;\n");
2663 oprintf (d.of, " (void) %s (xprev",
2664 wtd->marker_routine);
2665 if (wtd->param_prefix)
2667 oprintf (d.of, ", xprev, gt_%s_", wtd->param_prefix);
2668 output_mangled_typename (d.of, orig_s);
2669 output_type_enum (d.of, orig_s);
2671 oprintf (d.of, ");\n");
2672 oprintf (d.of, " }\n");
2674 if (chain_circular != NULL)
2676 oprintf (d.of, " while (%s (xlimit", wtd->marker_routine);
2677 if (wtd->param_prefix)
2679 oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix);
2680 output_mangled_typename (d.of, orig_s);
2681 output_type_enum (d.of, orig_s);
2683 oprintf (d.of, "));\n");
2684 if (mark_hook_name && !wtd->skip_hooks)
2685 oprintf (d.of, " %s (xlimit);\n", mark_hook_name);
2686 oprintf (d.of, " do\n");
2689 oprintf (d.of, " while (x != xlimit)\n");
2691 oprintf (d.of, " {\n");
2692 if (mark_hook_name && chain_next == NULL && !wtd->skip_hooks)
2694 oprintf (d.of, " %s (x);\n", mark_hook_name);
2696 d.prev_val[2] = "*x";
2700 if (chain_next != NULL)
2702 oprintf (d.of, " x = (");
2703 output_escaped_param (&d, chain_next, "chain_next");
2704 oprintf (d.of, ");\n");
2707 oprintf (d.of, " }\n");
2708 if (chain_circular != NULL)
2709 oprintf (d.of, " while (x != xlimit);\n");
2710 oprintf (d.of, "}\n");
2713 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
2716 write_types (outf_p output_header, type_p structures, type_p param_structs,
2717 const struct write_types_data *wtd)
2721 oprintf (output_header, "\n/* %s*/\n", wtd->comment);
2722 for (s = structures; s; s = s->next)
2723 if (s->gc_used == GC_POINTED_TO
2724 || s->gc_used == GC_MAYBE_POINTED_TO)
2728 if (s->gc_used == GC_MAYBE_POINTED_TO
2729 && s->u.s.line.file == NULL)
2732 oprintf (output_header, "#define gt_%s_", wtd->prefix);
2733 output_mangled_typename (output_header, s);
2734 oprintf (output_header, "(X) do { \\\n");
2735 oprintf (output_header,
2736 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd->prefix,
2738 oprintf (output_header,
2741 for (opt = s->u.s.opt; opt; opt = opt->next)
2742 if (strcmp (opt->name, "ptr_alias") == 0)
2744 const_type_p const t = (const_type_p) opt->info;
2745 if (t->kind == TYPE_STRUCT
2746 || t->kind == TYPE_UNION
2747 || t->kind == TYPE_LANG_STRUCT)
2748 oprintf (output_header,
2749 "#define gt_%sx_%s gt_%sx_%s\n",
2750 wtd->prefix, s->u.s.tag, wtd->prefix, t->u.s.tag);
2752 error_at_line (&s->u.s.line,
2753 "structure alias is not a structure");
2759 /* Declare the marker procedure only once. */
2760 oprintf (output_header,
2761 "extern void gt_%sx_%s (void *);\n",
2762 wtd->prefix, s->u.s.tag);
2764 if (s->u.s.line.file == NULL)
2766 fprintf (stderr, "warning: structure `%s' used but not defined\n",
2771 if (s->kind == TYPE_LANG_STRUCT)
2774 for (ss = s->u.s.lang_struct; ss; ss = ss->next)
2775 write_func_for_structure (s, ss, NULL, wtd);
2778 write_func_for_structure (s, s, NULL, wtd);
2781 for (s = param_structs; s; s = s->next)
2782 if (s->gc_used == GC_POINTED_TO)
2784 type_p * param = s->u.param_struct.param;
2785 type_p stru = s->u.param_struct.stru;
2787 /* Declare the marker procedure. */
2788 oprintf (output_header, "extern void gt_%s_", wtd->prefix);
2789 output_mangled_typename (output_header, s);
2790 oprintf (output_header, " (void *);\n");
2792 if (stru->u.s.line.file == NULL)
2794 fprintf (stderr, "warning: structure `%s' used but not defined\n",
2799 if (stru->kind == TYPE_LANG_STRUCT)
2802 for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
2803 write_func_for_structure (s, ss, param, wtd);
2806 write_func_for_structure (s, stru, param, wtd);
2810 static const struct write_types_data ggc_wtd =
2812 "ggc_m", NULL, "ggc_mark", "ggc_test_and_set_mark", NULL,
2813 "GC marker procedures. ",
2817 static const struct write_types_data pch_wtd =
2819 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
2820 "gt_pch_note_reorder",
2821 "PCH type-walking procedures. ",
2825 /* Write out the local pointer-walking routines. */
2827 /* process_field routine for local pointer-walking. */
2830 write_types_local_process_field (type_p f, const struct walk_type_data *d)
2837 case TYPE_LANG_STRUCT:
2838 case TYPE_PARAM_STRUCT:
2840 oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "",
2842 oprintf (d->of, "%*s op (&(%s), cookie);\n", d->indent, "", d->val);
2853 /* For S, a structure that's part of ORIG_S, and using parameters
2854 PARAM, write out a routine that:
2855 - Is of type gt_note_pointers
2856 - Calls PROCESS_FIELD on each field of S or its substructures.
2860 write_local_func_for_structure (type_p orig_s, type_p s, type_p *param)
2862 const char *fn = s->u.s.line.file;
2864 struct walk_type_data d;
2866 /* This is a hack, and not the good kind either. */
2867 for (i = NUM_PARAM - 1; i >= 0; i--)
2868 if (param && param[i] && param[i]->kind == TYPE_POINTER
2869 && UNION_OR_STRUCT_P (param[i]->u.p))
2870 fn = param[i]->u.p->u.s.line.file;
2872 memset (&d, 0, sizeof (d));
2873 d.of = get_output_file_with_visibility (fn);
2874 d.process_field = write_types_local_process_field;
2876 d.line = &s->u.s.line;
2877 d.bitmap = s->u.s.bitmap;
2879 d.prev_val[0] = d.prev_val[2] = "*x";
2880 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
2881 d.prev_val[3] = "x";
2883 d.fn_wants_lvalue = true;
2885 oprintf (d.of, "\n");
2886 oprintf (d.of, "void\n");
2887 oprintf (d.of, "gt_pch_p_");
2888 output_mangled_typename (d.of, orig_s);
2889 oprintf (d.of, " (ATTRIBUTE_UNUSED void *this_obj,\n"
2891 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2892 "\tATTRIBUTE_UNUSED void *cookie)\n");
2893 oprintf (d.of, "{\n");
2894 oprintf (d.of, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
2895 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag,
2896 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2899 oprintf (d.of, "}\n");
2902 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
2905 write_local (outf_p output_header, type_p structures, type_p param_structs)
2911 oprintf (output_header, "\n/* Local pointer-walking routines. */\n");
2912 for (s = structures; s; s = s->next)
2913 if (s->gc_used == GC_POINTED_TO
2914 || s->gc_used == GC_MAYBE_POINTED_TO)
2918 if (s->u.s.line.file == NULL)
2921 for (opt = s->u.s.opt; opt; opt = opt->next)
2922 if (strcmp (opt->name, "ptr_alias") == 0)
2924 const_type_p const t = (const_type_p) opt->info;
2925 if (t->kind == TYPE_STRUCT
2926 || t->kind == TYPE_UNION
2927 || t->kind == TYPE_LANG_STRUCT)
2929 oprintf (output_header, "#define gt_pch_p_");
2930 output_mangled_typename (output_header, s);
2931 oprintf (output_header, " gt_pch_p_");
2932 output_mangled_typename (output_header, t);
2933 oprintf (output_header, "\n");
2936 error_at_line (&s->u.s.line,
2937 "structure alias is not a structure");
2943 /* Declare the marker procedure only once. */
2944 oprintf (output_header, "extern void gt_pch_p_");
2945 output_mangled_typename (output_header, s);
2946 oprintf (output_header,
2947 "\n (void *, void *, gt_pointer_operator, void *);\n");
2949 if (s->kind == TYPE_LANG_STRUCT)
2952 for (ss = s->u.s.lang_struct; ss; ss = ss->next)
2953 write_local_func_for_structure (s, ss, NULL);
2956 write_local_func_for_structure (s, s, NULL);
2959 for (s = param_structs; s; s = s->next)
2960 if (s->gc_used == GC_POINTED_TO)
2962 type_p * param = s->u.param_struct.param;
2963 type_p stru = s->u.param_struct.stru;
2965 /* Declare the marker procedure. */
2966 oprintf (output_header, "extern void gt_pch_p_");
2967 output_mangled_typename (output_header, s);
2968 oprintf (output_header,
2969 "\n (void *, void *, gt_pointer_operator, void *);\n");
2971 if (stru->u.s.line.file == NULL)
2973 fprintf (stderr, "warning: structure `%s' used but not defined\n",
2978 if (stru->kind == TYPE_LANG_STRUCT)
2981 for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
2982 write_local_func_for_structure (s, ss, param);
2985 write_local_func_for_structure (s, stru, param);
2989 /* Write out the 'enum' definition for gt_types_enum. */
2992 write_enum_defn (type_p structures, type_p param_structs)
2998 oprintf (header_file, "\n/* Enumeration of types known. */\n");
2999 oprintf (header_file, "enum gt_types_enum {\n");
3000 for (s = structures; s; s = s->next)
3001 if (s->gc_used == GC_POINTED_TO
3002 || s->gc_used == GC_MAYBE_POINTED_TO)
3004 if (s->gc_used == GC_MAYBE_POINTED_TO
3005 && s->u.s.line.file == NULL)
3008 oprintf (header_file, " gt_ggc_e_");
3009 output_mangled_typename (header_file, s);
3010 oprintf (header_file, ", \n");
3012 for (s = param_structs; s; s = s->next)
3013 if (s->gc_used == GC_POINTED_TO)
3015 oprintf (header_file, " gt_e_");
3016 output_mangled_typename (header_file, s);
3017 oprintf (header_file, ", \n");
3019 oprintf (header_file, " gt_types_enum_last\n");
3020 oprintf (header_file, "};\n");
3023 /* Might T contain any non-pointer elements? */
3026 contains_scalar_p (type_p t)
3034 return contains_scalar_p (t->u.a.p);
3036 /* Could also check for structures that have no non-pointer
3037 fields, but there aren't enough of those to worry about. */
3042 /* Mangle FN and print it to F. */
3045 put_mangled_filename (outf_p f, const char *fn)
3047 const char *name = get_output_file_name (fn);
3050 for (; *name != 0; name++)
3051 if (ISALNUM (*name))
3052 oprintf (f, "%c", *name);
3054 oprintf (f, "%c", '_');
3057 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
3058 LASTNAME, and NAME are all strings to insert in various places in
3059 the resulting code. */
3062 finish_root_table (struct flist *flp, const char *pfx, const char *lastname,
3063 const char *tname, const char *name)
3067 for (fli2 = flp; fli2; fli2 = fli2->next)
3068 if (fli2->started_p)
3070 oprintf (fli2->f, " %s\n", lastname);
3071 oprintf (fli2->f, "};\n\n");
3074 for (fli2 = flp; fli2 && base_files; fli2 = fli2->next)
3075 if (fli2->started_p)
3077 lang_bitmap bitmap = get_lang_bitmap (fli2->name);
3080 for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1)
3083 oprintf (base_files[fnum],
3084 "extern const struct %s gt_%s_",
3086 put_mangled_filename (base_files[fnum], fli2->name);
3087 oprintf (base_files[fnum], "[];\n");
3093 for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
3094 oprintf (base_files [fnum],
3095 "EXPORTED_CONST struct %s * const %s[] = {\n",
3100 for (fli2 = flp; fli2; fli2 = fli2->next)
3101 if (fli2->started_p)
3103 lang_bitmap bitmap = get_lang_bitmap (fli2->name);
3106 fli2->started_p = 0;
3108 for (fnum = 0; base_files && bitmap != 0; fnum++, bitmap >>= 1)
3111 oprintf (base_files[fnum], " gt_%s_", pfx);
3112 put_mangled_filename (base_files[fnum], fli2->name);
3113 oprintf (base_files[fnum], ",\n");
3119 for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
3121 oprintf (base_files[fnum], " NULL\n");
3122 oprintf (base_files[fnum], "};\n");
3127 /* Write out to F the table entry and any marker routines needed to
3128 mark NAME as TYPE. The original variable is V, at LINE.
3129 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
3130 is nonzero iff we are building the root table for hash table caches. */
3133 write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
3134 struct fileloc *line, const char *if_marked, bool emit_pch)
3141 for (fld = type->u.s.fields; fld; fld = fld->next)
3144 const char *desc = NULL;
3147 for (o = fld->opt; o; o = o->next)
3148 if (strcmp (o->name, "skip") == 0)
3150 else if (strcmp (o->name, "desc") == 0)
3152 else if (strcmp (o->name, "param_is") == 0)
3155 error_at_line (line,
3156 "field `%s' of global `%s' has unknown option `%s'",
3157 fld->name, name, o->name);
3161 else if (desc && fld->type->kind == TYPE_UNION)
3163 pair_p validf = NULL;
3166 for (ufld = fld->type->u.s.fields; ufld; ufld = ufld->next)
3168 const char *tag = NULL;
3171 for (oo = ufld->opt; oo; oo = oo->next)
3172 if (strcmp (oo->name, "tag") == 0)
3174 if (tag == NULL || strcmp (tag, desc) != 0)
3177 error_at_line (line,
3178 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3179 name, fld->name, validf->name,
3180 name, fld->name, ufld->name,
3187 newname = xasprintf ("%s.%s.%s",
3188 name, fld->name, validf->name);
3189 write_root (f, v, validf->type, newname, 0, line,
3190 if_marked, emit_pch);
3195 error_at_line (line,
3196 "global `%s.%s' has `desc' option but is not union",
3201 newname = xasprintf ("%s.%s", name, fld->name);
3202 write_root (f, v, fld->type, newname, 0, line, if_marked,
3213 newname = xasprintf ("%s[0]", name);
3214 write_root (f, v, type->u.a.p, newname, has_length, line, if_marked,
3224 oprintf (f, " {\n");
3225 oprintf (f, " &%s,\n", name);
3228 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
3230 oprintf (f, " * (%s)", ap->u.a.len);
3231 else if (ap == v->type)
3232 oprintf (f, " * ARRAY_SIZE (%s)", v->name);
3234 oprintf (f, " sizeof (%s", v->name);
3235 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
3237 oprintf (f, "),\n");
3241 if (! has_length && UNION_OR_STRUCT_P (tp))
3243 oprintf (f, " >_ggc_mx_%s,\n", tp->u.s.tag);
3245 oprintf (f, " >_pch_nx_%s", tp->u.s.tag);
3247 oprintf (f, " NULL");
3249 else if (! has_length && tp->kind == TYPE_PARAM_STRUCT)
3251 oprintf (f, " >_ggc_m_");
3252 output_mangled_typename (f, tp);
3255 oprintf (f, ",\n >_pch_n_");
3256 output_mangled_typename (f, tp);
3259 oprintf (f, ",\n NULL");
3262 && (tp->kind == TYPE_POINTER || UNION_OR_STRUCT_P (tp)))
3264 oprintf (f, " >_ggc_ma_%s,\n", name);
3266 oprintf (f, " >_pch_na_%s", name);
3268 oprintf (f, " NULL");
3272 error_at_line (line,
3273 "global `%s' is pointer to unimplemented type",
3277 oprintf (f, ",\n &%s", if_marked);
3278 oprintf (f, "\n },\n");
3284 oprintf (f, " {\n");
3285 oprintf (f, " &%s,\n", name);
3286 oprintf (f, " 1, \n");
3287 oprintf (f, " sizeof (%s),\n", v->name);
3288 oprintf (f, " (gt_pointer_walker) >_ggc_m_S,\n");
3289 oprintf (f, " (gt_pointer_walker) >_pch_n_S\n");
3290 oprintf (f, " },\n");
3298 error_at_line (line,
3299 "global `%s' is unimplemented type",
3304 /* This generates a routine to walk an array. */
3307 write_array (outf_p f, pair_p v, const struct write_types_data *wtd)
3309 struct walk_type_data d;
3312 memset (&d, 0, sizeof (d));
3318 d.bitmap = get_lang_bitmap (v->line.file);
3321 d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name);
3323 if (wtd->param_prefix)
3325 oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name);
3327 " (void *, void *, gt_pointer_operator, void *);\n");
3328 oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3329 wtd->param_prefix, v->name);
3331 " ATTRIBUTE_UNUSED void *x_p,\n"
3332 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3333 " ATTRIBUTE_UNUSED void * cookie)\n");
3334 oprintf (d.of, "{\n");
3335 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
3336 d.process_field = write_types_local_process_field;
3337 walk_type (v->type, &d);
3338 oprintf (f, "}\n\n");
3342 oprintf (f, "static void gt_%sa_%s (void *);\n",
3343 wtd->prefix, v->name);
3344 oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3345 wtd->prefix, v->name);
3347 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
3348 d.process_field = write_types_process_field;
3349 walk_type (v->type, &d);
3351 oprintf (f, "}\n\n");
3354 /* Output a table describing the locations and types of VARIABLES. */
3357 write_roots (pair_p variables, bool emit_pch)
3360 struct flist *flp = NULL;
3362 for (v = variables; v; v = v->next)
3364 outf_p f = get_output_file_with_visibility (v->line.file);
3366 const char *length = NULL;
3367 int deletable_p = 0;
3370 for (o = v->opt; o; o = o->next)
3371 if (strcmp (o->name, "length") == 0)
3373 else if (strcmp (o->name, "deletable") == 0)
3375 else if (strcmp (o->name, "param_is") == 0)
3377 else if (strncmp (o->name, "param", 5) == 0
3378 && ISDIGIT (o->name[5])
3379 && strcmp (o->name + 6, "_is") == 0)
3381 else if (strcmp (o->name, "if_marked") == 0)
3384 error_at_line (&v->line,
3385 "global `%s' has unknown option `%s'",
3388 for (fli = flp; fli; fli = fli->next)
3389 if (fli->f == f && f)
3393 fli = XNEW (struct flist);
3397 fli->name = v->line.file;
3398 gcc_assert(fli->name);
3401 oprintf (f, "\n/* GC roots. */\n\n");
3406 && v->type->kind == TYPE_POINTER
3407 && (v->type->u.p->kind == TYPE_POINTER
3408 || v->type->u.p->kind == TYPE_STRUCT))
3410 write_array (f, v, &ggc_wtd);
3411 write_array (f, v, &pch_wtd);
3415 for (v = variables; v; v = v->next)
3417 outf_p f = get_output_file_with_visibility (v->line.file);
3423 for (o = v->opt; o; o = o->next)
3424 if (strcmp (o->name, "length") == 0)
3426 else if (strcmp (o->name, "deletable") == 0
3427 || strcmp (o->name, "if_marked") == 0)
3433 for (fli = flp; fli; fli = fli->next)
3436 if (! fli->started_p)
3440 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3441 put_mangled_filename (f, v->line.file);
3442 oprintf (f, "[] = {\n");
3445 write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
3448 finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3451 for (v = variables; v; v = v->next)
3453 outf_p f = get_output_file_with_visibility (v->line.file);
3458 for (o = v->opt; o; o = o->next)
3459 if (strcmp (o->name, "deletable") == 0)
3461 else if (strcmp (o->name, "if_marked") == 0)
3467 for (fli = flp; fli; fli = fli->next)
3470 if (! fli->started_p)
3474 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3475 put_mangled_filename (f, v->line.file);
3476 oprintf (f, "[] = {\n");
3479 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3483 finish_root_table (flp, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3484 "gt_ggc_deletable_rtab");
3486 for (v = variables; v; v = v->next)
3488 outf_p f = get_output_file_with_visibility (v->line.file);
3490 const char *if_marked = NULL;
3494 for (o = v->opt; o; o = o->next)
3495 if (strcmp (o->name, "length") == 0)
3497 else if (strcmp (o->name, "if_marked") == 0)
3498 if_marked = o->info;
3500 if (if_marked == NULL)
3503 if (v->type->kind != TYPE_POINTER
3504 || v->type->u.p->kind != TYPE_PARAM_STRUCT
3505 || v->type->u.p->u.param_struct.stru != find_structure ("htab", 0))
3507 error_at_line (&v->line, "if_marked option used but not hash table");
3511 for (fli = flp; fli; fli = fli->next)
3514 if (! fli->started_p)
3518 oprintf (f, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
3519 put_mangled_filename (f, v->line.file);
3520 oprintf (f, "[] = {\n");
3523 write_root (f, v, v->type->u.p->u.param_struct.param[0],
3524 v->name, length_p, &v->line, if_marked, emit_pch);
3527 finish_root_table (flp, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
3528 "gt_ggc_cache_rtab");
3533 for (v = variables; v; v = v->next)
3535 outf_p f = get_output_file_with_visibility (v->line.file);
3538 int if_marked_p = 0;
3541 for (o = v->opt; o; o = o->next)
3542 if (strcmp (o->name, "length") == 0)
3544 else if (strcmp (o->name, "if_marked") == 0)
3550 for (fli = flp; fli; fli = fli->next)
3553 if (! fli->started_p)
3557 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
3558 put_mangled_filename (f, v->line.file);
3559 oprintf (f, "[] = {\n");
3562 write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
3565 finish_root_table (flp, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3566 "gt_pch_cache_rtab");
3568 for (v = variables; v; v = v->next)
3570 outf_p f = get_output_file_with_visibility (v->line.file);
3575 for (o = v->opt; o; o = o->next)
3576 if (strcmp (o->name, "deletable") == 0
3577 || strcmp (o->name, "if_marked") == 0)
3583 if (! contains_scalar_p (v->type))
3586 for (fli = flp; fli; fli = fli->next)
3589 if (! fli->started_p)
3593 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
3594 put_mangled_filename (f, v->line.file);
3595 oprintf (f, "[] = {\n");
3598 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3602 finish_root_table (flp, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3603 "gt_pch_scalar_rtab");
3606 /* Record the definition of a generic VEC structure, as if we had expanded
3607 the macros in vec.h:
3609 typedef struct VEC_<type>_base GTY(()) {
3612 <type> GTY((length ("%h.num"))) vec[1];
3615 where the GTY(()) tags are only present if is_scalar is _false_. */
3618 note_def_vec (const char *type_name, bool is_scalar, struct fileloc *pos)
3623 type_p len_ty = create_scalar_type ("unsigned");
3624 const char *name = concat ("VEC_", type_name, "_base", (char *)0);
3628 t = create_scalar_type (type_name);
3633 t = resolve_typedef (type_name, pos);
3634 o = create_option (0, "length", "%h.num");
3637 /* We assemble the field list in reverse order. */
3638 fields = create_field_at (0, create_array (t, "1"), "vec", o, pos);
3639 fields = create_field_at (fields, len_ty, "alloc", 0, pos);
3640 fields = create_field_at (fields, len_ty, "num", 0, pos);
3642 do_typedef (name, new_structure (name, 0, pos, fields, 0), pos);
3645 /* Record the definition of an allocation-specific VEC structure, as if
3646 we had expanded the macros in vec.h:
3648 typedef struct VEC_<type>_<astrat> {
3649 VEC_<type>_base base;
3650 } VEC_<type>_<astrat>;
3653 note_def_vec_alloc (const char *type, const char *astrat, struct fileloc *pos)
3655 const char *astratname = concat ("VEC_", type, "_", astrat, (char *)0);
3656 const char *basename = concat ("VEC_", type, "_base", (char *)0);
3658 pair_p field = create_field_at (0, resolve_typedef (basename, pos),
3661 do_typedef (astratname, new_structure (astratname, 0, pos, field, 0), pos);
3666 main (int argc, char **argv)
3669 static struct fileloc pos = { this_file, 0 };
3670 char* inputlist = 0;
3671 outf_p output_header;
3672 char* plugin_output_filename = NULL;
3673 /* fatal uses this */
3674 progname = "gengtype";
3676 if (argc >= 6 && !strcmp (argv[1], "-P"))
3678 plugin_output_filename = argv[2];
3679 plugin_output = create_file ("GCC", plugin_output_filename);
3681 inputlist = argv[4];
3682 nb_plugin_files = argc - 5;
3683 plugin_files = XCNEWVEC (char *, nb_plugin_files);
3684 for (i = 0; i < nb_plugin_files; i++)
3686 /* Place an all zero lang_bitmap before the plugin file
3688 char *name = argv[i + 5];
3689 int len = strlen(name) + 1 + sizeof (lang_bitmap);
3690 plugin_files[i] = XCNEWVEC (char, len) + sizeof (lang_bitmap);
3691 strcpy (plugin_files[i], name);
3697 inputlist = argv[2];
3700 fatal ("usage: gengtype [-P pluginout.h] srcdir input-list "
3701 "[file1 file2 ... fileN]");
3703 srcdir_len = strlen (srcdir);
3705 read_input_list (inputlist);
3709 scalar_char.u.scalar_is_char = true;
3710 scalar_nonchar.u.scalar_is_char = false;
3713 /* These types are set up with #define or else outside of where
3715 pos.line = __LINE__ + 1;
3716 do_scalar_typedef ("CUMULATIVE_ARGS", &pos); pos.line++;
3717 do_scalar_typedef ("REAL_VALUE_TYPE", &pos); pos.line++;
3718 do_scalar_typedef ("FIXED_VALUE_TYPE", &pos); pos.line++;
3719 do_scalar_typedef ("double_int", &pos); pos.line++;
3720 do_scalar_typedef ("uint64_t", &pos); pos.line++;
3721 do_scalar_typedef ("uint8", &pos); pos.line++;
3722 do_scalar_typedef ("jword", &pos); pos.line++;
3723 do_scalar_typedef ("JCF_u2", &pos); pos.line++;
3724 do_scalar_typedef ("void", &pos); pos.line++;
3725 do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos)), &pos);
3727 for (i = 0; i < num_gt_files; i++)
3728 parse_file (gt_files[i]);
3733 set_gc_used (variables);
3736 write_enum_defn (structures, param_structs);
3737 output_header = plugin_output ? plugin_output : header_file;
3738 write_types (output_header, structures, param_structs, &ggc_wtd);
3739 if (plugin_files == NULL)
3741 write_types (header_file, structures, param_structs, &pch_wtd);
3742 write_local (header_file, structures, param_structs);
3744 write_roots (variables, plugin_files == NULL);
3746 close_output_files ();
3750 for (i = 0; i < nb_plugin_files; i++)
3751 free (plugin_files[i] - sizeof (lang_bitmap));
3752 free (plugin_files);