1 /* Process source files and output type information.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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"
28 /* Data types, macros, etc. used only in this file. */
30 /* Kinds of types we can understand. */
42 typedef unsigned lang_bitmap;
44 /* A way to pass data through to the output end. */
52 /* Option data for the 'nested_ptr' option. */
53 struct nested_ptr_data
56 const char *convert_to;
57 const char *convert_from;
60 /* A name and a type. */
72 /* A description of a type. */
77 /* Used for structures whose definitions we haven't seen so far when
78 we encounter a pointer to it that is annotated with ``maybe_undef''.
79 If after reading in everything we don't have source file
80 information for it, we assume that it never has been defined. */
90 enum gc_used_enum gc_used;
108 type_p param[NUM_PARAM];
115 ((x)->kind == TYPE_UNION || \
116 ((x)->kind == TYPE_LANG_STRUCT \
117 && (x)->u.s.lang_struct->kind == TYPE_UNION))
118 #define UNION_OR_STRUCT_P(x) \
119 ((x)->kind == TYPE_UNION \
120 || (x)->kind == TYPE_STRUCT \
121 || (x)->kind == TYPE_LANG_STRUCT)
123 /* Structure representing an output file. */
132 typedef struct outf * outf_p;
134 /* An output file, suitable for definitions, that can see declarations
135 made in INPUT_FILE and is linked into every language that uses
136 INPUT_FILE. May return NULL in plugin mode. */
137 extern outf_p get_output_file_with_visibility
138 (const char *input_file);
139 const char *get_output_file_name (const char *);
141 /* Print, like fprintf, to O. No-op if O is NULL. */
142 static void oprintf (outf_p o, const char *S, ...)
145 /* The list of output files. */
146 static outf_p output_files;
148 /* The plugin input files and their number; in that case only
149 a single file is produced. */
150 static char** plugin_files;
151 static size_t nb_plugin_files;
152 /* the generated plugin output name & file */
153 static outf_p plugin_output;
155 /* The output header file that is included into pretty much every
157 static outf_p header_file;
159 /* Source directory. */
160 static const char *srcdir;
162 /* Length of srcdir name. */
163 static size_t srcdir_len = 0;
165 static outf_p create_file (const char *, const char *);
167 static const char * get_file_basename (const char *);
168 static const char * get_file_realbasename (const char *);
169 static const char * get_file_srcdir_relative_path (const char *);
171 static int get_prefix_langdir_index (const char *);
172 static const char * get_file_langdir (const char *);
175 /* Nonzero iff an error has occurred. */
176 bool hit_error = false;
178 static void gen_rtx_next (void);
179 static void write_rtx_next (void);
180 static void open_base_files (void);
181 static void close_output_files (void);
183 /* Report an error at POS, printing MSG. */
186 error_at_line (const struct fileloc *pos, const char *msg, ...)
192 fprintf (stderr, "%s:%d: ", pos->file, pos->line);
193 vfprintf (stderr, msg, ap);
194 fputc ('\n', stderr);
200 /* asprintf, but produces fatal message on out-of-memory. */
202 xasprintf (const char *format, ...)
208 va_start (ap, format);
209 n = vasprintf (&result, format, ap);
210 if (result == NULL || n < 0)
211 fatal ("out of memory");
217 /* Input file handling. */
219 /* Table of all input files. */
220 static const char **gt_files;
221 static size_t num_gt_files;
223 /* A number of places use the name of this file for a location for
224 things that we can't rely on the source to define. Make sure we
225 can still use pointer comparison on filenames. */
226 static const char this_file[] = __FILE__;
228 /* Vector of per-language directories. */
229 static const char **lang_dir_names;
230 static size_t num_lang_dirs;
232 /* An array of output files suitable for definitions. There is one
233 BASE_FILES entry for each language. */
234 static outf_p *base_files;
236 /* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
237 INPUT_FILE is used by <lang>.
239 This function should be written to assume that a file _is_ used
240 if the situation is unclear. If it wrongly assumes a file _is_ used,
241 a linker error will result. If it wrongly assumes a file _is not_ used,
242 some GC roots may be missed, which is a much harder-to-debug problem.
244 The relevant bitmap is stored immediately before the file's name in the
245 buffer set up by read_input_list. It may be unaligned, so we have to
246 read it byte-by-byte. */
249 get_lang_bitmap (const char *gtfile)
252 if (gtfile == this_file)
253 /* Things defined in this file are universal. */
254 return (((lang_bitmap)1) << num_lang_dirs) - 1;
259 for (i = -(int) sizeof (lang_bitmap); i < 0; i++)
260 n = (n << CHAR_BIT) + (unsigned char)gtfile[i];
265 /* Set the bitmap returned by get_lang_bitmap. The only legitimate
266 caller of this function is read_input_list. */
268 set_lang_bitmap (char *gtfile, lang_bitmap n)
271 for (i = -1; i >= -(int) sizeof (lang_bitmap); i--)
273 gtfile[i] = n & ((1U << CHAR_BIT)-1);
278 /* Scan the input file, LIST, and determine how much space we need to
279 store strings in. Also, count the number of language directories
280 and files. The numbers returned are overestimates as they does not
281 consider repeated files. */
283 measure_input_list (FILE *list)
289 num_gt_files = plugin_files ? nb_plugin_files : 0;
290 while ((c = getc (list)) != EOF)
299 /* Add space for a lang_bitmap before the input file name. */
300 n += sizeof (lang_bitmap);
314 /* Read one input line from LIST to HEREP (which is updated). A
315 pointer to the string is returned via LINEP. If it was a language
316 subdirectory in square brackets, strip off the square brackets and
317 return true. Otherwise, leave space before the string for a
318 lang_bitmap, and return false. At EOF, returns false, does not
319 touch *HEREP, and sets *LINEP to NULL. POS is used for
322 read_input_line (FILE *list, char **herep, char **linep,
329 /* Read over whitespace. */
330 while (c == '\n' || c == ' ')
340 /* No space for a lang_bitmap is necessary. Discard the '['. */
343 while (c != ']' && c != '\n' && c != EOF)
352 c = getc (list); /* eat what should be a newline */
353 if (c != '\n' && c != EOF)
354 error_at_line (pos, "junk on line after language tag [%s]", line);
357 error_at_line (pos, "missing close bracket for language tag [%s", line);
365 /* Leave space for a lang_bitmap. */
366 memset (here, 0, sizeof (lang_bitmap));
367 here += sizeof (lang_bitmap);
374 while (c != EOF && c != '\n');
382 /* Read the list of input files from LIST and compute all of the
383 relevant tables. There is one file per line of the list. At
384 first, all the files on the list are language-generic, but
385 eventually a line will appear which is the name of a language
386 subdirectory in square brackets, like this: [cp]. All subsequent
387 files are specific to that language, until another language
388 subdirectory tag appears. Files can appear more than once, if
389 they apply to more than one language. */
391 read_input_list (const char *listname)
393 FILE *list = fopen (listname, "r");
395 fatal ("cannot open %s: %s", listname, xstrerror (errno));
399 size_t bufsz = measure_input_list (list);
400 char *buf = XNEWVEC (char, bufsz);
402 char *committed = buf;
403 char *limit = buf + bufsz;
408 lang_bitmap curlangs = (1 << num_lang_dirs) - 1;
410 epos.file = listname;
413 lang_dir_names = XNEWVEC (const char *, num_lang_dirs);
414 gt_files = XNEWVEC (const char *, num_gt_files);
421 is_language = read_input_line (list, &here, &line, &epos);
422 gcc_assert (here <= limit);
425 else if (is_language)
428 gcc_assert (langno <= num_lang_dirs);
429 for (i = 0; i < langno; i++)
430 if (strcmp (lang_dir_names[i], line) == 0)
432 error_at_line (&epos, "duplicate language tag [%s]", line);
438 curlangs = 1 << langno;
439 lang_dir_names[langno++] = line;
444 gcc_assert (nfiles <= num_gt_files);
445 for (i = 0; i < nfiles; i++)
446 if (strcmp (gt_files[i], line) == 0)
448 /* Throw away the string we just read, and add the
449 current language to the existing string's bitmap. */
450 lang_bitmap bmap = get_lang_bitmap (gt_files[i]);
452 error_at_line (&epos, "file %s specified more than once "
453 "for language %s", line, langno == 0
455 : lang_dir_names[langno - 1]);
458 set_lang_bitmap (CONST_CAST(char *, gt_files[i]), bmap);
463 set_lang_bitmap (line, curlangs);
464 gt_files[nfiles++] = line;
467 /* Update the global counts now that we know accurately how many
468 things there are. (We do not bother resizing the arrays down.) */
469 num_lang_dirs = langno;
470 /* Add the plugin files if provided. */
474 for (i = 0; i < nb_plugin_files; i++)
475 gt_files[nfiles++] = plugin_files[i];
477 num_gt_files = nfiles;
480 /* Sanity check: any file that resides in a language subdirectory
481 (e.g. 'cp') ought to belong to the corresponding language.
482 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
483 (Can you even do that? Should you be allowed to?) */
486 for (f = 0; f < num_gt_files; f++)
488 lang_bitmap bitmap = get_lang_bitmap (gt_files[f]);
489 const char *basename = get_file_basename (gt_files[f]);
490 const char *slashpos = strchr (basename, '/');
495 for (l = 0; l < num_lang_dirs; l++)
496 if ((size_t)(slashpos - basename) == strlen (lang_dir_names [l])
497 && memcmp (basename, lang_dir_names[l],
498 strlen (lang_dir_names[l])) == 0)
500 if (!(bitmap & (1 << l)))
501 error ("%s is in language directory '%s' but is not "
502 "tagged for that language",
503 basename, lang_dir_names[l]);
511 fatal ("error reading %s: %s", listname, xstrerror (errno));
518 /* The one and only TYPE_STRING. */
520 static struct type string_type = {
521 TYPE_STRING, 0, 0, GC_USED, {0}
524 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
525 set to appropriate values at the beginning of main. */
527 static struct type scalar_nonchar = {
528 TYPE_SCALAR, 0, 0, GC_USED, {0}
530 static struct type scalar_char = {
531 TYPE_SCALAR, 0, 0, GC_USED, {0}
534 /* Lists of various things. */
536 static pair_p typedefs;
537 static type_p structures;
538 static type_p param_structs;
539 static pair_p variables;
541 static type_p find_param_structure
542 (type_p t, type_p param[NUM_PARAM]);
543 static type_p adjust_field_tree_exp (type_p t, options_p opt);
544 static type_p adjust_field_rtx_def (type_p t, options_p opt);
546 /* Define S as a typedef to T at POS. */
549 do_typedef (const char *s, type_p t, struct fileloc *pos)
553 /* temporary kludge - gengtype doesn't handle conditionals or
554 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
555 is coming from this file (main() sets them up with safe dummy
557 if (!strcmp (s, "CUMULATIVE_ARGS") && pos->file != this_file)
560 for (p = typedefs; p != NULL; p = p->next)
561 if (strcmp (p->name, s) == 0)
565 error_at_line (pos, "type `%s' previously defined", s);
566 error_at_line (&p->line, "previously defined here");
571 p = XNEW (struct pair);
580 /* Define S as a typename of a scalar. Cannot be used to define
581 typedefs of 'char'. Note: is also used for pointer-to-function
582 typedefs (which are therefore not treated as pointers). */
585 do_scalar_typedef (const char *s, struct fileloc *pos)
587 do_typedef (s, &scalar_nonchar, pos);
590 /* Return the type previously defined for S. Use POS to report errors. */
593 resolve_typedef (const char *s, struct fileloc *pos)
596 for (p = typedefs; p != NULL; p = p->next)
597 if (strcmp (p->name, s) == 0)
599 error_at_line (pos, "unidentified type `%s'", s);
600 return &scalar_nonchar; /* treat as "int" */
603 /* Create and return a new structure with tag NAME (or a union iff
604 ISUNION is nonzero), at POS with fields FIELDS and options O. */
607 new_structure (const char *name, int isunion, struct fileloc *pos,
608 pair_p fields, options_p o)
612 lang_bitmap bitmap = get_lang_bitmap (pos->file);
614 /* temporary kludge - gengtype doesn't handle conditionals or
615 macros. Ignore any attempt to define struct location_s, unless
616 it is coming from this file (main() sets it up safely). */
617 if (!strcmp (name, "location_s") && !isunion
618 && pos->file != this_file)
619 return find_structure (name, 0);
621 for (si = structures; si != NULL; si = si->next)
622 if (strcmp (name, si->u.s.tag) == 0
623 && UNION_P (si) == isunion)
626 if (si->kind == TYPE_LANG_STRUCT)
630 for (si = ls->u.s.lang_struct; si != NULL; si = si->next)
631 if (si->u.s.bitmap == bitmap)
634 else if (si->u.s.line.file != NULL && si->u.s.bitmap != bitmap)
637 si = XCNEW (struct type);
638 memcpy (si, ls, sizeof (struct type));
639 ls->kind = TYPE_LANG_STRUCT;
640 ls->u.s.lang_struct = si;
641 ls->u.s.fields = NULL;
643 si->pointer_to = NULL;
644 si->u.s.lang_struct = ls;
649 if (ls != NULL && s == NULL)
651 s = XCNEW (struct type);
652 s->next = ls->u.s.lang_struct;
653 ls->u.s.lang_struct = s;
654 s->u.s.lang_struct = ls;
661 s = XCNEW (struct type);
662 s->next = structures;
666 if (s->u.s.line.file != NULL
667 || (s->u.s.lang_struct && (s->u.s.lang_struct->u.s.bitmap & bitmap)))
669 error_at_line (pos, "duplicate definition of '%s %s'",
670 isunion ? "union" : "struct", s->u.s.tag);
671 error_at_line (&s->u.s.line, "previous definition here");
674 s->kind = isunion ? TYPE_UNION : TYPE_STRUCT;
677 s->u.s.fields = fields;
679 s->u.s.bitmap = bitmap;
680 if (s->u.s.lang_struct)
681 s->u.s.lang_struct->u.s.bitmap |= bitmap;
683 /* Reset location_s's location to input.h so that we know where to
684 write out its mark routine. */
685 if (!strcmp (name, "location_s") && !isunion
686 && pos->file == this_file)
689 for (n = 0; n < num_gt_files; n++)
690 if (!strcmp (gt_files[n] + strlen (gt_files[n]) - strlen ("input.h"),
693 s->u.s.line.file = gt_files[n];
701 /* Return the previously-defined structure with tag NAME (or a union
702 iff ISUNION is nonzero), or a new empty structure or union if none
703 was defined previously. */
706 find_structure (const char *name, int isunion)
710 for (s = structures; s != NULL; s = s->next)
711 if (strcmp (name, s->u.s.tag) == 0
712 && UNION_P (s) == isunion)
715 s = XCNEW (struct type);
716 s->next = structures;
718 s->kind = isunion ? TYPE_UNION : TYPE_STRUCT;
724 /* Return the previously-defined parameterized structure for structure
725 T and parameters PARAM, or a new parameterized empty structure or
726 union if none was defined previously. */
729 find_param_structure (type_p t, type_p param[NUM_PARAM])
733 for (res = param_structs; res; res = res->next)
734 if (res->u.param_struct.stru == t
735 && memcmp (res->u.param_struct.param, param,
736 sizeof (type_p) * NUM_PARAM) == 0)
740 res = XCNEW (struct type);
741 res->kind = TYPE_PARAM_STRUCT;
742 res->next = param_structs;
744 res->u.param_struct.stru = t;
745 memcpy (res->u.param_struct.param, param, sizeof (type_p) * NUM_PARAM);
750 /* Return a scalar type with name NAME. */
753 create_scalar_type (const char *name)
755 if (!strcmp (name, "char") || !strcmp (name, "unsigned char"))
758 return &scalar_nonchar;
761 /* Return a pointer to T. */
764 create_pointer (type_p t)
768 type_p r = XCNEW (struct type);
769 r->kind = TYPE_POINTER;
773 return t->pointer_to;
776 /* Return an array of length LEN. */
779 create_array (type_p t, const char *len)
783 v = XCNEW (struct type);
784 v->kind = TYPE_ARRAY;
790 /* Return an options structure with name NAME and info INFO. NEXT is the
791 next option in the chain. */
794 create_option (options_p next, const char *name, const void *info)
796 options_p o = XNEW (struct options);
799 o->info = (const char*) info;
803 /* Return an options structure for a "nested_ptr" option. */
805 create_nested_ptr_option (options_p next, type_p t,
806 const char *to, const char *from)
808 struct nested_ptr_data *d = XNEW (struct nested_ptr_data);
810 d->type = adjust_field_type (t, 0);
812 d->convert_from = from;
813 return create_option (next, "nested_ptr", d);
816 /* Add a variable named S of type T with options O defined at POS,
820 note_variable (const char *s, type_p t, options_p o, struct fileloc *pos)
823 n = XNEW (struct pair);
832 /* Most-general structure field creator. */
834 create_field_all (pair_p next, type_p type, const char *name, options_p opt,
835 const char *file, int line)
839 field = XNEW (struct pair);
844 field->line.file = file;
845 field->line.line = line;
849 /* Create a field that came from the source code we are scanning,
850 i.e. we have a 'struct fileloc', and possibly options; also,
851 adjust_field_type should be called. */
853 create_field_at (pair_p next, type_p type, const char *name, options_p opt,
856 return create_field_all (next, adjust_field_type (type, opt),
857 name, opt, pos->file, pos->line);
860 /* Create a fake field with the given type and name. NEXT is the next
861 field in the chain. */
862 #define create_field(next,type,name) \
863 create_field_all(next,type,name, 0, this_file, __LINE__)
865 /* Like create_field, but the field is only valid when condition COND
869 create_optional_field_ (pair_p next, type_p type, const char *name,
870 const char *cond, int line)
876 /* Create a fake union type with a single nameless field of type TYPE.
877 The field has a tag of "1". This allows us to make the presence
878 of a field of type TYPE depend on some boolean "desc" being true. */
879 union_fields = create_field (NULL, type, "");
880 union_fields->opt = create_option (union_fields->opt, "dot", "");
881 union_fields->opt = create_option (union_fields->opt, "tag", "1");
882 union_type = new_structure (xasprintf ("%s_%d", "fake_union", id++), 1,
883 &lexer_line, union_fields, NULL);
885 /* Create the field and give it the new fake union type. Add a "desc"
886 tag that specifies the condition under which the field is valid. */
887 return create_field_all (next, union_type, name,
888 create_option (0, "desc", cond),
891 #define create_optional_field(next,type,name,cond) \
892 create_optional_field_(next,type,name,cond,__LINE__)
894 /* Reverse a linked list of 'struct pair's in place. */
896 nreverse_pairs (pair_p list)
898 pair_p prev = 0, p, next;
899 for (p = list; p; p = next)
909 /* We don't care how long a CONST_DOUBLE is. */
910 #define CONST_DOUBLE_FORMAT "ww"
911 /* We don't want to see codes that are only for generator files. */
912 #undef GENERATOR_FILE
915 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
921 static const char * const rtx_name[NUM_RTX_CODE] = {
922 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
927 static const char * const rtx_format[NUM_RTX_CODE] = {
928 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
933 static int rtx_next_new[NUM_RTX_CODE];
935 /* We also need codes and names for insn notes (not register notes).
936 Note that we do *not* bias the note values here. */
938 #define DEF_INSN_NOTE(NAME) NAME,
939 #include "insn-notes.def"
945 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
946 default field for line number notes. */
947 static const char *const note_insn_name[NOTE_INSN_MAX+1] = {
948 #define DEF_INSN_NOTE(NAME) #NAME,
949 #include "insn-notes.def"
953 #undef CONST_DOUBLE_FORMAT
954 #define GENERATOR_FILE
956 /* Generate the contents of the rtx_next array. This really doesn't belong
957 in gengtype at all, but it's needed for adjust_field_rtx_def. */
963 for (i = 0; i < NUM_RTX_CODE; i++)
967 rtx_next_new[i] = -1;
968 if (strncmp (rtx_format[i], "iuu", 3) == 0)
970 else if (i == COND_EXEC || i == SET || i == EXPR_LIST || i == INSN_LIST)
973 for (k = strlen (rtx_format[i]) - 1; k >= 0; k--)
974 if (rtx_format[i][k] == 'e' || rtx_format[i][k] == 'u')
979 /* Write out the contents of the rtx_next array. */
981 write_rtx_next (void)
983 outf_p f = get_output_file_with_visibility (NULL);
988 oprintf (f, "\n/* Used to implement the RTX_NEXT macro. */\n");
989 oprintf (f, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
990 for (i = 0; i < NUM_RTX_CODE; i++)
991 if (rtx_next_new[i] == -1)
992 oprintf (f, " 0,\n");
995 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n",
1000 /* Handle `special("rtx_def")'. This is a special case for field
1001 `fld' of struct rtx_def, which is an array of unions whose values
1002 are based in a complex way on the type of RTL. */
1005 adjust_field_rtx_def (type_p t, options_p ARG_UNUSED (opt))
1010 type_p rtx_tp, rtvec_tp, tree_tp, mem_attrs_tp, note_union_tp, scalar_tp;
1011 type_p basic_block_tp, reg_attrs_tp, constant_tp, symbol_union_tp;
1013 if (t->kind != TYPE_UNION)
1015 error_at_line (&lexer_line,
1016 "special `rtx_def' must be applied to a union");
1017 return &string_type;
1020 nodot = create_option (NULL, "dot", "");
1022 rtx_tp = create_pointer (find_structure ("rtx_def", 0));
1023 rtvec_tp = create_pointer (find_structure ("rtvec_def", 0));
1024 tree_tp = create_pointer (find_structure ("tree_node", 1));
1025 mem_attrs_tp = create_pointer (find_structure ("mem_attrs", 0));
1026 reg_attrs_tp = create_pointer (find_structure ("reg_attrs", 0));
1027 basic_block_tp = create_pointer (find_structure ("basic_block_def", 0));
1028 constant_tp = create_pointer (find_structure ("constant_descriptor_rtx", 0));
1029 scalar_tp = &scalar_nonchar; /* rtunion int */
1032 pair_p note_flds = NULL;
1035 for (c = 0; c <= NOTE_INSN_MAX; c++)
1040 case NOTE_INSN_DELETED_LABEL:
1041 note_flds = create_field (note_flds, &string_type, "rt_str");
1044 case NOTE_INSN_BLOCK_BEG:
1045 case NOTE_INSN_BLOCK_END:
1046 note_flds = create_field (note_flds, tree_tp, "rt_tree");
1049 case NOTE_INSN_VAR_LOCATION:
1050 note_flds = create_field (note_flds, rtx_tp, "rt_rtx");
1054 note_flds = create_field (note_flds, scalar_tp, "rt_int");
1057 /* NOTE_INSN_MAX is used as the default field for line
1059 if (c == NOTE_INSN_MAX)
1060 note_flds->opt = create_option (nodot, "default", "");
1062 note_flds->opt = create_option (nodot, "tag", note_insn_name[c]);
1064 note_union_tp = new_structure ("rtx_def_note_subunion", 1,
1065 &lexer_line, note_flds, NULL);
1067 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1071 sym_flds = create_field (NULL, tree_tp, "rt_tree");
1072 sym_flds->opt = create_option (nodot, "default", "");
1074 sym_flds = create_field (sym_flds, constant_tp, "rt_constant");
1075 sym_flds->opt = create_option (nodot, "tag", "1");
1077 symbol_union_tp = new_structure ("rtx_def_symbol_subunion", 1,
1078 &lexer_line, sym_flds, NULL);
1080 for (i = 0; i < NUM_RTX_CODE; i++)
1082 pair_p subfields = NULL;
1083 size_t aindex, nmindex;
1088 for (aindex = 0; aindex < strlen (rtx_format[i]); aindex++)
1091 const char *subname;
1093 switch (rtx_format[i][aindex])
1104 if (i == MEM && aindex == 1)
1105 t = mem_attrs_tp, subname = "rt_mem";
1106 else if (i == JUMP_INSN && aindex == 8)
1107 t = rtx_tp, subname = "rt_rtx";
1108 else if (i == CODE_LABEL && aindex == 4)
1109 t = scalar_tp, subname = "rt_int";
1110 else if (i == CODE_LABEL && aindex == 5)
1111 t = rtx_tp, subname = "rt_rtx";
1112 else if (i == LABEL_REF
1113 && (aindex == 1 || aindex == 2))
1114 t = rtx_tp, subname = "rt_rtx";
1115 else if (i == NOTE && aindex == 4)
1116 t = note_union_tp, subname = "";
1117 else if (i == NOTE && aindex == 5)
1118 t = scalar_tp, subname = "rt_int";
1119 else if (i == NOTE && aindex >= 7)
1120 t = scalar_tp, subname = "rt_int";
1121 else if (i == ADDR_DIFF_VEC && aindex == 4)
1122 t = scalar_tp, subname = "rt_int";
1123 else if (i == VALUE && aindex == 0)
1124 t = scalar_tp, subname = "rt_int";
1125 else if (i == DEBUG_EXPR && aindex == 0)
1126 t = tree_tp, subname = "rt_tree";
1127 else if (i == REG && aindex == 1)
1128 t = scalar_tp, subname = "rt_int";
1129 else if (i == REG && aindex == 2)
1130 t = reg_attrs_tp, subname = "rt_reg";
1131 else if (i == SCRATCH && aindex == 0)
1132 t = scalar_tp, subname = "rt_int";
1133 else if (i == SYMBOL_REF && aindex == 1)
1134 t = scalar_tp, subname = "rt_int";
1135 else if (i == SYMBOL_REF && aindex == 2)
1136 t = symbol_union_tp, subname = "";
1137 else if (i == BARRIER && aindex >= 3)
1138 t = scalar_tp, subname = "rt_int";
1141 error_at_line (&lexer_line,
1142 "rtx type `%s' has `0' in position %lu, can't handle",
1143 rtx_name[i], (unsigned long) aindex);
1165 subname = "rt_rtvec";
1170 subname = "rt_tree";
1179 error_at_line (&lexer_line,
1180 "rtx type `%s' has `%c' in position %lu, can't handle",
1181 rtx_name[i], rtx_format[i][aindex],
1182 (unsigned long)aindex);
1188 subfields = create_field (subfields, t,
1189 xasprintf (".fld[%lu].%s",
1190 (unsigned long) aindex,
1192 subfields->opt = nodot;
1193 if (t == note_union_tp)
1194 subfields->opt = create_option (subfields->opt, "desc",
1196 if (t == symbol_union_tp)
1197 subfields->opt = create_option (subfields->opt, "desc",
1198 "CONSTANT_POOL_ADDRESS_P (&%0)");
1201 if (i == SYMBOL_REF)
1203 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds. */
1204 type_p field_tp = find_structure ("block_symbol", 0);
1206 = create_optional_field (subfields, field_tp, "block_sym",
1207 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1210 sname = xasprintf ("rtx_def_%s", rtx_name[i]);
1211 substruct = new_structure (sname, 0, &lexer_line, subfields, NULL);
1213 ftag = xstrdup (rtx_name[i]);
1214 for (nmindex = 0; nmindex < strlen (ftag); nmindex++)
1215 ftag[nmindex] = TOUPPER (ftag[nmindex]);
1217 flds = create_field (flds, substruct, "");
1218 flds->opt = create_option (nodot, "tag", ftag);
1221 return new_structure ("rtx_def_subunion", 1, &lexer_line, flds, nodot);
1224 /* Handle `special("tree_exp")'. This is a special case for
1225 field `operands' of struct tree_exp, which although it claims to contain
1226 pointers to trees, actually sometimes contains pointers to RTL too.
1227 Passed T, the old type of the field, and OPT its options. Returns
1228 a new type for the field. */
1231 adjust_field_tree_exp (type_p t, options_p opt ATTRIBUTE_UNUSED)
1236 if (t->kind != TYPE_ARRAY)
1238 error_at_line (&lexer_line,
1239 "special `tree_exp' must be applied to an array");
1240 return &string_type;
1243 nodot = create_option (NULL, "dot", "");
1245 flds = create_field (NULL, t, "");
1246 flds->opt = create_option (nodot, "length",
1247 "TREE_OPERAND_LENGTH ((tree) &%0)");
1248 flds->opt = create_option (flds->opt, "default", "");
1250 return new_structure ("tree_exp_subunion", 1, &lexer_line, flds, nodot);
1253 /* Perform any special processing on a type T, about to become the type
1254 of a field. Return the appropriate type for the field.
1256 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1257 - Similarly for arrays of pointer-to-char;
1258 - Converts structures for which a parameter is provided to
1260 - Handles "special" options.
1264 adjust_field_type (type_p t, options_p opt)
1267 const int pointer_p = t->kind == TYPE_POINTER;
1268 type_p params[NUM_PARAM];
1272 for (i = 0; i < NUM_PARAM; i++)
1275 for (; opt; opt = opt->next)
1276 if (strcmp (opt->name, "length") == 0)
1278 else if (strcmp (opt->name, "param_is") == 0
1279 || (strncmp (opt->name, "param", 5) == 0
1280 && ISDIGIT (opt->name[5])
1281 && strcmp (opt->name + 6, "_is") == 0))
1283 int num = ISDIGIT (opt->name[5]) ? opt->name[5] - '0' : 0;
1285 if (! UNION_OR_STRUCT_P (t)
1286 && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p)))
1288 error_at_line (&lexer_line,
1289 "option `%s' may only be applied to structures or structure pointers",
1295 if (params[num] != NULL)
1296 error_at_line (&lexer_line, "duplicate `%s' option", opt->name);
1297 if (! ISDIGIT (opt->name[5]))
1298 params[num] = create_pointer (CONST_CAST2(type_p, const char *, opt->info));
1300 params[num] = CONST_CAST2 (type_p, const char *, opt->info);
1302 else if (strcmp (opt->name, "special") == 0)
1304 const char *special_name = opt->info;
1305 if (strcmp (special_name, "tree_exp") == 0)
1306 t = adjust_field_tree_exp (t, opt);
1307 else if (strcmp (special_name, "rtx_def") == 0)
1308 t = adjust_field_rtx_def (t, opt);
1310 error_at_line (&lexer_line, "unknown special `%s'", special_name);
1319 realt = find_param_structure (t, params);
1320 t = pointer_p ? create_pointer (realt) : realt;
1325 && t->u.p->kind == TYPE_SCALAR
1326 && t->u.p->u.scalar_is_char)
1327 return &string_type;
1328 if (t->kind == TYPE_ARRAY && t->u.a.p->kind == TYPE_POINTER
1329 && t->u.a.p->u.p->kind == TYPE_SCALAR
1330 && t->u.a.p->u.p->u.scalar_is_char)
1331 return create_array (&string_type, t->u.a.len);
1337 static void set_gc_used_type (type_p, enum gc_used_enum, type_p *);
1338 static void set_gc_used (pair_p);
1340 /* Handle OPT for set_gc_used_type. */
1343 process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef,
1344 int *pass_param, int *length, int *skip, type_p *nested_ptr)
1347 for (o = opt; o; o = o->next)
1348 if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO)
1349 set_gc_used_type (CONST_CAST2 (type_p, const char *, o->info),
1350 GC_POINTED_TO, NULL);
1351 else if (strcmp (o->name, "maybe_undef") == 0)
1353 else if (strcmp (o->name, "use_params") == 0)
1355 else if (strcmp (o->name, "length") == 0)
1357 else if (strcmp (o->name, "skip") == 0)
1359 else if (strcmp (o->name, "nested_ptr") == 0)
1360 *nested_ptr = ((const struct nested_ptr_data *) o->info)->type;
1363 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1366 set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM])
1368 if (t->gc_used >= level)
1382 process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, &dummy,
1385 for (f = t->u.s.fields; f; f = f->next)
1387 int maybe_undef = 0;
1391 type_p nested_ptr = NULL;
1392 process_gc_options (f->opt, level, &maybe_undef, &pass_param,
1393 &length, &skip, &nested_ptr);
1395 if (nested_ptr && f->type->kind == TYPE_POINTER)
1396 set_gc_used_type (nested_ptr, GC_POINTED_TO,
1397 pass_param ? param : NULL);
1398 else if (length && f->type->kind == TYPE_POINTER)
1399 set_gc_used_type (f->type->u.p, GC_USED, NULL);
1400 else if (maybe_undef && f->type->kind == TYPE_POINTER)
1401 set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO, NULL);
1402 else if (pass_param && f->type->kind == TYPE_POINTER && param)
1403 set_gc_used_type (find_param_structure (f->type->u.p, param),
1404 GC_POINTED_TO, NULL);
1406 ; /* target type is not used through this field */
1408 set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL);
1414 set_gc_used_type (t->u.p, GC_POINTED_TO, NULL);
1418 set_gc_used_type (t->u.a.p, GC_USED, param);
1421 case TYPE_LANG_STRUCT:
1422 for (t = t->u.s.lang_struct; t; t = t->next)
1423 set_gc_used_type (t, level, param);
1426 case TYPE_PARAM_STRUCT:
1429 for (i = 0; i < NUM_PARAM; i++)
1430 if (t->u.param_struct.param[i] != 0)
1431 set_gc_used_type (t->u.param_struct.param[i], GC_USED, NULL);
1433 if (t->u.param_struct.stru->gc_used == GC_POINTED_TO)
1434 level = GC_POINTED_TO;
1437 t->u.param_struct.stru->gc_used = GC_UNUSED;
1438 set_gc_used_type (t->u.param_struct.stru, level,
1439 t->u.param_struct.param);
1447 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1450 set_gc_used (pair_p variables)
1453 for (p = variables; p; p = p->next)
1454 set_gc_used_type (p->type, GC_USED, NULL);
1457 /* File mapping routines. For each input file, there is one output .c file
1458 (but some output files have many input files), and there is one .h file
1459 for the whole build. */
1461 /* Output file handling. */
1463 /* Create and return an outf_p for a new file for NAME, to be called
1467 create_file (const char *name, const char *oname)
1469 static const char *const hdr[] = {
1470 " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n",
1472 "This file is part of GCC.\n",
1474 "GCC is free software; you can redistribute it and/or modify it under\n",
1475 "the terms of the GNU General Public License as published by the Free\n",
1476 "Software Foundation; either version 3, or (at your option) any later\n",
1479 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1480 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1481 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1482 "for more details.\n",
1484 "You should have received a copy of the GNU General Public License\n",
1485 "along with GCC; see the file COPYING3. If not see\n",
1486 "<http://www.gnu.org/licenses/>. */\n",
1488 "/* This file is machine generated. Do not edit. */\n"
1493 gcc_assert (name != NULL);
1494 gcc_assert (oname != NULL);
1495 f = XCNEW (struct outf);
1496 f->next = output_files;
1500 oprintf (f, "/* Type information for %s.\n", name);
1501 for (i = 0; i < ARRAY_SIZE (hdr); i++)
1502 oprintf (f, "%s", hdr[i]);
1506 /* Print, like fprintf, to O.
1507 N.B. You might think this could be implemented more efficiently
1508 with vsnprintf(). Unfortunately, there are C libraries that
1509 provide that function but without the C99 semantics for its return
1510 value, making it impossible to know how much space is required. */
1512 oprintf (outf_p o, const char *format, ...)
1518 /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1523 va_start (ap, format);
1524 slength = vasprintf (&s, format, ap);
1525 if (s == NULL || (int)slength < 0)
1526 fatal ("out of memory");
1529 if (o->bufused + slength > o->buflength)
1531 size_t new_len = o->buflength;
1536 } while (o->bufused + slength >= new_len);
1537 o->buf = XRESIZEVEC (char, o->buf, new_len);
1538 o->buflength = new_len;
1540 memcpy (o->buf + o->bufused, s, slength);
1541 o->bufused += slength;
1545 /* Open the global header file and the language-specific header files. */
1548 open_base_files (void)
1552 if (nb_plugin_files > 0 && plugin_files)
1555 header_file = create_file ("GCC", "gtype-desc.h");
1557 base_files = XNEWVEC (outf_p, num_lang_dirs);
1559 for (i = 0; i < num_lang_dirs; i++)
1560 base_files[i] = create_file (lang_dir_names[i],
1561 xasprintf ("gtype-%s.h", lang_dir_names[i]));
1563 /* gtype-desc.c is a little special, so we create it here. */
1565 /* The order of files here matters very much. */
1566 static const char *const ifiles [] = {
1567 "config.h", "system.h", "coretypes.h", "tm.h",
1568 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1569 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1570 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1571 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1572 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1573 "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h",
1574 "target.h", "ipa-prop.h", "lto-streamer.h", NULL
1576 const char *const *ifp;
1577 outf_p gtype_desc_c;
1579 gtype_desc_c = create_file ("GCC", "gtype-desc.c");
1580 for (ifp = ifiles; *ifp; ifp++)
1581 oprintf (gtype_desc_c, "#include \"%s\"\n", *ifp);
1583 /* Make sure we handle "cfun" specially. */
1584 oprintf (gtype_desc_c, "\n/* See definition in function.h. */\n");
1585 oprintf (gtype_desc_c, "#undef cfun\n");
1589 /* For F a filename, return the real basename of F, with all the directory
1590 components skipped. */
1593 get_file_realbasename (const char *f)
1595 const char * lastslash = strrchr (f, '/');
1597 return (lastslash != NULL) ? lastslash + 1 : f;
1600 /* For F a filename, return the relative path to F from $(srcdir) if the
1601 latter is a prefix in F, NULL otherwise. */
1604 get_file_srcdir_relative_path (const char *f)
1606 if (strlen (f) > srcdir_len
1607 && IS_DIR_SEPARATOR (f[srcdir_len])
1608 && memcmp (f, srcdir, srcdir_len) == 0)
1609 return f + srcdir_len + 1;
1614 /* For F a filename, return the relative path to F from $(srcdir) if the
1615 latter is a prefix in F, or the real basename of F otherwise. */
1618 get_file_basename (const char *f)
1620 const char * srcdir_path = get_file_srcdir_relative_path (f);
1622 return (srcdir_path != NULL) ? srcdir_path : get_file_realbasename (f);
1625 /* For F a filename, return the lang_dir_names relative index of the language
1626 directory that is a prefix in F, if any, -1 otherwise. */
1629 get_prefix_langdir_index (const char *f)
1631 size_t f_len = strlen (f);
1634 for (lang_index = 0; lang_index < num_lang_dirs; lang_index++)
1636 const char * langdir = lang_dir_names [lang_index];
1637 size_t langdir_len = strlen (langdir);
1639 if (f_len > langdir_len
1640 && IS_DIR_SEPARATOR (f[langdir_len])
1641 && memcmp (f, langdir, langdir_len) == 0)
1648 /* For F a filename, return the name of language directory where F is located,
1649 if any, NULL otherwise. */
1652 get_file_langdir (const char *f)
1654 /* Get the relative path to F from $(srcdir) and find the language by
1655 comparing the prefix with language directory names. If F is not even
1656 srcdir relative, no point in looking further. */
1659 const char * srcdir_relative_path = get_file_srcdir_relative_path (f);
1662 if (!srcdir_relative_path)
1665 lang_index = get_prefix_langdir_index (srcdir_relative_path);
1667 && strncmp (srcdir_relative_path, "c-family", 8) == 0)
1669 else if (lang_index >= 0)
1670 r = lang_dir_names [lang_index];
1677 /* The gt- output file name for F. */
1680 get_file_gtfilename (const char *f)
1682 /* Cook up an initial version of the gt- file name from the file real
1683 basename and the language name, if any. */
1685 const char *basename = get_file_realbasename (f);
1686 const char *langdir = get_file_langdir (f);
1689 (langdir ? xasprintf ("gt-%s-%s", langdir, basename)
1690 : xasprintf ("gt-%s", basename));
1692 /* Then replace all non alphanumerics characters by '-' and change the
1693 extension to ".h". We expect the input filename extension was at least
1694 one character long. */
1698 for (; *s != '.'; s++)
1699 if (! ISALNUM (*s) && *s != '-')
1702 memcpy (s, ".h", sizeof (".h"));
1707 /* An output file, suitable for definitions, that can see declarations
1708 made in INPUT_FILE and is linked into every language that uses
1712 get_output_file_with_visibility (const char *input_file)
1716 const char *basename;
1717 const char *for_name;
1718 const char *output_name;
1720 /* This can happen when we need a file with visibility on a
1721 structure that we've never seen. We have to just hope that it's
1722 globally visible. */
1723 if (input_file == NULL)
1724 input_file = "system.h";
1726 /* In plugin mode, return NULL unless the input_file is one of the
1731 for (i = 0; i < nb_plugin_files; i++)
1732 if (strcmp (input_file, plugin_files[i]) == 0)
1733 return plugin_output;
1738 /* Determine the output file name. */
1739 basename = get_file_basename (input_file);
1741 len = strlen (basename);
1742 if ((len > 2 && memcmp (basename+len-2, ".c", 2) == 0)
1743 || (len > 2 && memcmp (basename+len-2, ".y", 2) == 0)
1744 || (len > 3 && memcmp (basename+len-3, ".in", 3) == 0))
1746 output_name = get_file_gtfilename (input_file);
1747 for_name = basename;
1749 /* Some headers get used by more than one front-end; hence, it
1750 would be inappropriate to spew them out to a single gtype-<lang>.h
1751 (and gengtype doesn't know how to direct spewage into multiple
1752 gtype-<lang>.h headers at this time). Instead, we pair up these
1753 headers with source files (and their special purpose gt-*.h headers). */
1754 else if (strncmp (basename, "c-family", 8) == 0
1755 && IS_DIR_SEPARATOR (basename[8])
1756 && strcmp (basename + 9, "c-common.h") == 0)
1757 output_name = "gt-c-family-c-common.h", for_name = "c-family/c-common.c";
1758 else if (strcmp (basename, "c-lang.h") == 0)
1759 output_name = "gt-c-decl.h", for_name = "c-decl.c";
1760 else if (strcmp (basename, "c-tree.h") == 0)
1761 output_name = "gt-c-decl.h", for_name = "c-decl.c";
1762 else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2])
1763 && strcmp (basename + 3, "cp-tree.h") == 0)
1764 output_name = "gt-cp-tree.h", for_name = "cp/tree.c";
1765 else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2])
1766 && strcmp (basename + 3, "decl.h") == 0)
1767 output_name = "gt-cp-decl.h", for_name = "cp/decl.c";
1768 else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2])
1769 && strcmp (basename + 3, "name-lookup.h") == 0)
1770 output_name = "gt-cp-name-lookup.h", for_name = "cp/name-lookup.c";
1771 else if (strncmp (basename, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename[4])
1772 && strcmp (basename + 5, "objc-act.h") == 0)
1773 output_name = "gt-objc-objc-act.h", for_name = "objc/objc-act.c";
1776 int lang_index = get_prefix_langdir_index (basename);
1778 if (lang_index >= 0)
1779 return base_files[lang_index];
1781 output_name = "gtype-desc.c";
1785 /* Look through to see if we've ever seen this output filename before. */
1786 for (r = output_files; r; r = r->next)
1787 if (strcmp (r->name, output_name) == 0)
1790 /* If not, create it. */
1791 r = create_file (for_name, output_name);
1793 gcc_assert (r && r->name);
1797 /* The name of an output file, suitable for definitions, that can see
1798 declarations made in INPUT_FILE and is linked into every language
1799 that uses INPUT_FILE. */
1802 get_output_file_name (const char *input_file)
1804 outf_p o = get_output_file_with_visibility (input_file);
1810 /* Check if existing file is equal to the in memory buffer. */
1813 is_file_equal (outf_p of)
1815 FILE *newfile = fopen (of->name, "r");
1818 if (newfile == NULL)
1822 for (i = 0; i < of->bufused; i++)
1825 ch = fgetc (newfile);
1826 if (ch == EOF || ch != (unsigned char) of->buf[i])
1836 /* Copy the output to its final destination,
1837 but don't unnecessarily change modification times. */
1840 close_output_files (void)
1844 for (of = output_files; of; of = of->next)
1847 if (!is_file_equal(of))
1849 FILE *newfile = fopen (of->name, "w");
1850 if (newfile == NULL)
1851 fatal ("opening output file %s: %s", of->name, xstrerror (errno));
1852 if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused)
1853 fatal ("writing output file %s: %s", of->name, xstrerror (errno));
1854 if (fclose (newfile) != 0)
1855 fatal ("closing output file %s: %s", of->name, xstrerror (errno));
1859 of->bufused = of->buflength = 0;
1870 struct walk_type_data;
1872 /* For scalars and strings, given the item in 'val'.
1873 For structures, given a pointer to the item in 'val'.
1874 For misc. pointers, given the item in 'val'.
1876 typedef void (*process_field_fn)
1877 (type_p f, const struct walk_type_data *p);
1878 typedef void (*func_name_fn)
1879 (type_p s, const struct walk_type_data *p);
1881 /* Parameters for write_types. */
1883 struct write_types_data
1886 const char *param_prefix;
1887 const char *subfield_marker_routine;
1888 const char *marker_routine;
1889 const char *reorder_note_routine;
1890 const char *comment;
1891 int skip_hooks; /* skip hook generation if non zero */
1894 static void output_escaped_param (struct walk_type_data *d,
1895 const char *, const char *);
1896 static void output_mangled_typename (outf_p, const_type_p);
1897 static void walk_type (type_p t, struct walk_type_data *d);
1898 static void write_func_for_structure
1899 (type_p orig_s, type_p s, type_p * param,
1900 const struct write_types_data *wtd);
1901 static void write_types_process_field
1902 (type_p f, const struct walk_type_data *d);
1903 static void write_types (outf_p output_header,
1905 type_p param_structs,
1906 const struct write_types_data *wtd);
1907 static void write_types_local_process_field
1908 (type_p f, const struct walk_type_data *d);
1909 static void write_local_func_for_structure
1910 (const_type_p orig_s, type_p s, type_p * param);
1911 static void write_local (outf_p output_header,
1913 type_p param_structs);
1914 static void write_enum_defn (type_p structures, type_p param_structs);
1915 static int contains_scalar_p (type_p t);
1916 static void put_mangled_filename (outf_p , const char *);
1917 static void finish_root_table (struct flist *flp, const char *pfx,
1918 const char *tname, const char *lastname,
1920 static void write_root (outf_p , pair_p, type_p, const char *, int,
1921 struct fileloc *, const char *, bool);
1922 static void write_array (outf_p f, pair_p v,
1923 const struct write_types_data *wtd);
1924 static void write_roots (pair_p, bool);
1926 /* Parameters for walk_type. */
1928 struct walk_type_data
1930 process_field_fn process_field;
1935 const char *prev_val[4];
1938 const struct fileloc *line;
1943 const char *reorder_fn;
1945 bool fn_wants_lvalue;
1948 /* Print a mangled name representing T to OF. */
1951 output_mangled_typename (outf_p of, const_type_p t)
1955 else switch (t->kind)
1959 output_mangled_typename (of, t->u.p);
1969 case TYPE_LANG_STRUCT:
1970 oprintf (of, "%lu%s", (unsigned long) strlen (t->u.s.tag), t->u.s.tag);
1972 case TYPE_PARAM_STRUCT:
1975 for (i = 0; i < NUM_PARAM; i++)
1976 if (t->u.param_struct.param[i] != NULL)
1977 output_mangled_typename (of, t->u.param_struct.param[i]);
1978 output_mangled_typename (of, t->u.param_struct.stru);
1986 /* Print PARAM to D->OF processing escapes. D->VAL references the
1987 current object, D->PREV_VAL the object containing the current
1988 object, ONAME is the name of the option and D->LINE is used to
1989 print error messages. */
1992 output_escaped_param (struct walk_type_data *d, const char *param,
1997 for (p = param; *p; p++)
1999 oprintf (d->of, "%c", *p);
2003 oprintf (d->of, "(%s)", d->prev_val[2]);
2006 oprintf (d->of, "(%s)", d->prev_val[0]);
2009 oprintf (d->of, "(%s)", d->prev_val[1]);
2013 const char *pp = d->val + strlen (d->val);
2014 while (pp[-1] == ']')
2017 oprintf (d->of, "%s", pp);
2021 error_at_line (d->line, "`%s' option contains bad escape %c%c",
2026 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2027 which is of type T. Write code to D->OF to constrain execution (at
2028 the point that D->PROCESS_FIELD is called) to the appropriate
2029 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2030 pointers to those objects. D->PREV_VAL lists the objects
2031 containing the current object, D->OPT is a list of options to
2032 apply, D->INDENT is the current indentation level, D->LINE is used
2033 to print error messages, D->BITMAP indicates which languages to
2034 print the structure for, and D->PARAM is the current parameter
2035 (from an enclosing param_is option). */
2038 walk_type (type_p t, struct walk_type_data *d)
2040 const char *length = NULL;
2041 const char *desc = NULL;
2042 int maybe_undef_p = 0;
2043 int use_param_num = -1;
2044 int use_params_p = 0;
2046 const struct nested_ptr_data *nested_ptr_d = NULL;
2048 d->needs_cast_p = false;
2049 for (oo = d->opt; oo; oo = oo->next)
2050 if (strcmp (oo->name, "length") == 0)
2052 else if (strcmp (oo->name, "maybe_undef") == 0)
2054 else if (strncmp (oo->name, "use_param", 9) == 0
2055 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
2056 use_param_num = oo->name[9] == '\0' ? 0 : oo->name[9] - '0';
2057 else if (strcmp (oo->name, "use_params") == 0)
2059 else if (strcmp (oo->name, "desc") == 0)
2061 else if (strcmp (oo->name, "mark_hook") == 0)
2063 else if (strcmp (oo->name, "nested_ptr") == 0)
2064 nested_ptr_d = (const struct nested_ptr_data *) oo->info;
2065 else if (strcmp (oo->name, "dot") == 0)
2067 else if (strcmp (oo->name, "tag") == 0)
2069 else if (strcmp (oo->name, "special") == 0)
2071 else if (strcmp (oo->name, "skip") == 0)
2073 else if (strcmp (oo->name, "default") == 0)
2075 else if (strcmp (oo->name, "descbits") == 0)
2077 else if (strcmp (oo->name, "param_is") == 0)
2079 else if (strncmp (oo->name, "param", 5) == 0
2080 && ISDIGIT (oo->name[5])
2081 && strcmp (oo->name + 6, "_is") == 0)
2083 else if (strcmp (oo->name, "chain_next") == 0)
2085 else if (strcmp (oo->name, "chain_prev") == 0)
2087 else if (strcmp (oo->name, "chain_circular") == 0)
2089 else if (strcmp (oo->name, "reorder") == 0)
2092 error_at_line (d->line, "unknown option `%s'\n", oo->name);
2099 int pointer_p = t->kind == TYPE_POINTER;
2103 if (! UNION_OR_STRUCT_P (t))
2104 error_at_line (d->line, "`use_params' option on unimplemented type");
2106 t = find_param_structure (t, d->param);
2108 t = create_pointer (t);
2111 if (use_param_num != -1)
2113 if (d->param != NULL && d->param[use_param_num] != NULL)
2115 type_p nt = d->param[use_param_num];
2117 if (t->kind == TYPE_ARRAY)
2118 nt = create_array (nt, t->u.a.len);
2119 else if (length != NULL && t->kind == TYPE_POINTER)
2120 nt = create_pointer (nt);
2121 d->needs_cast_p = (t->kind != TYPE_POINTER
2122 && (nt->kind == TYPE_POINTER
2123 || nt->kind == TYPE_STRING));
2127 error_at_line (d->line, "no parameter defined for `%s'",
2132 && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p)))
2134 error_at_line (d->line,
2135 "field `%s' has invalid option `maybe_undef_p'\n",
2144 d->process_field (t, d);
2150 && t->u.p->u.s.line.file == NULL)
2152 oprintf (d->of, "%*sgcc_assert (!%s);\n", d->indent, "", d->val);
2158 if (! UNION_OR_STRUCT_P (t->u.p)
2159 && t->u.p->kind != TYPE_PARAM_STRUCT)
2161 error_at_line (d->line,
2162 "field `%s' is pointer to unimplemented type",
2169 const char *oldprevval2 = d->prev_val[2];
2171 if (! UNION_OR_STRUCT_P (nested_ptr_d->type))
2173 error_at_line (d->line,
2174 "field `%s' has invalid "
2175 "option `nested_ptr'\n",
2180 d->prev_val[2] = d->val;
2181 oprintf (d->of, "%*s{\n", d->indent, "");
2183 d->val = xasprintf ("x%d", d->counter++);
2184 oprintf (d->of, "%*s%s %s * %s%s =\n", d->indent, "",
2185 (nested_ptr_d->type->kind == TYPE_UNION
2186 ? "union" : "struct"),
2187 nested_ptr_d->type->u.s.tag,
2188 d->fn_wants_lvalue ? "" : "const ",
2190 oprintf (d->of, "%*s", d->indent + 2, "");
2191 output_escaped_param (d, nested_ptr_d->convert_from,
2193 oprintf (d->of, ";\n");
2195 d->process_field (nested_ptr_d->type, d);
2197 if (d->fn_wants_lvalue)
2199 oprintf (d->of, "%*s%s = ", d->indent, "",
2201 d->prev_val[2] = d->val;
2202 output_escaped_param (d, nested_ptr_d->convert_to,
2204 oprintf (d->of, ";\n");
2208 oprintf (d->of, "%*s}\n", d->indent, "");
2209 d->val = d->prev_val[2];
2210 d->prev_val[2] = oldprevval2;
2213 d->process_field (t->u.p, d);
2217 int loopcounter = d->counter++;
2218 const char *oldval = d->val;
2219 const char *oldprevval3 = d->prev_val[3];
2222 oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val);
2224 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
2225 oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent, "",
2226 loopcounter, loopcounter);
2227 output_escaped_param (d, length, "length");
2228 oprintf (d->of, "); i%d++) {\n", loopcounter);
2230 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
2232 d->prev_val[3] = oldval;
2233 walk_type (t->u.p, d);
2236 d->prev_val[3] = oldprevval3;
2239 oprintf (d->of, "%*s}\n", d->indent, "");
2240 d->process_field(t, d);
2242 oprintf (d->of, "%*s}\n", d->indent, "");
2249 int loopcounter = d->counter++;
2250 const char *oldval = d->val;
2253 /* If it's an array of scalars, we optimize by not generating
2255 if (t->u.a.p->kind == TYPE_SCALAR)
2258 /* When walking an array, compute the length and store it in a
2259 local variable before walking the array elements, instead of
2260 recomputing the length expression each time through the loop.
2261 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2262 where the length is stored in the first array element,
2263 because otherwise that operand can get overwritten on the
2265 oprintf (d->of, "%*s{\n", d->indent, "");
2267 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
2268 oprintf (d->of, "%*ssize_t l%d = (size_t)(",
2269 d->indent, "", loopcounter);
2271 output_escaped_param (d, length, "length");
2273 oprintf (d->of, "%s", t->u.a.len);
2274 oprintf (d->of, ");\n");
2276 oprintf (d->of, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2278 loopcounter, loopcounter, loopcounter, loopcounter);
2280 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
2282 walk_type (t->u.a.p, d);
2287 oprintf (d->of, "%*s}\n", d->indent, "");
2289 oprintf (d->of, "%*s}\n", d->indent, "");
2297 const char *oldval = d->val;
2298 const char *oldprevval1 = d->prev_val[1];
2299 const char *oldprevval2 = d->prev_val[2];
2300 const int union_p = t->kind == TYPE_UNION;
2301 int seen_default_p = 0;
2304 if (! t->u.s.line.file)
2305 error_at_line (d->line, "incomplete structure `%s'", t->u.s.tag);
2307 if ((d->bitmap & t->u.s.bitmap) != d->bitmap)
2309 error_at_line (d->line,
2310 "structure `%s' defined for mismatching languages",
2312 error_at_line (&t->u.s.line, "one structure defined here");
2315 /* Some things may also be defined in the structure's options. */
2316 for (o = t->u.s.opt; o; o = o->next)
2317 if (! desc && strcmp (o->name, "desc") == 0)
2320 d->prev_val[2] = oldval;
2321 d->prev_val[1] = oldprevval2;
2326 error_at_line (d->line, "missing `desc' option for union `%s'",
2330 oprintf (d->of, "%*sswitch (", d->indent, "");
2331 output_escaped_param (d, desc, "desc");
2332 oprintf (d->of, ")\n");
2334 oprintf (d->of, "%*s{\n", d->indent, "");
2336 for (f = t->u.s.fields; f; f = f->next)
2339 const char *dot = ".";
2340 const char *tagid = NULL;
2343 int use_param_p = 0;
2346 d->reorder_fn = NULL;
2347 for (oo = f->opt; oo; oo = oo->next)
2348 if (strcmp (oo->name, "dot") == 0)
2350 else if (strcmp (oo->name, "tag") == 0)
2352 else if (strcmp (oo->name, "skip") == 0)
2354 else if (strcmp (oo->name, "default") == 0)
2356 else if (strcmp (oo->name, "reorder") == 0)
2357 d->reorder_fn = oo->info;
2358 else if (strncmp (oo->name, "use_param", 9) == 0
2359 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
2365 if (union_p && tagid)
2367 oprintf (d->of, "%*scase %s:\n", d->indent, "", tagid);
2370 else if (union_p && default_p)
2372 oprintf (d->of, "%*sdefault:\n", d->indent, "");
2376 else if (! union_p && (default_p || tagid))
2377 error_at_line (d->line,
2378 "can't use `%s' outside a union on field `%s'",
2379 default_p ? "default" : "tag", f->name);
2380 else if (union_p && ! (default_p || tagid)
2381 && f->type->kind == TYPE_SCALAR)
2384 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2385 d->line->file, d->line->line, f->name);
2388 else if (union_p && ! (default_p || tagid))
2389 error_at_line (d->line,
2390 "field `%s' is missing `tag' or `default' option",
2394 d->val = newval = xasprintf ("%s%s%s", oldval, dot, f->name);
2396 d->used_length = false;
2398 if (union_p && use_param_p && d->param == NULL)
2399 oprintf (d->of, "%*sgcc_unreachable ();\n", d->indent, "");
2401 walk_type (f->type, d);
2407 oprintf (d->of, "%*sbreak;\n", d->indent, "");
2411 d->reorder_fn = NULL;
2414 d->prev_val[1] = oldprevval1;
2415 d->prev_val[2] = oldprevval2;
2417 if (union_p && ! seen_default_p)
2419 oprintf (d->of, "%*sdefault:\n", d->indent, "");
2420 oprintf (d->of, "%*s break;\n", d->indent, "");
2424 oprintf (d->of, "%*s}\n", d->indent, "");
2430 case TYPE_LANG_STRUCT:
2433 for (nt = t->u.s.lang_struct; nt; nt = nt->next)
2434 if ((d->bitmap & nt->u.s.bitmap) == d->bitmap)
2437 error_at_line (d->line, "structure `%s' differs between languages",
2444 case TYPE_PARAM_STRUCT:
2446 type_p *oldparam = d->param;
2448 d->param = t->u.param_struct.param;
2449 walk_type (t->u.param_struct.stru, d);
2450 d->param = oldparam;
2459 /* process_field routine for marking routines. */
2462 write_types_process_field (type_p f, const struct walk_type_data *d)
2464 const struct write_types_data *wtd;
2465 const char *cast = d->needs_cast_p ? "(void *)" : "";
2466 wtd = (const struct write_types_data *) d->cookie;
2471 oprintf (d->of, "%*s%s (%s%s", d->indent, "",
2472 wtd->subfield_marker_routine, cast, d->val);
2473 if (wtd->param_prefix)
2475 oprintf (d->of, ", %s", d->prev_val[3]);
2478 oprintf (d->of, ", gt_%s_", wtd->param_prefix);
2479 output_mangled_typename (d->of, d->orig_s);
2482 oprintf (d->of, ", gt_%sa_%s", wtd->param_prefix, d->prev_val[0]);
2484 if (f->u.p->kind == TYPE_PARAM_STRUCT
2485 && f->u.p->u.s.line.file != NULL)
2487 oprintf (d->of, ", gt_e_");
2488 output_mangled_typename (d->of, f);
2490 else if (UNION_OR_STRUCT_P (f)
2491 && f->u.p->u.s.line.file != NULL)
2493 oprintf (d->of, ", gt_ggc_e_");
2494 output_mangled_typename (d->of, f);
2497 oprintf (d->of, ", gt_types_enum_last");
2499 oprintf (d->of, ");\n");
2500 if (d->reorder_fn && wtd->reorder_note_routine)
2501 oprintf (d->of, "%*s%s (%s%s, %s, %s);\n", d->indent, "",
2502 wtd->reorder_note_routine, cast, d->val,
2503 d->prev_val[3], d->reorder_fn);
2509 case TYPE_LANG_STRUCT:
2510 case TYPE_PARAM_STRUCT:
2511 oprintf (d->of, "%*sgt_%s_", d->indent, "", wtd->prefix);
2512 output_mangled_typename (d->of, f);
2513 oprintf (d->of, " (%s%s);\n", cast, d->val);
2514 if (d->reorder_fn && wtd->reorder_note_routine)
2515 oprintf (d->of, "%*s%s (%s%s, %s%s, %s);\n", d->indent, "",
2516 wtd->reorder_note_routine, cast, d->val, cast, d->val,
2528 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2531 output_type_enum (outf_p of, type_p s)
2533 if (s->kind == TYPE_PARAM_STRUCT && s->u.s.line.file != NULL)
2535 oprintf (of, ", gt_e_");
2536 output_mangled_typename (of, s);
2538 else if (UNION_OR_STRUCT_P (s) && s->u.s.line.file != NULL)
2540 oprintf (of, ", gt_ggc_e_");
2541 output_mangled_typename (of, s);
2544 oprintf (of, ", gt_types_enum_last");
2547 /* Return an output file that is suitable for definitions which can
2548 reference struct S */
2551 get_output_file_for_structure (const_type_p s, type_p *param)
2553 const char * fn = s->u.s.line.file;
2556 /* This is a hack, and not the good kind either. */
2557 for (i = NUM_PARAM - 1; i >= 0; i--)
2558 if (param && param[i] && param[i]->kind == TYPE_POINTER
2559 && UNION_OR_STRUCT_P (param[i]->u.p))
2560 fn = param[i]->u.p->u.s.line.file;
2562 return get_output_file_with_visibility (fn);
2565 /* For S, a structure that's part of ORIG_S, and using parameters
2566 PARAM, write out a routine that:
2567 - Takes a parameter, a void * but actually of type *S
2568 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2569 field of S or its substructures and (in some cases) things
2570 that are pointed to by S.
2574 write_func_for_structure (type_p orig_s, type_p s, type_p *param,
2575 const struct write_types_data *wtd)
2577 const char *chain_next = NULL;
2578 const char *chain_prev = NULL;
2579 const char *chain_circular = NULL;
2580 const char *mark_hook_name = NULL;
2582 struct walk_type_data d;
2584 memset (&d, 0, sizeof (d));
2585 d.of = get_output_file_for_structure (s, param);
2587 for (opt = s->u.s.opt; opt; opt = opt->next)
2588 if (strcmp (opt->name, "chain_next") == 0)
2589 chain_next = opt->info;
2590 else if (strcmp (opt->name, "chain_prev") == 0)
2591 chain_prev = opt->info;
2592 else if (strcmp (opt->name, "chain_circular") == 0)
2593 chain_circular = opt->info;
2594 else if (strcmp (opt->name, "mark_hook") == 0)
2595 mark_hook_name = opt->info;
2597 if (chain_prev != NULL && chain_next == NULL)
2598 error_at_line (&s->u.s.line, "chain_prev without chain_next");
2599 if (chain_circular != NULL && chain_next != NULL)
2600 error_at_line (&s->u.s.line, "chain_circular with chain_next");
2601 if (chain_circular != NULL)
2602 chain_next = chain_circular;
2604 d.process_field = write_types_process_field;
2608 d.line = &s->u.s.line;
2609 d.bitmap = s->u.s.bitmap;
2611 d.prev_val[0] = "*x";
2612 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
2613 d.prev_val[3] = "x";
2616 oprintf (d.of, "\n");
2617 oprintf (d.of, "void\n");
2619 oprintf (d.of, "gt_%sx_%s", wtd->prefix, orig_s->u.s.tag);
2622 oprintf (d.of, "gt_%s_", wtd->prefix);
2623 output_mangled_typename (d.of, orig_s);
2625 oprintf (d.of, " (void *x_p)\n");
2626 oprintf (d.of, "{\n");
2627 oprintf (d.of, " %s %s * %sx = (%s %s *)x_p;\n",
2628 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag,
2629 chain_next == NULL ? "const " : "",
2630 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2631 if (chain_next != NULL)
2632 oprintf (d.of, " %s %s * xlimit = x;\n",
2633 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2634 if (chain_next == NULL)
2636 oprintf (d.of, " if (%s (x", wtd->marker_routine);
2637 if (wtd->param_prefix)
2639 oprintf (d.of, ", x, gt_%s_", wtd->param_prefix);
2640 output_mangled_typename (d.of, orig_s);
2641 output_type_enum (d.of, orig_s);
2643 oprintf (d.of, "))\n");
2647 if (chain_circular != NULL)
2648 oprintf (d.of, " if (!%s (xlimit", wtd->marker_routine);
2650 oprintf (d.of, " while (%s (xlimit", wtd->marker_routine);
2651 if (wtd->param_prefix)
2653 oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix);
2654 output_mangled_typename (d.of, orig_s);
2655 output_type_enum (d.of, orig_s);
2657 oprintf (d.of, "))\n");
2658 if (chain_circular != NULL)
2659 oprintf (d.of, " return;\n do\n");
2660 if (mark_hook_name && !wtd->skip_hooks)
2662 oprintf (d.of, " {\n");
2663 oprintf (d.of, " %s (xlimit);\n ", mark_hook_name);
2665 oprintf (d.of, " xlimit = (");
2666 d.prev_val[2] = "*xlimit";
2667 output_escaped_param (&d, chain_next, "chain_next");
2668 oprintf (d.of, ");\n");
2669 if (mark_hook_name && !wtd->skip_hooks)
2670 oprintf (d.of, " }\n");
2671 if (chain_prev != NULL)
2673 oprintf (d.of, " if (x != xlimit)\n");
2674 oprintf (d.of, " for (;;)\n");
2675 oprintf (d.of, " {\n");
2676 oprintf (d.of, " %s %s * const xprev = (",
2677 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2679 d.prev_val[2] = "*x";
2680 output_escaped_param (&d, chain_prev, "chain_prev");
2681 oprintf (d.of, ");\n");
2682 oprintf (d.of, " if (xprev == NULL) break;\n");
2683 oprintf (d.of, " x = xprev;\n");
2684 oprintf (d.of, " (void) %s (xprev",
2685 wtd->marker_routine);
2686 if (wtd->param_prefix)
2688 oprintf (d.of, ", xprev, gt_%s_", wtd->param_prefix);
2689 output_mangled_typename (d.of, orig_s);
2690 output_type_enum (d.of, orig_s);
2692 oprintf (d.of, ");\n");
2693 oprintf (d.of, " }\n");
2695 if (chain_circular != NULL)
2697 oprintf (d.of, " while (%s (xlimit", wtd->marker_routine);
2698 if (wtd->param_prefix)
2700 oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix);
2701 output_mangled_typename (d.of, orig_s);
2702 output_type_enum (d.of, orig_s);
2704 oprintf (d.of, "));\n");
2705 if (mark_hook_name && !wtd->skip_hooks)
2706 oprintf (d.of, " %s (xlimit);\n", mark_hook_name);
2707 oprintf (d.of, " do\n");
2710 oprintf (d.of, " while (x != xlimit)\n");
2712 oprintf (d.of, " {\n");
2713 if (mark_hook_name && chain_next == NULL && !wtd->skip_hooks)
2715 oprintf (d.of, " %s (x);\n", mark_hook_name);
2717 d.prev_val[2] = "*x";
2721 if (chain_next != NULL)
2723 oprintf (d.of, " x = (");
2724 output_escaped_param (&d, chain_next, "chain_next");
2725 oprintf (d.of, ");\n");
2728 oprintf (d.of, " }\n");
2729 if (chain_circular != NULL)
2730 oprintf (d.of, " while (x != xlimit);\n");
2731 oprintf (d.of, "}\n");
2734 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
2737 write_types (outf_p output_header, type_p structures, type_p param_structs,
2738 const struct write_types_data *wtd)
2742 oprintf (output_header, "\n/* %s*/\n", wtd->comment);
2743 /* We first emit the macros and the declarations. Functions' code is
2744 emitted afterwards. This is needed in plugin mode. */
2745 oprintf (output_header, "/* macros and declarations */\n");
2746 for (s = structures; s; s = s->next)
2747 if (s->gc_used == GC_POINTED_TO
2748 || s->gc_used == GC_MAYBE_POINTED_TO)
2752 if (s->gc_used == GC_MAYBE_POINTED_TO
2753 && s->u.s.line.file == NULL)
2756 oprintf (output_header, "#define gt_%s_", wtd->prefix);
2757 output_mangled_typename (output_header, s);
2758 oprintf (output_header, "(X) do { \\\n");
2759 oprintf (output_header,
2760 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd->prefix,
2762 oprintf (output_header,
2765 for (opt = s->u.s.opt; opt; opt = opt->next)
2766 if (strcmp (opt->name, "ptr_alias") == 0)
2768 const_type_p const t = (const_type_p) opt->info;
2769 if (t->kind == TYPE_STRUCT
2770 || t->kind == TYPE_UNION
2771 || t->kind == TYPE_LANG_STRUCT)
2772 oprintf (output_header,
2773 "#define gt_%sx_%s gt_%sx_%s\n",
2774 wtd->prefix, s->u.s.tag, wtd->prefix, t->u.s.tag);
2776 error_at_line (&s->u.s.line,
2777 "structure alias is not a structure");
2783 /* Declare the marker procedure only once. */
2784 oprintf (output_header,
2785 "extern void gt_%sx_%s (void *);\n",
2786 wtd->prefix, s->u.s.tag);
2788 if (s->u.s.line.file == NULL)
2790 fprintf (stderr, "warning: structure `%s' used but not defined\n",
2796 for (s = param_structs; s; s = s->next)
2797 if (s->gc_used == GC_POINTED_TO)
2799 type_p stru = s->u.param_struct.stru;
2801 /* Declare the marker procedure. */
2802 oprintf (output_header, "extern void gt_%s_", wtd->prefix);
2803 output_mangled_typename (output_header, s);
2804 oprintf (output_header, " (void *);\n");
2806 if (stru->u.s.line.file == NULL)
2808 fprintf (stderr, "warning: structure `%s' used but not defined\n",
2814 /* At last we emit the functions code. */
2815 oprintf (output_header, "\n/* functions code */\n");
2816 for (s = structures; s; s = s->next)
2817 if (s->gc_used == GC_POINTED_TO
2818 || s->gc_used == GC_MAYBE_POINTED_TO)
2822 if (s->gc_used == GC_MAYBE_POINTED_TO
2823 && s->u.s.line.file == NULL)
2825 for (opt = s->u.s.opt; opt; opt = opt->next)
2826 if (strcmp (opt->name, "ptr_alias") == 0)
2831 if (s->kind == TYPE_LANG_STRUCT)
2834 for (ss = s->u.s.lang_struct; ss; ss = ss->next)
2835 write_func_for_structure (s, ss, NULL, wtd);
2838 write_func_for_structure (s, s, NULL, wtd);
2840 for (s = param_structs; s; s = s->next)
2841 if (s->gc_used == GC_POINTED_TO)
2843 type_p *param = s->u.param_struct.param;
2844 type_p stru = s->u.param_struct.stru;
2845 if (stru->u.s.line.file == NULL)
2847 if (stru->kind == TYPE_LANG_STRUCT)
2850 for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
2851 write_func_for_structure (s, ss, param, wtd);
2854 write_func_for_structure (s, stru, param, wtd);
2858 static const struct write_types_data ggc_wtd =
2860 "ggc_m", NULL, "ggc_mark", "ggc_test_and_set_mark", NULL,
2861 "GC marker procedures. ",
2865 static const struct write_types_data pch_wtd =
2867 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
2868 "gt_pch_note_reorder",
2869 "PCH type-walking procedures. ",
2873 /* Write out the local pointer-walking routines. */
2875 /* process_field routine for local pointer-walking. */
2878 write_types_local_process_field (type_p f, const struct walk_type_data *d)
2885 case TYPE_LANG_STRUCT:
2886 case TYPE_PARAM_STRUCT:
2888 oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "",
2890 oprintf (d->of, "%*s op (&(%s), cookie);\n", d->indent, "", d->val);
2901 /* For S, a structure that's part of ORIG_S, and using parameters
2902 PARAM, write out a routine that:
2903 - Is of type gt_note_pointers
2904 - Calls PROCESS_FIELD on each field of S or its substructures.
2908 write_local_func_for_structure (const_type_p orig_s, type_p s, type_p *param)
2910 struct walk_type_data d;
2912 memset (&d, 0, sizeof (d));
2913 d.of = get_output_file_for_structure (s, param);
2914 d.process_field = write_types_local_process_field;
2916 d.line = &s->u.s.line;
2917 d.bitmap = s->u.s.bitmap;
2919 d.prev_val[0] = d.prev_val[2] = "*x";
2920 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
2921 d.prev_val[3] = "x";
2923 d.fn_wants_lvalue = true;
2925 oprintf (d.of, "\n");
2926 oprintf (d.of, "void\n");
2927 oprintf (d.of, "gt_pch_p_");
2928 output_mangled_typename (d.of, orig_s);
2929 oprintf (d.of, " (ATTRIBUTE_UNUSED void *this_obj,\n"
2931 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2932 "\tATTRIBUTE_UNUSED void *cookie)\n");
2933 oprintf (d.of, "{\n");
2934 oprintf (d.of, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
2935 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag,
2936 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2939 oprintf (d.of, "}\n");
2942 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
2945 write_local (outf_p output_header, type_p structures, type_p param_structs)
2951 oprintf (output_header, "\n/* Local pointer-walking routines. */\n");
2952 for (s = structures; s; s = s->next)
2953 if (s->gc_used == GC_POINTED_TO
2954 || s->gc_used == GC_MAYBE_POINTED_TO)
2958 if (s->u.s.line.file == NULL)
2961 for (opt = s->u.s.opt; opt; opt = opt->next)
2962 if (strcmp (opt->name, "ptr_alias") == 0)
2964 const_type_p const t = (const_type_p) opt->info;
2965 if (t->kind == TYPE_STRUCT
2966 || t->kind == TYPE_UNION
2967 || t->kind == TYPE_LANG_STRUCT)
2969 oprintf (output_header, "#define gt_pch_p_");
2970 output_mangled_typename (output_header, s);
2971 oprintf (output_header, " gt_pch_p_");
2972 output_mangled_typename (output_header, t);
2973 oprintf (output_header, "\n");
2976 error_at_line (&s->u.s.line,
2977 "structure alias is not a structure");
2983 /* Declare the marker procedure only once. */
2984 oprintf (output_header, "extern void gt_pch_p_");
2985 output_mangled_typename (output_header, s);
2986 oprintf (output_header,
2987 "\n (void *, void *, gt_pointer_operator, void *);\n");
2989 if (s->kind == TYPE_LANG_STRUCT)
2992 for (ss = s->u.s.lang_struct; ss; ss = ss->next)
2993 write_local_func_for_structure (s, ss, NULL);
2996 write_local_func_for_structure (s, s, NULL);
2999 for (s = param_structs; s; s = s->next)
3000 if (s->gc_used == GC_POINTED_TO)
3002 type_p * param = s->u.param_struct.param;
3003 type_p stru = s->u.param_struct.stru;
3005 /* Declare the marker procedure. */
3006 oprintf (output_header, "extern void gt_pch_p_");
3007 output_mangled_typename (output_header, s);
3008 oprintf (output_header,
3009 "\n (void *, void *, gt_pointer_operator, void *);\n");
3011 if (stru->u.s.line.file == NULL)
3013 fprintf (stderr, "warning: structure `%s' used but not defined\n",
3018 if (stru->kind == TYPE_LANG_STRUCT)
3021 for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
3022 write_local_func_for_structure (s, ss, param);
3025 write_local_func_for_structure (s, stru, param);
3029 /* Write out the 'enum' definition for gt_types_enum. */
3032 write_enum_defn (type_p structures, type_p param_structs)
3038 oprintf (header_file, "\n/* Enumeration of types known. */\n");
3039 oprintf (header_file, "enum gt_types_enum {\n");
3040 for (s = structures; s; s = s->next)
3041 if (s->gc_used == GC_POINTED_TO
3042 || s->gc_used == GC_MAYBE_POINTED_TO)
3044 if (s->gc_used == GC_MAYBE_POINTED_TO
3045 && s->u.s.line.file == NULL)
3048 oprintf (header_file, " gt_ggc_e_");
3049 output_mangled_typename (header_file, s);
3050 oprintf (header_file, ", \n");
3052 for (s = param_structs; s; s = s->next)
3053 if (s->gc_used == GC_POINTED_TO)
3055 oprintf (header_file, " gt_e_");
3056 output_mangled_typename (header_file, s);
3057 oprintf (header_file, ", \n");
3059 oprintf (header_file, " gt_types_enum_last\n");
3060 oprintf (header_file, "};\n");
3063 /* Might T contain any non-pointer elements? */
3066 contains_scalar_p (type_p t)
3074 return contains_scalar_p (t->u.a.p);
3076 /* Could also check for structures that have no non-pointer
3077 fields, but there aren't enough of those to worry about. */
3082 /* Mangle FN and print it to F. */
3085 put_mangled_filename (outf_p f, const char *fn)
3087 const char *name = get_output_file_name (fn);
3090 for (; *name != 0; name++)
3091 if (ISALNUM (*name))
3092 oprintf (f, "%c", *name);
3094 oprintf (f, "%c", '_');
3097 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
3098 LASTNAME, and NAME are all strings to insert in various places in
3099 the resulting code. */
3102 finish_root_table (struct flist *flp, const char *pfx, const char *lastname,
3103 const char *tname, const char *name)
3107 for (fli2 = flp; fli2; fli2 = fli2->next)
3108 if (fli2->started_p)
3110 oprintf (fli2->f, " %s\n", lastname);
3111 oprintf (fli2->f, "};\n\n");
3114 for (fli2 = flp; fli2 && base_files; fli2 = fli2->next)
3115 if (fli2->started_p)
3117 lang_bitmap bitmap = get_lang_bitmap (fli2->name);
3120 for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1)
3123 oprintf (base_files[fnum],
3124 "extern const struct %s gt_%s_",
3126 put_mangled_filename (base_files[fnum], fli2->name);
3127 oprintf (base_files[fnum], "[];\n");
3133 for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
3134 oprintf (base_files [fnum],
3135 "EXPORTED_CONST struct %s * const %s[] = {\n",
3140 for (fli2 = flp; fli2; fli2 = fli2->next)
3141 if (fli2->started_p)
3143 lang_bitmap bitmap = get_lang_bitmap (fli2->name);
3146 fli2->started_p = 0;
3148 for (fnum = 0; base_files && bitmap != 0; fnum++, bitmap >>= 1)
3151 oprintf (base_files[fnum], " gt_%s_", pfx);
3152 put_mangled_filename (base_files[fnum], fli2->name);
3153 oprintf (base_files[fnum], ",\n");
3159 for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
3161 oprintf (base_files[fnum], " NULL\n");
3162 oprintf (base_files[fnum], "};\n");
3167 /* Write out to F the table entry and any marker routines needed to
3168 mark NAME as TYPE. The original variable is V, at LINE.
3169 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
3170 is nonzero iff we are building the root table for hash table caches. */
3173 write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
3174 struct fileloc *line, const char *if_marked, bool emit_pch)
3181 for (fld = type->u.s.fields; fld; fld = fld->next)
3184 const char *desc = NULL;
3187 for (o = fld->opt; o; o = o->next)
3188 if (strcmp (o->name, "skip") == 0)
3190 else if (strcmp (o->name, "desc") == 0)
3192 else if (strcmp (o->name, "param_is") == 0)
3195 error_at_line (line,
3196 "field `%s' of global `%s' has unknown option `%s'",
3197 fld->name, name, o->name);
3201 else if (desc && fld->type->kind == TYPE_UNION)
3203 pair_p validf = NULL;
3206 for (ufld = fld->type->u.s.fields; ufld; ufld = ufld->next)
3208 const char *tag = NULL;
3211 for (oo = ufld->opt; oo; oo = oo->next)
3212 if (strcmp (oo->name, "tag") == 0)
3214 if (tag == NULL || strcmp (tag, desc) != 0)
3217 error_at_line (line,
3218 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3219 name, fld->name, validf->name,
3220 name, fld->name, ufld->name,
3227 newname = xasprintf ("%s.%s.%s",
3228 name, fld->name, validf->name);
3229 write_root (f, v, validf->type, newname, 0, line,
3230 if_marked, emit_pch);
3235 error_at_line (line,
3236 "global `%s.%s' has `desc' option but is not union",
3241 newname = xasprintf ("%s.%s", name, fld->name);
3242 write_root (f, v, fld->type, newname, 0, line, if_marked,
3253 newname = xasprintf ("%s[0]", name);
3254 write_root (f, v, type->u.a.p, newname, has_length, line, if_marked,
3264 oprintf (f, " {\n");
3265 oprintf (f, " &%s,\n", name);
3268 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
3270 oprintf (f, " * (%s)", ap->u.a.len);
3271 else if (ap == v->type)
3272 oprintf (f, " * ARRAY_SIZE (%s)", v->name);
3274 oprintf (f, " sizeof (%s", v->name);
3275 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
3277 oprintf (f, "),\n");
3281 if (! has_length && UNION_OR_STRUCT_P (tp))
3283 oprintf (f, " >_ggc_mx_%s,\n", tp->u.s.tag);
3285 oprintf (f, " >_pch_nx_%s", tp->u.s.tag);
3287 oprintf (f, " NULL");
3289 else if (! has_length && tp->kind == TYPE_PARAM_STRUCT)
3291 oprintf (f, " >_ggc_m_");
3292 output_mangled_typename (f, tp);
3295 oprintf (f, ",\n >_pch_n_");
3296 output_mangled_typename (f, tp);
3299 oprintf (f, ",\n NULL");
3302 && (tp->kind == TYPE_POINTER || UNION_OR_STRUCT_P (tp)))
3304 oprintf (f, " >_ggc_ma_%s,\n", name);
3306 oprintf (f, " >_pch_na_%s", name);
3308 oprintf (f, " NULL");
3312 error_at_line (line,
3313 "global `%s' is pointer to unimplemented type",
3317 oprintf (f, ",\n &%s", if_marked);
3318 oprintf (f, "\n },\n");
3324 oprintf (f, " {\n");
3325 oprintf (f, " &%s,\n", name);
3326 oprintf (f, " 1, \n");
3327 oprintf (f, " sizeof (%s),\n", v->name);
3328 oprintf (f, " (gt_pointer_walker) >_ggc_m_S,\n");
3329 oprintf (f, " (gt_pointer_walker) >_pch_n_S\n");
3330 oprintf (f, " },\n");
3338 error_at_line (line,
3339 "global `%s' is unimplemented type",
3344 /* This generates a routine to walk an array. */
3347 write_array (outf_p f, pair_p v, const struct write_types_data *wtd)
3349 struct walk_type_data d;
3352 memset (&d, 0, sizeof (d));
3358 d.bitmap = get_lang_bitmap (v->line.file);
3361 d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name);
3363 if (wtd->param_prefix)
3365 oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name);
3367 " (void *, void *, gt_pointer_operator, void *);\n");
3368 oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3369 wtd->param_prefix, v->name);
3371 " ATTRIBUTE_UNUSED void *x_p,\n"
3372 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3373 " ATTRIBUTE_UNUSED void * cookie)\n");
3374 oprintf (d.of, "{\n");
3375 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
3376 d.process_field = write_types_local_process_field;
3377 walk_type (v->type, &d);
3378 oprintf (f, "}\n\n");
3382 oprintf (f, "static void gt_%sa_%s (void *);\n",
3383 wtd->prefix, v->name);
3384 oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3385 wtd->prefix, v->name);
3387 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
3388 d.process_field = write_types_process_field;
3389 walk_type (v->type, &d);
3391 oprintf (f, "}\n\n");
3394 /* Output a table describing the locations and types of VARIABLES. */
3397 write_roots (pair_p variables, bool emit_pch)
3400 struct flist *flp = NULL;
3402 for (v = variables; v; v = v->next)
3404 outf_p f = get_output_file_with_visibility (v->line.file);
3406 const char *length = NULL;
3407 int deletable_p = 0;
3410 for (o = v->opt; o; o = o->next)
3411 if (strcmp (o->name, "length") == 0)
3413 else if (strcmp (o->name, "deletable") == 0)
3415 else if (strcmp (o->name, "param_is") == 0)
3417 else if (strncmp (o->name, "param", 5) == 0
3418 && ISDIGIT (o->name[5])
3419 && strcmp (o->name + 6, "_is") == 0)
3421 else if (strcmp (o->name, "if_marked") == 0)
3424 error_at_line (&v->line,
3425 "global `%s' has unknown option `%s'",
3428 for (fli = flp; fli; fli = fli->next)
3429 if (fli->f == f && f)
3433 fli = XNEW (struct flist);
3437 fli->name = v->line.file;
3438 gcc_assert(fli->name);
3441 oprintf (f, "\n/* GC roots. */\n\n");
3446 && v->type->kind == TYPE_POINTER
3447 && (v->type->u.p->kind == TYPE_POINTER
3448 || v->type->u.p->kind == TYPE_STRUCT))
3450 write_array (f, v, &ggc_wtd);
3451 write_array (f, v, &pch_wtd);
3455 for (v = variables; v; v = v->next)
3457 outf_p f = get_output_file_with_visibility (v->line.file);
3463 for (o = v->opt; o; o = o->next)
3464 if (strcmp (o->name, "length") == 0)
3466 else if (strcmp (o->name, "deletable") == 0
3467 || strcmp (o->name, "if_marked") == 0)
3473 for (fli = flp; fli; fli = fli->next)
3476 if (! fli->started_p)
3480 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3481 put_mangled_filename (f, v->line.file);
3482 oprintf (f, "[] = {\n");
3485 write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
3488 finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3491 for (v = variables; v; v = v->next)
3493 outf_p f = get_output_file_with_visibility (v->line.file);
3498 for (o = v->opt; o; o = o->next)
3499 if (strcmp (o->name, "deletable") == 0)
3501 else if (strcmp (o->name, "if_marked") == 0)
3507 for (fli = flp; fli; fli = fli->next)
3510 if (! fli->started_p)
3514 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3515 put_mangled_filename (f, v->line.file);
3516 oprintf (f, "[] = {\n");
3519 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3523 finish_root_table (flp, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3524 "gt_ggc_deletable_rtab");
3526 for (v = variables; v; v = v->next)
3528 outf_p f = get_output_file_with_visibility (v->line.file);
3530 const char *if_marked = NULL;
3534 for (o = v->opt; o; o = o->next)
3535 if (strcmp (o->name, "length") == 0)
3537 else if (strcmp (o->name, "if_marked") == 0)
3538 if_marked = o->info;
3540 if (if_marked == NULL)
3543 if (v->type->kind != TYPE_POINTER
3544 || v->type->u.p->kind != TYPE_PARAM_STRUCT
3545 || v->type->u.p->u.param_struct.stru != find_structure ("htab", 0))
3547 error_at_line (&v->line, "if_marked option used but not hash table");
3551 for (fli = flp; fli; fli = fli->next)
3554 if (! fli->started_p)
3558 oprintf (f, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
3559 put_mangled_filename (f, v->line.file);
3560 oprintf (f, "[] = {\n");
3563 write_root (f, v, v->type->u.p->u.param_struct.param[0],
3564 v->name, length_p, &v->line, if_marked, emit_pch);
3567 finish_root_table (flp, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
3568 "gt_ggc_cache_rtab");
3573 for (v = variables; v; v = v->next)
3575 outf_p f = get_output_file_with_visibility (v->line.file);
3578 int if_marked_p = 0;
3581 for (o = v->opt; o; o = o->next)
3582 if (strcmp (o->name, "length") == 0)
3584 else if (strcmp (o->name, "if_marked") == 0)
3590 for (fli = flp; fli; fli = fli->next)
3593 if (! fli->started_p)
3597 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
3598 put_mangled_filename (f, v->line.file);
3599 oprintf (f, "[] = {\n");
3602 write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
3605 finish_root_table (flp, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3606 "gt_pch_cache_rtab");
3608 for (v = variables; v; v = v->next)
3610 outf_p f = get_output_file_with_visibility (v->line.file);
3615 for (o = v->opt; o; o = o->next)
3616 if (strcmp (o->name, "deletable") == 0
3617 || strcmp (o->name, "if_marked") == 0)
3623 if (! contains_scalar_p (v->type))
3626 for (fli = flp; fli; fli = fli->next)
3629 if (! fli->started_p)
3633 oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
3634 put_mangled_filename (f, v->line.file);
3635 oprintf (f, "[] = {\n");
3638 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3642 finish_root_table (flp, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3643 "gt_pch_scalar_rtab");
3646 /* Record the definition of a generic VEC structure, as if we had expanded
3647 the macros in vec.h:
3649 typedef struct VEC_<type>_base GTY(()) {
3652 <type> GTY((length ("%h.num"))) vec[1];
3655 where the GTY(()) tags are only present if is_scalar is _false_. */
3658 note_def_vec (const char *type_name, bool is_scalar, struct fileloc *pos)
3663 type_p len_ty = create_scalar_type ("unsigned");
3664 const char *name = concat ("VEC_", type_name, "_base", (char *)0);
3668 t = create_scalar_type (type_name);
3673 t = resolve_typedef (type_name, pos);
3674 o = create_option (0, "length", "%h.num");
3677 /* We assemble the field list in reverse order. */
3678 fields = create_field_at (0, create_array (t, "1"), "vec", o, pos);
3679 fields = create_field_at (fields, len_ty, "alloc", 0, pos);
3680 fields = create_field_at (fields, len_ty, "num", 0, pos);
3682 do_typedef (name, new_structure (name, 0, pos, fields, 0), pos);
3685 /* Record the definition of an allocation-specific VEC structure, as if
3686 we had expanded the macros in vec.h:
3688 typedef struct VEC_<type>_<astrat> {
3689 VEC_<type>_base base;
3690 } VEC_<type>_<astrat>;
3693 note_def_vec_alloc (const char *type, const char *astrat, struct fileloc *pos)
3695 const char *astratname = concat ("VEC_", type, "_", astrat, (char *)0);
3696 const char *basename = concat ("VEC_", type, "_base", (char *)0);
3698 pair_p field = create_field_at (0, resolve_typedef (basename, pos),
3701 do_typedef (astratname, new_structure (astratname, 0, pos, field, 0), pos);
3704 static void dump_pair (int indent, pair_p p);
3705 static void dump_type (int indent, type_p p);
3706 static void dump_type_list (int indent, type_p p);
3710 /* Dumps the value of typekind KIND. */
3713 dump_typekind (int indent, enum typekind kind)
3715 printf ("%*ckind = ", indent, ' ');
3718 case TYPE_SCALAR: printf ("TYPE_SCALAR"); break;
3719 case TYPE_STRING: printf ("TYPE_STRING"); break;
3720 case TYPE_STRUCT: printf ("TYPE_STRUCT"); break;
3721 case TYPE_UNION: printf ("TYPE_UNION"); break;
3722 case TYPE_POINTER: printf ("TYPE_POINTER"); break;
3723 case TYPE_ARRAY: printf ("TYPE_ARRAY"); break;
3724 case TYPE_LANG_STRUCT: printf ("TYPE_LANG_STRUCT"); break;
3725 case TYPE_PARAM_STRUCT: printf ("TYPE_PARAM_STRUCT"); break;
3726 default: gcc_unreachable ();
3731 /* Dumps the value of GC_USED flag. */
3734 dump_gc_used (int indent, enum gc_used_enum gc_used)
3736 printf ("%*cgc_used = ", indent, ' ');
3739 case GC_UNUSED: printf ("GC_UNUSED"); break;
3740 case GC_USED: printf ("GC_USED"); break;
3741 case GC_MAYBE_POINTED_TO: printf ("GC_MAYBE_POINTED_TO"); break;
3742 case GC_POINTED_TO: printf ("GC_POINTED_TO"); break;
3743 default: gcc_unreachable ();
3748 /* Dumps the type options OPT. */
3751 dump_options (int indent, options_p opt)
3754 printf ("%*coptions = ", indent, ' ');
3758 printf ("%s:%s ", o->name, o->info);
3764 /* Dumps the source file location in LINE. */
3767 dump_fileloc (int indent, struct fileloc line)
3769 printf ("%*cfileloc: file = %s, line = %d\n", indent, ' ', line.file,
3773 /* Recursively dumps the struct, union, or a language-specific
3777 dump_type_u_s (int indent, type_p t)
3781 gcc_assert (t->kind == TYPE_STRUCT || t->kind == TYPE_UNION
3782 || t->kind == TYPE_LANG_STRUCT);
3783 printf ("%*cu.s.tag = %s\n", indent, ' ', t->u.s.tag);
3784 dump_fileloc (indent, t->u.s.line);
3785 printf ("%*cu.s.fields =\n", indent, ' ');
3786 fields = t->u.s.fields;
3789 dump_pair (indent + INDENT, fields);
3790 fields = fields->next;
3792 printf ("%*cend of fields of type %p\n", indent, ' ', (void *) t);
3793 dump_options (indent, t->u.s.opt);
3794 printf ("%*cu.s.bitmap = %X\n", indent, ' ', t->u.s.bitmap);
3795 if (t->kind == TYPE_LANG_STRUCT)
3797 printf ("%*cu.s.lang_struct:\n", indent, ' ');
3798 dump_type_list (indent + INDENT, t->u.s.lang_struct);
3802 /* Recursively dumps the array T. */
3805 dump_type_u_a (int indent, type_p t)
3807 gcc_assert (t->kind == TYPE_ARRAY);
3808 printf ("%*clen = %s, u.a.p:\n", indent, ' ', t->u.a.len);
3809 dump_type_list (indent + INDENT, t->u.a.p);
3812 /* Recursively dumps the parameterized struct T. */
3815 dump_type_u_param_struct (int indent, type_p t)
3818 gcc_assert (t->kind == TYPE_PARAM_STRUCT);
3819 printf ("%*cu.param_struct.stru:\n", indent, ' ');
3820 dump_type_list (indent, t->u.param_struct.stru);
3821 dump_fileloc (indent, t->u.param_struct.line);
3822 for (i = 0; i < NUM_PARAM; i++)
3824 if (t->u.param_struct.param[i] == NULL)
3826 printf ("%*cu.param_struct.param[%d]:\n", indent, ' ', i);
3827 dump_type (indent + INDENT, t->u.param_struct.param[i]);
3831 /* Recursively dumps the type list T. */
3834 dump_type_list (int indent, type_p t)
3839 dump_type (indent, p);
3844 static htab_t seen_types;
3846 /* Recursively dumps the type T if it was not dumped previously. */
3849 dump_type (int indent, type_p t)
3853 printf ("%*cType at %p: ", indent, ' ', (void *)t);
3854 slot = htab_find_slot (seen_types, t, INSERT);
3857 printf ("already seen.\n");
3863 dump_typekind (indent, t->kind);
3864 printf ("%*cpointer_to = %p\n", indent + INDENT, ' ',
3865 (void *)t->pointer_to);
3866 dump_gc_used (indent + INDENT, t->gc_used);
3870 printf ("%*cscalar_is_char = %s\n", indent + INDENT, ' ',
3871 t->u.scalar_is_char ? "true" : "false");
3877 case TYPE_LANG_STRUCT:
3878 dump_type_u_s (indent + INDENT, t);
3881 printf ("%*cp:\n", indent + INDENT, ' ');
3882 dump_type (indent + INDENT, t->u.p);
3885 dump_type_u_a (indent + INDENT, t);
3887 case TYPE_PARAM_STRUCT:
3888 dump_type_u_param_struct (indent + INDENT, t);
3893 printf ("%*cEnd of type at %p\n", indent, ' ', (void *)t);
3896 /* Dumps the pair P. */
3899 dump_pair (int indent, pair_p p)
3901 printf ("%*cpair: name = %s\n", indent, ' ', p->name);
3902 dump_type (indent, p->type);
3903 dump_fileloc (indent, p->line);
3904 dump_options (indent, p->opt);
3905 printf ("%*cEnd of pair %s\n", indent, ' ', p->name);
3908 /* Dumps the list of pairs PP. */
3911 dump_pair_list (const char * name, pair_p pp)
3914 printf ("%s:\n", name);
3915 for (p = pp; p != NULL; p = p->next)
3917 printf ("End of %s\n\n", name);
3920 /* Dumps the STRUCTURES. */
3923 dump_structures (const char * name, type_p structures)
3925 printf ("%s:\n", name);
3926 dump_type_list (0, structures);
3927 printf ("End of %s\n\n", name);
3930 /* Dumps the internal structures of gengtype. */
3933 dump_everything (void)
3935 seen_types = htab_create (100, htab_hash_pointer, htab_eq_pointer, NULL);
3936 dump_pair_list ("typedefs", typedefs);
3937 dump_structures ("structures", structures);
3938 dump_structures ("param_structs", param_structs);
3939 dump_pair_list ("variables", variables);
3940 htab_delete (seen_types);
3945 main (int argc, char **argv)
3948 static struct fileloc pos = { this_file, 0 };
3949 char* inputlist = 0;
3951 outf_p output_header;
3952 char* plugin_output_filename = NULL;
3953 /* fatal uses this */
3954 progname = "gengtype";
3956 if (argc >= 2 && !strcmp (argv[1], "-d"))
3963 if (argc >= 6 && !strcmp (argv[1], "-P"))
3965 plugin_output_filename = argv[2];
3966 plugin_output = create_file ("GCC", plugin_output_filename);
3968 inputlist = argv[4];
3969 nb_plugin_files = argc - 5;
3970 plugin_files = XCNEWVEC (char *, nb_plugin_files);
3971 for (i = 0; i < nb_plugin_files; i++)
3973 /* Place an all zero lang_bitmap before the plugin file
3975 char *name = argv[i + 5];
3976 int len = strlen(name) + 1 + sizeof (lang_bitmap);
3977 plugin_files[i] = XCNEWVEC (char, len) + sizeof (lang_bitmap);
3978 strcpy (plugin_files[i], name);
3984 inputlist = argv[2];
3987 fatal ("usage: gengtype [-d] [-P pluginout.h] srcdir input-list "
3988 "[file1 file2 ... fileN]");
3990 srcdir_len = strlen (srcdir);
3992 read_input_list (inputlist);
3996 scalar_char.u.scalar_is_char = true;
3997 scalar_nonchar.u.scalar_is_char = false;
4000 /* These types are set up with #define or else outside of where
4002 pos.line = __LINE__ + 1;
4003 do_scalar_typedef ("CUMULATIVE_ARGS", &pos); pos.line++;
4004 do_scalar_typedef ("REAL_VALUE_TYPE", &pos); pos.line++;
4005 do_scalar_typedef ("FIXED_VALUE_TYPE", &pos); pos.line++;
4006 do_scalar_typedef ("double_int", &pos); pos.line++;
4007 do_scalar_typedef ("uint64_t", &pos); pos.line++;
4008 do_scalar_typedef ("uint8", &pos); pos.line++;
4009 do_scalar_typedef ("jword", &pos); pos.line++;
4010 do_scalar_typedef ("JCF_u2", &pos); pos.line++;
4011 do_scalar_typedef ("void", &pos); pos.line++;
4012 do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos)), &pos);
4014 for (i = 0; i < num_gt_files; i++)
4015 parse_file (gt_files[i]);
4020 set_gc_used (variables);
4023 write_enum_defn (structures, param_structs);
4024 output_header = plugin_output ? plugin_output : header_file;
4025 write_types (output_header, structures, param_structs, &ggc_wtd);
4026 if (plugin_files == NULL)
4028 write_types (header_file, structures, param_structs, &pch_wtd);
4029 write_local (header_file, structures, param_structs);
4031 write_roots (variables, plugin_files == NULL);
4033 close_output_files ();
4040 for (i = 0; i < nb_plugin_files; i++)
4041 free (plugin_files[i] - sizeof (lang_bitmap));
4042 free (plugin_files);