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 int nb_plugin_files
;
149 /* The output header file that is included into pretty much every
151 static outf_p header_file
;
153 /* Source directory. */
154 static const char *srcdir
;
156 /* Length of srcdir name. */
157 static size_t srcdir_len
= 0;
159 static outf_p
create_file (const char *, const char *);
161 static const char * get_file_basename (const char *);
162 static const char * get_file_realbasename (const char *);
163 static const char * get_file_srcdir_relative_path (const char *);
165 static int get_prefix_langdir_index (const char *);
166 static const char * get_file_langdir (const char *);
169 /* Nonzero iff an error has occurred. */
170 bool hit_error
= false;
172 static void gen_rtx_next (void);
173 static void write_rtx_next (void);
174 static void open_base_files (void);
175 static void close_output_files (void);
177 /* Report an error at POS, printing MSG. */
180 error_at_line (struct fileloc
*pos
, const char *msg
, ...)
186 fprintf (stderr
, "%s:%d: ", pos
->file
, pos
->line
);
187 vfprintf (stderr
, msg
, ap
);
188 fputc ('\n', stderr
);
194 /* asprintf, but produces fatal message on out-of-memory. */
196 xasprintf (const char *format
, ...)
202 va_start (ap
, format
);
203 n
= vasprintf (&result
, format
, ap
);
204 if (result
== NULL
|| n
< 0)
205 fatal ("out of memory");
211 /* Input file handling. */
213 /* Table of all input files. */
214 static const char **gt_files
;
215 static size_t num_gt_files
;
217 /* A number of places use the name of this file for a location for
218 things that we can't rely on the source to define. Make sure we
219 can still use pointer comparison on filenames. */
220 static const char this_file
[] = __FILE__
;
222 /* Vector of per-language directories. */
223 static const char **lang_dir_names
;
224 static size_t num_lang_dirs
;
226 /* An array of output files suitable for definitions. There is one
227 BASE_FILES entry for each language. */
228 static outf_p
*base_files
;
230 /* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
231 INPUT_FILE is used by <lang>.
233 This function should be written to assume that a file _is_ used
234 if the situation is unclear. If it wrongly assumes a file _is_ used,
235 a linker error will result. If it wrongly assumes a file _is not_ used,
236 some GC roots may be missed, which is a much harder-to-debug problem.
238 The relevant bitmap is stored immediately before the file's name in the
239 buffer set up by read_input_list. It may be unaligned, so we have to
240 read it byte-by-byte. */
243 get_lang_bitmap (const char *gtfile
)
246 if (gtfile
== this_file
)
247 /* Things defined in this file are universal. */
248 return (((lang_bitmap
)1) << num_lang_dirs
) - 1;
253 for (i
= -(int) sizeof (lang_bitmap
); i
< 0; i
++)
254 n
= (n
<< CHAR_BIT
) + (unsigned char)gtfile
[i
];
259 /* Set the bitmap returned by get_lang_bitmap. The only legitimate
260 caller of this function is read_input_list. */
262 set_lang_bitmap (char *gtfile
, lang_bitmap n
)
265 for (i
= -1; i
>= -(int) sizeof (lang_bitmap
); i
--)
267 gtfile
[i
] = n
& ((1U << CHAR_BIT
)-1);
272 /* Scan the input file, LIST, and determine how much space we need to
273 store strings in. Also, count the number of language directories
274 and files. The numbers returned are overestimates as they does not
275 consider repeated files. */
277 measure_input_list (FILE *list
)
283 num_gt_files
= plugin_files
? nb_plugin_files
: 0;
284 while ((c
= getc (list
)) != EOF
)
293 /* Add space for a lang_bitmap before the input file name. */
294 n
+= sizeof (lang_bitmap
);
308 /* Read one input line from LIST to HEREP (which is updated). A
309 pointer to the string is returned via LINEP. If it was a language
310 subdirectory in square brackets, strip off the square brackets and
311 return true. Otherwise, leave space before the string for a
312 lang_bitmap, and return false. At EOF, returns false, does not
313 touch *HEREP, and sets *LINEP to NULL. POS is used for
316 read_input_line (FILE *list
, char **herep
, char **linep
,
323 /* Read over whitespace. */
324 while (c
== '\n' || c
== ' ')
334 /* No space for a lang_bitmap is necessary. Discard the '['. */
337 while (c
!= ']' && c
!= '\n' && c
!= EOF
)
346 c
= getc (list
); /* eat what should be a newline */
347 if (c
!= '\n' && c
!= EOF
)
348 error_at_line (pos
, "junk on line after language tag [%s]", line
);
351 error_at_line (pos
, "missing close bracket for language tag [%s", line
);
359 /* Leave space for a lang_bitmap. */
360 memset (here
, 0, sizeof (lang_bitmap
));
361 here
+= sizeof (lang_bitmap
);
368 while (c
!= EOF
&& c
!= '\n');
376 /* Read the list of input files from LIST and compute all of the
377 relevant tables. There is one file per line of the list. At
378 first, all the files on the list are language-generic, but
379 eventually a line will appear which is the name of a language
380 subdirectory in square brackets, like this: [cp]. All subsequent
381 files are specific to that language, until another language
382 subdirectory tag appears. Files can appear more than once, if
383 they apply to more than one language. */
385 read_input_list (const char *listname
)
387 FILE *list
= fopen (listname
, "r");
389 fatal ("cannot open %s: %s", listname
, strerror (errno
));
393 size_t bufsz
= measure_input_list (list
);
394 char *buf
= XNEWVEC (char, bufsz
);
396 char *committed
= buf
;
397 char *limit
= buf
+ bufsz
;
402 lang_bitmap curlangs
= (1 << num_lang_dirs
) - 1;
404 epos
.file
= listname
;
407 lang_dir_names
= XNEWVEC (const char *, num_lang_dirs
);
408 gt_files
= XNEWVEC (const char *, num_gt_files
);
415 is_language
= read_input_line (list
, &here
, &line
, &epos
);
416 gcc_assert (here
<= limit
);
419 else if (is_language
)
422 gcc_assert (langno
<= num_lang_dirs
);
423 for (i
= 0; i
< langno
; i
++)
424 if (strcmp (lang_dir_names
[i
], line
) == 0)
426 error_at_line (&epos
, "duplicate language tag [%s]", line
);
432 curlangs
= 1 << langno
;
433 lang_dir_names
[langno
++] = line
;
438 gcc_assert (nfiles
<= num_gt_files
);
439 for (i
= 0; i
< nfiles
; i
++)
440 if (strcmp (gt_files
[i
], line
) == 0)
442 /* Throw away the string we just read, and add the
443 current language to the existing string's bitmap. */
444 lang_bitmap bmap
= get_lang_bitmap (gt_files
[i
]);
446 error_at_line (&epos
, "file %s specified more than once "
447 "for language %s", line
, langno
== 0
449 : lang_dir_names
[langno
- 1]);
452 set_lang_bitmap (CONST_CAST(char *, gt_files
[i
]), bmap
);
457 set_lang_bitmap (line
, curlangs
);
458 gt_files
[nfiles
++] = line
;
461 /* Update the global counts now that we know accurately how many
462 things there are. (We do not bother resizing the arrays down.) */
463 num_lang_dirs
= langno
;
464 /* Add the plugin files if provided. */
468 for (i
= 0; i
< nb_plugin_files
; i
++)
469 gt_files
[nfiles
++] = plugin_files
[i
];
471 num_gt_files
= nfiles
;
474 /* Sanity check: any file that resides in a language subdirectory
475 (e.g. 'cp') ought to belong to the corresponding language.
476 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
477 (Can you even do that? Should you be allowed to?) */
480 for (f
= 0; f
< num_gt_files
; f
++)
482 lang_bitmap bitmap
= get_lang_bitmap (gt_files
[f
]);
483 const char *basename
= get_file_basename (gt_files
[f
]);
484 const char *slashpos
= strchr (basename
, '/');
489 for (l
= 0; l
< num_lang_dirs
; l
++)
490 if ((size_t)(slashpos
- basename
) == strlen (lang_dir_names
[l
])
491 && memcmp (basename
, lang_dir_names
[l
],
492 strlen (lang_dir_names
[l
])) == 0)
494 if (!(bitmap
& (1 << l
)))
495 error ("%s is in language directory '%s' but is not "
496 "tagged for that language",
497 basename
, lang_dir_names
[l
]);
505 fatal ("error reading %s: %s", listname
, strerror (errno
));
512 /* The one and only TYPE_STRING. */
514 static struct type string_type
= {
515 TYPE_STRING
, 0, 0, GC_USED
, {0}
518 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
519 set to appropriate values at the beginning of main. */
521 static struct type scalar_nonchar
= {
522 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
524 static struct type scalar_char
= {
525 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
528 /* Lists of various things. */
530 static pair_p typedefs
;
531 static type_p structures
;
532 static type_p param_structs
;
533 static pair_p variables
;
535 static type_p find_param_structure
536 (type_p t
, type_p param
[NUM_PARAM
]);
537 static type_p
adjust_field_tree_exp (type_p t
, options_p opt
);
538 static type_p
adjust_field_rtx_def (type_p t
, options_p opt
);
540 /* Define S as a typedef to T at POS. */
543 do_typedef (const char *s
, type_p t
, struct fileloc
*pos
)
547 /* temporary kludge - gengtype doesn't handle conditionals or
548 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
549 is coming from this file (main() sets them up with safe dummy
551 if (!strcmp (s
, "CUMULATIVE_ARGS") && pos
->file
!= this_file
)
554 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
555 if (strcmp (p
->name
, s
) == 0)
559 error_at_line (pos
, "type `%s' previously defined", s
);
560 error_at_line (&p
->line
, "previously defined here");
565 p
= XNEW (struct pair
);
573 /* Define S as a typename of a scalar. Cannot be used to define
574 typedefs of 'char'. Note: is also used for pointer-to-function
575 typedefs (which are therefore not treated as pointers). */
578 do_scalar_typedef (const char *s
, struct fileloc
*pos
)
580 do_typedef (s
, &scalar_nonchar
, pos
);
583 /* Return the type previously defined for S. Use POS to report errors. */
586 resolve_typedef (const char *s
, struct fileloc
*pos
)
589 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
590 if (strcmp (p
->name
, s
) == 0)
592 error_at_line (pos
, "unidentified type `%s'", s
);
593 return &scalar_nonchar
; /* treat as "int" */
596 /* Create and return a new structure with tag NAME (or a union iff
597 ISUNION is nonzero), at POS with fields FIELDS and options O. */
600 new_structure (const char *name
, int isunion
, struct fileloc
*pos
,
601 pair_p fields
, options_p o
)
605 lang_bitmap bitmap
= get_lang_bitmap (pos
->file
);
607 /* temporary kludge - gengtype doesn't handle conditionals or
608 macros. Ignore any attempt to define struct location_s, unless
609 it is coming from this file (main() sets it up safely). */
610 if (!strcmp (name
, "location_s") && !isunion
611 && pos
->file
!= this_file
)
612 return find_structure (name
, 0);
614 for (si
= structures
; si
!= NULL
; si
= si
->next
)
615 if (strcmp (name
, si
->u
.s
.tag
) == 0
616 && UNION_P (si
) == isunion
)
619 if (si
->kind
== TYPE_LANG_STRUCT
)
623 for (si
= ls
->u
.s
.lang_struct
; si
!= NULL
; si
= si
->next
)
624 if (si
->u
.s
.bitmap
== bitmap
)
627 else if (si
->u
.s
.line
.file
!= NULL
&& si
->u
.s
.bitmap
!= bitmap
)
630 si
= XCNEW (struct type
);
631 memcpy (si
, ls
, sizeof (struct type
));
632 ls
->kind
= TYPE_LANG_STRUCT
;
633 ls
->u
.s
.lang_struct
= si
;
634 ls
->u
.s
.fields
= NULL
;
636 si
->pointer_to
= NULL
;
637 si
->u
.s
.lang_struct
= ls
;
642 if (ls
!= NULL
&& s
== NULL
)
644 s
= XCNEW (struct type
);
645 s
->next
= ls
->u
.s
.lang_struct
;
646 ls
->u
.s
.lang_struct
= s
;
647 s
->u
.s
.lang_struct
= ls
;
654 s
= XCNEW (struct type
);
655 s
->next
= structures
;
659 if (s
->u
.s
.line
.file
!= NULL
660 || (s
->u
.s
.lang_struct
&& (s
->u
.s
.lang_struct
->u
.s
.bitmap
& bitmap
)))
662 error_at_line (pos
, "duplicate definition of '%s %s'",
663 isunion
? "union" : "struct", s
->u
.s
.tag
);
664 error_at_line (&s
->u
.s
.line
, "previous definition here");
667 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
670 s
->u
.s
.fields
= fields
;
672 s
->u
.s
.bitmap
= bitmap
;
673 if (s
->u
.s
.lang_struct
)
674 s
->u
.s
.lang_struct
->u
.s
.bitmap
|= bitmap
;
676 /* Reset location_s's location to input.h so that we know where to
677 write out its mark routine. */
678 if (!strcmp (name
, "location_s") && !isunion
679 && pos
->file
== this_file
)
682 for (n
= 0; n
< num_gt_files
; n
++)
683 if (!strcmp (gt_files
[n
] + strlen (gt_files
[n
]) - strlen ("input.h"),
686 s
->u
.s
.line
.file
= gt_files
[n
];
694 /* Return the previously-defined structure with tag NAME (or a union
695 iff ISUNION is nonzero), or a new empty structure or union if none
696 was defined previously. */
699 find_structure (const char *name
, int isunion
)
703 for (s
= structures
; s
!= NULL
; s
= s
->next
)
704 if (strcmp (name
, s
->u
.s
.tag
) == 0
705 && UNION_P (s
) == isunion
)
708 s
= XCNEW (struct type
);
709 s
->next
= structures
;
711 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
717 /* Return the previously-defined parameterized structure for structure
718 T and parameters PARAM, or a new parameterized empty structure or
719 union if none was defined previously. */
722 find_param_structure (type_p t
, type_p param
[NUM_PARAM
])
726 for (res
= param_structs
; res
; res
= res
->next
)
727 if (res
->u
.param_struct
.stru
== t
728 && memcmp (res
->u
.param_struct
.param
, param
,
729 sizeof (type_p
) * NUM_PARAM
) == 0)
733 res
= XCNEW (struct type
);
734 res
->kind
= TYPE_PARAM_STRUCT
;
735 res
->next
= param_structs
;
737 res
->u
.param_struct
.stru
= t
;
738 memcpy (res
->u
.param_struct
.param
, param
, sizeof (type_p
) * NUM_PARAM
);
743 /* Return a scalar type with name NAME. */
746 create_scalar_type (const char *name
)
748 if (!strcmp (name
, "char") || !strcmp (name
, "unsigned char"))
751 return &scalar_nonchar
;
754 /* Return a pointer to T. */
757 create_pointer (type_p t
)
761 type_p r
= XCNEW (struct type
);
762 r
->kind
= TYPE_POINTER
;
766 return t
->pointer_to
;
769 /* Return an array of length LEN. */
772 create_array (type_p t
, const char *len
)
776 v
= XCNEW (struct type
);
777 v
->kind
= TYPE_ARRAY
;
783 /* Return an options structure with name NAME and info INFO. NEXT is the
784 next option in the chain. */
787 create_option (options_p next
, const char *name
, const void *info
)
789 options_p o
= XNEW (struct options
);
792 o
->info
= (const char*) info
;
796 /* Return an options structure for a "nested_ptr" option. */
798 create_nested_ptr_option (options_p next
, type_p t
,
799 const char *to
, const char *from
)
801 struct nested_ptr_data
*d
= XNEW (struct nested_ptr_data
);
803 d
->type
= adjust_field_type (t
, 0);
805 d
->convert_from
= from
;
806 return create_option (next
, "nested_ptr", d
);
809 /* Add a variable named S of type T with options O defined at POS,
813 note_variable (const char *s
, type_p t
, options_p o
, struct fileloc
*pos
)
816 n
= XNEW (struct pair
);
825 /* Most-general structure field creator. */
827 create_field_all (pair_p next
, type_p type
, const char *name
, options_p opt
,
828 const char *file
, int line
)
832 field
= XNEW (struct pair
);
837 field
->line
.file
= file
;
838 field
->line
.line
= line
;
842 /* Create a field that came from the source code we are scanning,
843 i.e. we have a 'struct fileloc', and possibly options; also,
844 adjust_field_type should be called. */
846 create_field_at (pair_p next
, type_p type
, const char *name
, options_p opt
,
849 return create_field_all (next
, adjust_field_type (type
, opt
),
850 name
, opt
, pos
->file
, pos
->line
);
853 /* Create a fake field with the given type and name. NEXT is the next
854 field in the chain. */
855 #define create_field(next,type,name) \
856 create_field_all(next,type,name, 0, this_file, __LINE__)
858 /* Like create_field, but the field is only valid when condition COND
862 create_optional_field_ (pair_p next
, type_p type
, const char *name
,
863 const char *cond
, int line
)
869 /* Create a fake union type with a single nameless field of type TYPE.
870 The field has a tag of "1". This allows us to make the presence
871 of a field of type TYPE depend on some boolean "desc" being true. */
872 union_fields
= create_field (NULL
, type
, "");
873 union_fields
->opt
= create_option (union_fields
->opt
, "dot", "");
874 union_fields
->opt
= create_option (union_fields
->opt
, "tag", "1");
875 union_type
= new_structure (xasprintf ("%s_%d", "fake_union", id
++), 1,
876 &lexer_line
, union_fields
, NULL
);
878 /* Create the field and give it the new fake union type. Add a "desc"
879 tag that specifies the condition under which the field is valid. */
880 return create_field_all (next
, union_type
, name
,
881 create_option (0, "desc", cond
),
884 #define create_optional_field(next,type,name,cond) \
885 create_optional_field_(next,type,name,cond,__LINE__)
887 /* Reverse a linked list of 'struct pair's in place. */
889 nreverse_pairs (pair_p list
)
891 pair_p prev
= 0, p
, next
;
892 for (p
= list
; p
; p
= next
)
902 /* We don't care how long a CONST_DOUBLE is. */
903 #define CONST_DOUBLE_FORMAT "ww"
904 /* We don't want to see codes that are only for generator files. */
905 #undef GENERATOR_FILE
908 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
914 static const char * const rtx_name
[NUM_RTX_CODE
] = {
915 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
920 static const char * const rtx_format
[NUM_RTX_CODE
] = {
921 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
926 static int rtx_next_new
[NUM_RTX_CODE
];
928 /* We also need codes and names for insn notes (not register notes).
929 Note that we do *not* bias the note values here. */
931 #define DEF_INSN_NOTE(NAME) NAME,
932 #include "insn-notes.def"
938 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
939 default field for line number notes. */
940 static const char *const note_insn_name
[NOTE_INSN_MAX
+1] = {
941 #define DEF_INSN_NOTE(NAME) #NAME,
942 #include "insn-notes.def"
946 #undef CONST_DOUBLE_FORMAT
947 #define GENERATOR_FILE
949 /* Generate the contents of the rtx_next array. This really doesn't belong
950 in gengtype at all, but it's needed for adjust_field_rtx_def. */
956 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
960 rtx_next_new
[i
] = -1;
961 if (strncmp (rtx_format
[i
], "iuu", 3) == 0)
963 else if (i
== COND_EXEC
|| i
== SET
|| i
== EXPR_LIST
|| i
== INSN_LIST
)
966 for (k
= strlen (rtx_format
[i
]) - 1; k
>= 0; k
--)
967 if (rtx_format
[i
][k
] == 'e' || rtx_format
[i
][k
] == 'u')
972 /* Write out the contents of the rtx_next array. */
974 write_rtx_next (void)
976 outf_p f
= get_output_file_with_visibility (NULL
);
981 oprintf (f
, "\n/* Used to implement the RTX_NEXT macro. */\n");
982 oprintf (f
, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
983 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
984 if (rtx_next_new
[i
] == -1)
985 oprintf (f
, " 0,\n");
988 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n",
993 /* Handle `special("rtx_def")'. This is a special case for field
994 `fld' of struct rtx_def, which is an array of unions whose values
995 are based in a complex way on the type of RTL. */
998 adjust_field_rtx_def (type_p t
, options_p
ARG_UNUSED (opt
))
1003 type_p rtx_tp
, rtvec_tp
, tree_tp
, mem_attrs_tp
, note_union_tp
, scalar_tp
;
1004 type_p bitmap_tp
, basic_block_tp
, reg_attrs_tp
, constant_tp
, symbol_union_tp
;
1006 if (t
->kind
!= TYPE_UNION
)
1008 error_at_line (&lexer_line
,
1009 "special `rtx_def' must be applied to a union");
1010 return &string_type
;
1013 nodot
= create_option (NULL
, "dot", "");
1015 rtx_tp
= create_pointer (find_structure ("rtx_def", 0));
1016 rtvec_tp
= create_pointer (find_structure ("rtvec_def", 0));
1017 tree_tp
= create_pointer (find_structure ("tree_node", 1));
1018 mem_attrs_tp
= create_pointer (find_structure ("mem_attrs", 0));
1019 reg_attrs_tp
= create_pointer (find_structure ("reg_attrs", 0));
1020 bitmap_tp
= create_pointer (find_structure ("bitmap_element_def", 0));
1021 basic_block_tp
= create_pointer (find_structure ("basic_block_def", 0));
1022 constant_tp
= create_pointer (find_structure ("constant_descriptor_rtx", 0));
1023 scalar_tp
= &scalar_nonchar
; /* rtunion int */
1026 pair_p note_flds
= NULL
;
1029 for (c
= 0; c
<= NOTE_INSN_MAX
; c
++)
1034 case NOTE_INSN_DELETED_LABEL
:
1035 note_flds
= create_field (note_flds
, &string_type
, "rt_str");
1038 case NOTE_INSN_BLOCK_BEG
:
1039 case NOTE_INSN_BLOCK_END
:
1040 note_flds
= create_field (note_flds
, tree_tp
, "rt_tree");
1043 case NOTE_INSN_VAR_LOCATION
:
1044 note_flds
= create_field (note_flds
, rtx_tp
, "rt_rtx");
1048 note_flds
= create_field (note_flds
, scalar_tp
, "rt_int");
1051 /* NOTE_INSN_MAX is used as the default field for line
1053 if (c
== NOTE_INSN_MAX
)
1054 note_flds
->opt
= create_option (nodot
, "default", "");
1056 note_flds
->opt
= create_option (nodot
, "tag", note_insn_name
[c
]);
1058 note_union_tp
= new_structure ("rtx_def_note_subunion", 1,
1059 &lexer_line
, note_flds
, NULL
);
1061 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1065 sym_flds
= create_field (NULL
, tree_tp
, "rt_tree");
1066 sym_flds
->opt
= create_option (nodot
, "default", "");
1068 sym_flds
= create_field (sym_flds
, constant_tp
, "rt_constant");
1069 sym_flds
->opt
= create_option (nodot
, "tag", "1");
1071 symbol_union_tp
= new_structure ("rtx_def_symbol_subunion", 1,
1072 &lexer_line
, sym_flds
, NULL
);
1074 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1076 pair_p subfields
= NULL
;
1077 size_t aindex
, nmindex
;
1082 for (aindex
= 0; aindex
< strlen (rtx_format
[i
]); aindex
++)
1085 const char *subname
;
1087 switch (rtx_format
[i
][aindex
])
1098 if (i
== MEM
&& aindex
== 1)
1099 t
= mem_attrs_tp
, subname
= "rt_mem";
1100 else if (i
== JUMP_INSN
&& aindex
== 8)
1101 t
= rtx_tp
, subname
= "rt_rtx";
1102 else if (i
== CODE_LABEL
&& aindex
== 4)
1103 t
= scalar_tp
, subname
= "rt_int";
1104 else if (i
== CODE_LABEL
&& aindex
== 5)
1105 t
= rtx_tp
, subname
= "rt_rtx";
1106 else if (i
== LABEL_REF
1107 && (aindex
== 1 || aindex
== 2))
1108 t
= rtx_tp
, subname
= "rt_rtx";
1109 else if (i
== NOTE
&& aindex
== 4)
1110 t
= note_union_tp
, subname
= "";
1111 else if (i
== NOTE
&& aindex
== 5)
1112 t
= scalar_tp
, subname
= "rt_int";
1113 else if (i
== NOTE
&& aindex
>= 7)
1114 t
= scalar_tp
, subname
= "rt_int";
1115 else if (i
== ADDR_DIFF_VEC
&& aindex
== 4)
1116 t
= scalar_tp
, subname
= "rt_int";
1117 else if (i
== VALUE
&& aindex
== 0)
1118 t
= scalar_tp
, subname
= "rt_int";
1119 else if (i
== REG
&& aindex
== 1)
1120 t
= scalar_tp
, subname
= "rt_int";
1121 else if (i
== REG
&& aindex
== 2)
1122 t
= reg_attrs_tp
, subname
= "rt_reg";
1123 else if (i
== SCRATCH
&& aindex
== 0)
1124 t
= scalar_tp
, subname
= "rt_int";
1125 else if (i
== SYMBOL_REF
&& aindex
== 1)
1126 t
= scalar_tp
, subname
= "rt_int";
1127 else if (i
== SYMBOL_REF
&& aindex
== 2)
1128 t
= symbol_union_tp
, subname
= "";
1129 else if (i
== BARRIER
&& aindex
>= 3)
1130 t
= scalar_tp
, subname
= "rt_int";
1133 error_at_line (&lexer_line
,
1134 "rtx type `%s' has `0' in position %lu, can't handle",
1135 rtx_name
[i
], (unsigned long) aindex
);
1157 subname
= "rt_rtvec";
1162 subname
= "rt_tree";
1176 error_at_line (&lexer_line
,
1177 "rtx type `%s' has `%c' in position %lu, can't handle",
1178 rtx_name
[i
], rtx_format
[i
][aindex
],
1179 (unsigned long)aindex
);
1185 subfields
= create_field (subfields
, t
,
1186 xasprintf (".fld[%lu].%s",
1187 (unsigned long) aindex
,
1189 subfields
->opt
= nodot
;
1190 if (t
== note_union_tp
)
1191 subfields
->opt
= create_option (subfields
->opt
, "desc",
1193 if (t
== symbol_union_tp
)
1194 subfields
->opt
= create_option (subfields
->opt
, "desc",
1195 "CONSTANT_POOL_ADDRESS_P (&%0)");
1198 if (i
== SYMBOL_REF
)
1200 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds. */
1201 type_p field_tp
= find_structure ("block_symbol", 0);
1203 = create_optional_field (subfields
, field_tp
, "block_sym",
1204 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1207 sname
= xasprintf ("rtx_def_%s", rtx_name
[i
]);
1208 substruct
= new_structure (sname
, 0, &lexer_line
, subfields
, NULL
);
1210 ftag
= xstrdup (rtx_name
[i
]);
1211 for (nmindex
= 0; nmindex
< strlen (ftag
); nmindex
++)
1212 ftag
[nmindex
] = TOUPPER (ftag
[nmindex
]);
1214 flds
= create_field (flds
, substruct
, "");
1215 flds
->opt
= create_option (nodot
, "tag", ftag
);
1218 return new_structure ("rtx_def_subunion", 1, &lexer_line
, flds
, nodot
);
1221 /* Handle `special("tree_exp")'. This is a special case for
1222 field `operands' of struct tree_exp, which although it claims to contain
1223 pointers to trees, actually sometimes contains pointers to RTL too.
1224 Passed T, the old type of the field, and OPT its options. Returns
1225 a new type for the field. */
1228 adjust_field_tree_exp (type_p t
, options_p opt ATTRIBUTE_UNUSED
)
1233 if (t
->kind
!= TYPE_ARRAY
)
1235 error_at_line (&lexer_line
,
1236 "special `tree_exp' must be applied to an array");
1237 return &string_type
;
1240 nodot
= create_option (NULL
, "dot", "");
1242 flds
= create_field (NULL
, t
, "");
1243 flds
->opt
= create_option (nodot
, "length",
1244 "TREE_OPERAND_LENGTH ((tree) &%0)");
1245 flds
->opt
= create_option (flds
->opt
, "default", "");
1247 return new_structure ("tree_exp_subunion", 1, &lexer_line
, flds
, nodot
);
1250 /* Perform any special processing on a type T, about to become the type
1251 of a field. Return the appropriate type for the field.
1253 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1254 - Similarly for arrays of pointer-to-char;
1255 - Converts structures for which a parameter is provided to
1257 - Handles "special" options.
1261 adjust_field_type (type_p t
, options_p opt
)
1264 const int pointer_p
= t
->kind
== TYPE_POINTER
;
1265 type_p params
[NUM_PARAM
];
1269 for (i
= 0; i
< NUM_PARAM
; i
++)
1272 for (; opt
; opt
= opt
->next
)
1273 if (strcmp (opt
->name
, "length") == 0)
1275 else if (strcmp (opt
->name
, "param_is") == 0
1276 || (strncmp (opt
->name
, "param", 5) == 0
1277 && ISDIGIT (opt
->name
[5])
1278 && strcmp (opt
->name
+ 6, "_is") == 0))
1280 int num
= ISDIGIT (opt
->name
[5]) ? opt
->name
[5] - '0' : 0;
1282 if (! UNION_OR_STRUCT_P (t
)
1283 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
1285 error_at_line (&lexer_line
,
1286 "option `%s' may only be applied to structures or structure pointers",
1292 if (params
[num
] != NULL
)
1293 error_at_line (&lexer_line
, "duplicate `%s' option", opt
->name
);
1294 if (! ISDIGIT (opt
->name
[5]))
1295 params
[num
] = create_pointer (CONST_CAST2(type_p
, const char *, opt
->info
));
1297 params
[num
] = CONST_CAST2 (type_p
, const char *, opt
->info
);
1299 else if (strcmp (opt
->name
, "special") == 0)
1301 const char *special_name
= opt
->info
;
1302 if (strcmp (special_name
, "tree_exp") == 0)
1303 t
= adjust_field_tree_exp (t
, opt
);
1304 else if (strcmp (special_name
, "rtx_def") == 0)
1305 t
= adjust_field_rtx_def (t
, opt
);
1307 error_at_line (&lexer_line
, "unknown special `%s'", special_name
);
1316 realt
= find_param_structure (t
, params
);
1317 t
= pointer_p
? create_pointer (realt
) : realt
;
1322 && t
->u
.p
->kind
== TYPE_SCALAR
1323 && t
->u
.p
->u
.scalar_is_char
)
1324 return &string_type
;
1325 if (t
->kind
== TYPE_ARRAY
&& t
->u
.a
.p
->kind
== TYPE_POINTER
1326 && t
->u
.a
.p
->u
.p
->kind
== TYPE_SCALAR
1327 && t
->u
.a
.p
->u
.p
->u
.scalar_is_char
)
1328 return create_array (&string_type
, t
->u
.a
.len
);
1334 static void set_gc_used_type (type_p
, enum gc_used_enum
, type_p
*);
1335 static void set_gc_used (pair_p
);
1337 /* Handle OPT for set_gc_used_type. */
1340 process_gc_options (options_p opt
, enum gc_used_enum level
, int *maybe_undef
,
1341 int *pass_param
, int *length
, int *skip
, type_p
*nested_ptr
)
1344 for (o
= opt
; o
; o
= o
->next
)
1345 if (strcmp (o
->name
, "ptr_alias") == 0 && level
== GC_POINTED_TO
)
1346 set_gc_used_type (CONST_CAST2 (type_p
, const char *, o
->info
),
1347 GC_POINTED_TO
, NULL
);
1348 else if (strcmp (o
->name
, "maybe_undef") == 0)
1350 else if (strcmp (o
->name
, "use_params") == 0)
1352 else if (strcmp (o
->name
, "length") == 0)
1354 else if (strcmp (o
->name
, "skip") == 0)
1356 else if (strcmp (o
->name
, "nested_ptr") == 0)
1357 *nested_ptr
= ((const struct nested_ptr_data
*) o
->info
)->type
;
1360 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1363 set_gc_used_type (type_p t
, enum gc_used_enum level
, type_p param
[NUM_PARAM
])
1365 if (t
->gc_used
>= level
)
1379 process_gc_options (t
->u
.s
.opt
, level
, &dummy
, &dummy
, &dummy
, &dummy
,
1382 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
1384 int maybe_undef
= 0;
1388 type_p nested_ptr
= NULL
;
1389 process_gc_options (f
->opt
, level
, &maybe_undef
, &pass_param
,
1390 &length
, &skip
, &nested_ptr
);
1392 if (nested_ptr
&& f
->type
->kind
== TYPE_POINTER
)
1393 set_gc_used_type (nested_ptr
, GC_POINTED_TO
,
1394 pass_param
? param
: NULL
);
1395 else if (length
&& f
->type
->kind
== TYPE_POINTER
)
1396 set_gc_used_type (f
->type
->u
.p
, GC_USED
, NULL
);
1397 else if (maybe_undef
&& f
->type
->kind
== TYPE_POINTER
)
1398 set_gc_used_type (f
->type
->u
.p
, GC_MAYBE_POINTED_TO
, NULL
);
1399 else if (pass_param
&& f
->type
->kind
== TYPE_POINTER
&& param
)
1400 set_gc_used_type (find_param_structure (f
->type
->u
.p
, param
),
1401 GC_POINTED_TO
, NULL
);
1403 ; /* target type is not used through this field */
1405 set_gc_used_type (f
->type
, GC_USED
, pass_param
? param
: NULL
);
1411 set_gc_used_type (t
->u
.p
, GC_POINTED_TO
, NULL
);
1415 set_gc_used_type (t
->u
.a
.p
, GC_USED
, param
);
1418 case TYPE_LANG_STRUCT
:
1419 for (t
= t
->u
.s
.lang_struct
; t
; t
= t
->next
)
1420 set_gc_used_type (t
, level
, param
);
1423 case TYPE_PARAM_STRUCT
:
1426 for (i
= 0; i
< NUM_PARAM
; i
++)
1427 if (t
->u
.param_struct
.param
[i
] != 0)
1428 set_gc_used_type (t
->u
.param_struct
.param
[i
], GC_USED
, NULL
);
1430 if (t
->u
.param_struct
.stru
->gc_used
== GC_POINTED_TO
)
1431 level
= GC_POINTED_TO
;
1434 t
->u
.param_struct
.stru
->gc_used
= GC_UNUSED
;
1435 set_gc_used_type (t
->u
.param_struct
.stru
, level
,
1436 t
->u
.param_struct
.param
);
1444 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1447 set_gc_used (pair_p variables
)
1450 for (p
= variables
; p
; p
= p
->next
)
1451 set_gc_used_type (p
->type
, GC_USED
, NULL
);
1454 /* File mapping routines. For each input file, there is one output .c file
1455 (but some output files have many input files), and there is one .h file
1456 for the whole build. */
1458 /* Output file handling. */
1460 /* Create and return an outf_p for a new file for NAME, to be called
1464 create_file (const char *name
, const char *oname
)
1466 static const char *const hdr
[] = {
1467 " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n",
1469 "This file is part of GCC.\n",
1471 "GCC is free software; you can redistribute it and/or modify it under\n",
1472 "the terms of the GNU General Public License as published by the Free\n",
1473 "Software Foundation; either version 3, or (at your option) any later\n",
1476 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1477 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1478 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1479 "for more details.\n",
1481 "You should have received a copy of the GNU General Public License\n",
1482 "along with GCC; see the file COPYING3. If not see\n",
1483 "<http://www.gnu.org/licenses/>. */\n",
1485 "/* This file is machine generated. Do not edit. */\n"
1490 gcc_assert (name
!= NULL
);
1491 gcc_assert (oname
!= NULL
);
1492 f
= XCNEW (struct outf
);
1493 f
->next
= output_files
;
1497 oprintf (f
, "/* Type information for %s.\n", name
);
1498 for (i
= 0; i
< ARRAY_SIZE (hdr
); i
++)
1499 oprintf (f
, "%s", hdr
[i
]);
1503 /* Print, like fprintf, to O.
1504 N.B. You might think this could be implemented more efficiently
1505 with vsnprintf(). Unfortunately, there are C libraries that
1506 provide that function but without the C99 semantics for its return
1507 value, making it impossible to know how much space is required. */
1509 oprintf (outf_p o
, const char *format
, ...)
1515 /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1520 va_start (ap
, format
);
1521 slength
= vasprintf (&s
, format
, ap
);
1522 if (s
== NULL
|| (int)slength
< 0)
1523 fatal ("out of memory");
1526 if (o
->bufused
+ slength
> o
->buflength
)
1528 size_t new_len
= o
->buflength
;
1533 } while (o
->bufused
+ slength
>= new_len
);
1534 o
->buf
= XRESIZEVEC (char, o
->buf
, new_len
);
1535 o
->buflength
= new_len
;
1537 memcpy (o
->buf
+ o
->bufused
, s
, slength
);
1538 o
->bufused
+= slength
;
1542 /* Open the global header file and the language-specific header files. */
1545 open_base_files (void)
1549 if (nb_plugin_files
> 0 && plugin_files
)
1552 header_file
= create_file ("GCC", "gtype-desc.h");
1554 base_files
= XNEWVEC (outf_p
, num_lang_dirs
);
1556 for (i
= 0; i
< num_lang_dirs
; i
++)
1557 base_files
[i
] = create_file (lang_dir_names
[i
],
1558 xasprintf ("gtype-%s.h", lang_dir_names
[i
]));
1560 /* gtype-desc.c is a little special, so we create it here. */
1562 /* The order of files here matters very much. */
1563 static const char *const ifiles
[] = {
1564 "config.h", "system.h", "coretypes.h", "tm.h", "varray.h",
1565 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1566 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1567 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1568 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1569 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1570 "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h", NULL
1572 const char *const *ifp
;
1573 outf_p gtype_desc_c
;
1575 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1576 for (ifp
= ifiles
; *ifp
; ifp
++)
1577 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1579 /* Make sure we handle "cfun" specially. */
1580 oprintf (gtype_desc_c
, "\n/* See definition in function.h. */\n");
1581 oprintf (gtype_desc_c
, "#undef cfun\n");
1585 /* For F a filename, return the real basename of F, with all the directory
1586 components skipped. */
1589 get_file_realbasename (const char *f
)
1591 const char * lastslash
= strrchr (f
, '/');
1593 return (lastslash
!= NULL
) ? lastslash
+ 1 : f
;
1596 /* For F a filename, return the relative path to F from $(srcdir) if the
1597 latter is a prefix in F, NULL otherwise. */
1600 get_file_srcdir_relative_path (const char *f
)
1602 if (strlen (f
) > srcdir_len
1603 && IS_DIR_SEPARATOR (f
[srcdir_len
])
1604 && memcmp (f
, srcdir
, srcdir_len
) == 0)
1605 return f
+ srcdir_len
+ 1;
1610 /* For F a filename, return the relative path to F from $(srcdir) if the
1611 latter is a prefix in F, or the real basename of F otherwise. */
1614 get_file_basename (const char *f
)
1616 const char * srcdir_path
= get_file_srcdir_relative_path (f
);
1618 return (srcdir_path
!= NULL
) ? srcdir_path
: get_file_realbasename (f
);
1621 /* For F a filename, return the lang_dir_names relative index of the language
1622 directory that is a prefix in F, if any, -1 otherwise. */
1625 get_prefix_langdir_index (const char *f
)
1627 size_t f_len
= strlen (f
);
1630 for (lang_index
= 0; lang_index
< num_lang_dirs
; lang_index
++)
1632 const char * langdir
= lang_dir_names
[lang_index
];
1633 size_t langdir_len
= strlen (langdir
);
1635 if (f_len
> langdir_len
1636 && IS_DIR_SEPARATOR (f
[langdir_len
])
1637 && memcmp (f
, langdir
, langdir_len
) == 0)
1644 /* For F a filename, return the name of language directory where F is located,
1645 if any, NULL otherwise. */
1648 get_file_langdir (const char *f
)
1650 /* Get the relative path to F from $(srcdir) and find the language by
1651 comparing the prefix with language directory names. If F is not even
1652 srcdir relative, no point in looking further. */
1655 const char * srcdir_relative_path
= get_file_srcdir_relative_path (f
);
1657 if (!srcdir_relative_path
)
1660 lang_index
= get_prefix_langdir_index (srcdir_relative_path
);
1662 return (lang_index
>= 0) ? lang_dir_names
[lang_index
] : NULL
;
1665 /* The gt- output file name for F. */
1668 get_file_gtfilename (const char *f
)
1670 /* Cook up an initial version of the gt- file name from the file real
1671 basename and the language name, if any. */
1673 const char *basename
= get_file_realbasename (f
);
1674 const char *langdir
= get_file_langdir (f
);
1677 (langdir
? xasprintf ("gt-%s-%s", langdir
, basename
)
1678 : xasprintf ("gt-%s", basename
));
1680 /* Then replace all non alphanumerics characters by '-' and change the
1681 extenstion to ".h". We expect the input filename extension was at least
1682 one character long. */
1686 for (; *s
!= '.'; s
++)
1687 if (! ISALNUM (*s
) && *s
!= '-')
1690 memcpy (s
, ".h", sizeof (".h"));
1695 /* An output file, suitable for definitions, that can see declarations
1696 made in INPUT_FILE and is linked into every language that uses
1700 get_output_file_with_visibility (const char *input_file
)
1704 const char *basename
;
1705 const char *for_name
;
1706 const char *output_name
;
1708 /* This can happen when we need a file with visibility on a
1709 structure that we've never seen. We have to just hope that it's
1710 globally visible. */
1711 if (input_file
== NULL
)
1712 input_file
= "system.h";
1714 /* In plugin mode, return NULL unless the input_file is one of the
1716 if (plugin_files
&& nb_plugin_files
> 0)
1719 for (i
= 0; i
< nb_plugin_files
&& ix
< 0; i
++)
1720 if (strcmp (input_file
, plugin_files
[i
]) == 0)
1726 /* Determine the output file name. */
1727 basename
= get_file_basename (input_file
);
1729 len
= strlen (basename
);
1730 if ((len
> 2 && memcmp (basename
+len
-2, ".c", 2) == 0)
1731 || (len
> 2 && memcmp (basename
+len
-2, ".y", 2) == 0)
1732 || (len
> 3 && memcmp (basename
+len
-3, ".in", 3) == 0))
1734 output_name
= get_file_gtfilename (input_file
);
1735 for_name
= basename
;
1737 /* Some headers get used by more than one front-end; hence, it
1738 would be inappropriate to spew them out to a single gtype-<lang>.h
1739 (and gengtype doesn't know how to direct spewage into multiple
1740 gtype-<lang>.h headers at this time). Instead, we pair up these
1741 headers with source files (and their special purpose gt-*.h headers). */
1742 else if (strcmp (basename
, "c-common.h") == 0)
1743 output_name
= "gt-c-common.h", for_name
= "c-common.c";
1744 else if (strcmp (basename
, "c-tree.h") == 0)
1745 output_name
= "gt-c-decl.h", for_name
= "c-decl.c";
1746 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1747 && strcmp (basename
+ 3, "cp-tree.h") == 0)
1748 output_name
= "gt-cp-tree.h", for_name
= "cp/tree.c";
1749 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1750 && strcmp (basename
+ 3, "decl.h") == 0)
1751 output_name
= "gt-cp-decl.h", for_name
= "cp/decl.c";
1752 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1753 && strcmp (basename
+ 3, "name-lookup.h") == 0)
1754 output_name
= "gt-cp-name-lookup.h", for_name
= "cp/name-lookup.c";
1755 else if (strncmp (basename
, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename
[4])
1756 && strcmp (basename
+ 5, "objc-act.h") == 0)
1757 output_name
= "gt-objc-objc-act.h", for_name
= "objc/objc-act.c";
1760 int lang_index
= get_prefix_langdir_index (basename
);
1762 if (lang_index
>= 0)
1763 return base_files
[lang_index
];
1765 output_name
= "gtype-desc.c";
1769 /* Look through to see if we've ever seen this output filename before. */
1770 for (r
= output_files
; r
; r
= r
->next
)
1771 if (strcmp (r
->name
, output_name
) == 0)
1774 /* If not, create it. */
1775 r
= create_file (for_name
, output_name
);
1777 gcc_assert (r
&& r
->name
);
1781 /* The name of an output file, suitable for definitions, that can see
1782 declarations made in INPUT_FILE and is linked into every language
1783 that uses INPUT_FILE. */
1786 get_output_file_name (const char *input_file
)
1788 outf_p o
= get_output_file_with_visibility (input_file
);
1794 /* Copy the output to its final destination,
1795 but don't unnecessarily change modification times. */
1798 close_output_files (void)
1802 for (of
= output_files
; of
; of
= of
->next
)
1806 newfile
= fopen (of
->name
, "r");
1807 if (newfile
!= NULL
)
1812 for (i
= 0; i
< of
->bufused
; i
++)
1815 ch
= fgetc (newfile
);
1816 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
1819 no_write_p
= i
== of
->bufused
&& fgetc (newfile
) == EOF
;
1826 newfile
= fopen (of
->name
, "w");
1827 if (newfile
== NULL
)
1828 fatal ("opening output file %s: %s", of
->name
, strerror (errno
));
1829 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
1830 fatal ("writing output file %s: %s", of
->name
, strerror (errno
));
1831 if (fclose (newfile
) != 0)
1832 fatal ("closing output file %s: %s", of
->name
, strerror (errno
));
1843 struct walk_type_data
;
1845 /* For scalars and strings, given the item in 'val'.
1846 For structures, given a pointer to the item in 'val'.
1847 For misc. pointers, given the item in 'val'.
1849 typedef void (*process_field_fn
)
1850 (type_p f
, const struct walk_type_data
*p
);
1851 typedef void (*func_name_fn
)
1852 (type_p s
, const struct walk_type_data
*p
);
1854 /* Parameters for write_types. */
1856 struct write_types_data
1859 const char *param_prefix
;
1860 const char *subfield_marker_routine
;
1861 const char *marker_routine
;
1862 const char *reorder_note_routine
;
1863 const char *comment
;
1864 int skip_hooks
; /* skip hook generation if non zero */
1867 static void output_escaped_param (struct walk_type_data
*d
,
1868 const char *, const char *);
1869 static void output_mangled_typename (outf_p
, const_type_p
);
1870 static void walk_type (type_p t
, struct walk_type_data
*d
);
1871 static void write_func_for_structure
1872 (type_p orig_s
, type_p s
, type_p
* param
,
1873 const struct write_types_data
*wtd
);
1874 static void write_types_process_field
1875 (type_p f
, const struct walk_type_data
*d
);
1876 static void write_types (type_p structures
,
1877 type_p param_structs
,
1878 const struct write_types_data
*wtd
);
1879 static void write_types_local_process_field
1880 (type_p f
, const struct walk_type_data
*d
);
1881 static void write_local_func_for_structure
1882 (type_p orig_s
, type_p s
, type_p
* param
);
1883 static void write_local (type_p structures
,
1884 type_p param_structs
);
1885 static void write_enum_defn (type_p structures
, type_p param_structs
);
1886 static int contains_scalar_p (type_p t
);
1887 static void put_mangled_filename (outf_p
, const char *);
1888 static void finish_root_table (struct flist
*flp
, const char *pfx
,
1889 const char *tname
, const char *lastname
,
1891 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
1892 struct fileloc
*, const char *);
1893 static void write_array (outf_p f
, pair_p v
,
1894 const struct write_types_data
*wtd
);
1895 static void write_roots (pair_p
);
1897 /* Parameters for walk_type. */
1899 struct walk_type_data
1901 process_field_fn process_field
;
1906 const char *prev_val
[4];
1909 struct fileloc
*line
;
1914 const char *reorder_fn
;
1916 bool fn_wants_lvalue
;
1919 /* Print a mangled name representing T to OF. */
1922 output_mangled_typename (outf_p of
, const_type_p t
)
1926 else switch (t
->kind
)
1930 output_mangled_typename (of
, t
->u
.p
);
1940 case TYPE_LANG_STRUCT
:
1941 oprintf (of
, "%lu%s", (unsigned long) strlen (t
->u
.s
.tag
), t
->u
.s
.tag
);
1943 case TYPE_PARAM_STRUCT
:
1946 for (i
= 0; i
< NUM_PARAM
; i
++)
1947 if (t
->u
.param_struct
.param
[i
] != NULL
)
1948 output_mangled_typename (of
, t
->u
.param_struct
.param
[i
]);
1949 output_mangled_typename (of
, t
->u
.param_struct
.stru
);
1957 /* Print PARAM to D->OF processing escapes. D->VAL references the
1958 current object, D->PREV_VAL the object containing the current
1959 object, ONAME is the name of the option and D->LINE is used to
1960 print error messages. */
1963 output_escaped_param (struct walk_type_data
*d
, const char *param
,
1968 for (p
= param
; *p
; p
++)
1970 oprintf (d
->of
, "%c", *p
);
1974 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
1977 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
1980 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
1984 const char *pp
= d
->val
+ strlen (d
->val
);
1985 while (pp
[-1] == ']')
1988 oprintf (d
->of
, "%s", pp
);
1992 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
1997 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
1998 which is of type T. Write code to D->OF to constrain execution (at
1999 the point that D->PROCESS_FIELD is called) to the appropriate
2000 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2001 pointers to those objects. D->PREV_VAL lists the objects
2002 containing the current object, D->OPT is a list of options to
2003 apply, D->INDENT is the current indentation level, D->LINE is used
2004 to print error messages, D->BITMAP indicates which languages to
2005 print the structure for, and D->PARAM is the current parameter
2006 (from an enclosing param_is option). */
2009 walk_type (type_p t
, struct walk_type_data
*d
)
2011 const char *length
= NULL
;
2012 const char *desc
= NULL
;
2013 int maybe_undef_p
= 0;
2014 int use_param_num
= -1;
2015 int use_params_p
= 0;
2017 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
2019 d
->needs_cast_p
= false;
2020 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
2021 if (strcmp (oo
->name
, "length") == 0)
2023 else if (strcmp (oo
->name
, "maybe_undef") == 0)
2025 else if (strncmp (oo
->name
, "use_param", 9) == 0
2026 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2027 use_param_num
= oo
->name
[9] == '\0' ? 0 : oo
->name
[9] - '0';
2028 else if (strcmp (oo
->name
, "use_params") == 0)
2030 else if (strcmp (oo
->name
, "desc") == 0)
2032 else if (strcmp (oo
->name
, "mark_hook") == 0)
2034 else if (strcmp (oo
->name
, "nested_ptr") == 0)
2035 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
;
2036 else if (strcmp (oo
->name
, "dot") == 0)
2038 else if (strcmp (oo
->name
, "tag") == 0)
2040 else if (strcmp (oo
->name
, "special") == 0)
2042 else if (strcmp (oo
->name
, "skip") == 0)
2044 else if (strcmp (oo
->name
, "default") == 0)
2046 else if (strcmp (oo
->name
, "descbits") == 0)
2048 else if (strcmp (oo
->name
, "param_is") == 0)
2050 else if (strncmp (oo
->name
, "param", 5) == 0
2051 && ISDIGIT (oo
->name
[5])
2052 && strcmp (oo
->name
+ 6, "_is") == 0)
2054 else if (strcmp (oo
->name
, "chain_next") == 0)
2056 else if (strcmp (oo
->name
, "chain_prev") == 0)
2058 else if (strcmp (oo
->name
, "chain_circular") == 0)
2060 else if (strcmp (oo
->name
, "reorder") == 0)
2063 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
2070 int pointer_p
= t
->kind
== TYPE_POINTER
;
2074 if (! UNION_OR_STRUCT_P (t
))
2075 error_at_line (d
->line
, "`use_params' option on unimplemented type");
2077 t
= find_param_structure (t
, d
->param
);
2079 t
= create_pointer (t
);
2082 if (use_param_num
!= -1)
2084 if (d
->param
!= NULL
&& d
->param
[use_param_num
] != NULL
)
2086 type_p nt
= d
->param
[use_param_num
];
2088 if (t
->kind
== TYPE_ARRAY
)
2089 nt
= create_array (nt
, t
->u
.a
.len
);
2090 else if (length
!= NULL
&& t
->kind
== TYPE_POINTER
)
2091 nt
= create_pointer (nt
);
2092 d
->needs_cast_p
= (t
->kind
!= TYPE_POINTER
2093 && (nt
->kind
== TYPE_POINTER
2094 || nt
->kind
== TYPE_STRING
));
2098 error_at_line (d
->line
, "no parameter defined for `%s'",
2103 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
2105 error_at_line (d
->line
,
2106 "field `%s' has invalid option `maybe_undef_p'\n",
2115 d
->process_field (t
, d
);
2121 && t
->u
.p
->u
.s
.line
.file
== NULL
)
2123 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2129 if (! UNION_OR_STRUCT_P (t
->u
.p
)
2130 && t
->u
.p
->kind
!= TYPE_PARAM_STRUCT
)
2132 error_at_line (d
->line
,
2133 "field `%s' is pointer to unimplemented type",
2140 const char *oldprevval2
= d
->prev_val
[2];
2142 if (! UNION_OR_STRUCT_P (nested_ptr_d
->type
))
2144 error_at_line (d
->line
,
2145 "field `%s' has invalid "
2146 "option `nested_ptr'\n",
2151 d
->prev_val
[2] = d
->val
;
2152 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2154 d
->val
= xasprintf ("x%d", d
->counter
++);
2155 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2156 (nested_ptr_d
->type
->kind
== TYPE_UNION
2157 ? "union" : "struct"),
2158 nested_ptr_d
->type
->u
.s
.tag
,
2159 d
->fn_wants_lvalue
? "" : "const ",
2161 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2162 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2164 oprintf (d
->of
, ";\n");
2166 d
->process_field (nested_ptr_d
->type
, d
);
2168 if (d
->fn_wants_lvalue
)
2170 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2172 d
->prev_val
[2] = d
->val
;
2173 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2175 oprintf (d
->of
, ";\n");
2179 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2180 d
->val
= d
->prev_val
[2];
2181 d
->prev_val
[2] = oldprevval2
;
2184 d
->process_field (t
->u
.p
, d
);
2188 int loopcounter
= d
->counter
++;
2189 const char *oldval
= d
->val
;
2190 const char *oldprevval3
= d
->prev_val
[3];
2193 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2195 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2196 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
, "",
2197 loopcounter
, loopcounter
);
2198 output_escaped_param (d
, length
, "length");
2199 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2201 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2203 d
->prev_val
[3] = oldval
;
2204 walk_type (t
->u
.p
, d
);
2207 d
->prev_val
[3] = oldprevval3
;
2210 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2211 d
->process_field(t
, d
);
2213 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2220 int loopcounter
= d
->counter
++;
2221 const char *oldval
= d
->val
;
2224 /* If it's an array of scalars, we optimize by not generating
2226 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2229 /* When walking an array, compute the length and store it in a
2230 local variable before walking the array elements, instead of
2231 recomputing the length expression each time through the loop.
2232 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2233 where the length is stored in the first array element,
2234 because otherwise that operand can get overwritten on the
2236 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2238 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2239 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2240 d
->indent
, "", loopcounter
);
2242 output_escaped_param (d
, length
, "length");
2244 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2245 oprintf (d
->of
, ");\n");
2247 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2249 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2251 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2253 walk_type (t
->u
.a
.p
, d
);
2258 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2260 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2268 const char *oldval
= d
->val
;
2269 const char *oldprevval1
= d
->prev_val
[1];
2270 const char *oldprevval2
= d
->prev_val
[2];
2271 const int union_p
= t
->kind
== TYPE_UNION
;
2272 int seen_default_p
= 0;
2275 if (! t
->u
.s
.line
.file
)
2276 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2278 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2280 error_at_line (d
->line
,
2281 "structure `%s' defined for mismatching languages",
2283 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2286 /* Some things may also be defined in the structure's options. */
2287 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2288 if (! desc
&& strcmp (o
->name
, "desc") == 0)
2291 d
->prev_val
[2] = oldval
;
2292 d
->prev_val
[1] = oldprevval2
;
2297 error_at_line (d
->line
, "missing `desc' option for union `%s'",
2301 oprintf (d
->of
, "%*sswitch (", d
->indent
, "");
2302 output_escaped_param (d
, desc
, "desc");
2303 oprintf (d
->of
, ")\n");
2305 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2307 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
2310 const char *dot
= ".";
2311 const char *tagid
= NULL
;
2314 int use_param_p
= 0;
2317 d
->reorder_fn
= NULL
;
2318 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2319 if (strcmp (oo
->name
, "dot") == 0)
2321 else if (strcmp (oo
->name
, "tag") == 0)
2323 else if (strcmp (oo
->name
, "skip") == 0)
2325 else if (strcmp (oo
->name
, "default") == 0)
2327 else if (strcmp (oo
->name
, "reorder") == 0)
2328 d
->reorder_fn
= oo
->info
;
2329 else if (strncmp (oo
->name
, "use_param", 9) == 0
2330 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2336 if (union_p
&& tagid
)
2338 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
2341 else if (union_p
&& default_p
)
2343 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2347 else if (! union_p
&& (default_p
|| tagid
))
2348 error_at_line (d
->line
,
2349 "can't use `%s' outside a union on field `%s'",
2350 default_p
? "default" : "tag", f
->name
);
2351 else if (union_p
&& ! (default_p
|| tagid
)
2352 && f
->type
->kind
== TYPE_SCALAR
)
2355 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2356 d
->line
->file
, d
->line
->line
, f
->name
);
2359 else if (union_p
&& ! (default_p
|| tagid
))
2360 error_at_line (d
->line
,
2361 "field `%s' is missing `tag' or `default' option",
2365 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
2367 d
->used_length
= false;
2369 if (union_p
&& use_param_p
&& d
->param
== NULL
)
2370 oprintf (d
->of
, "%*sgcc_unreachable ();\n", d
->indent
, "");
2372 walk_type (f
->type
, d
);
2378 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2382 d
->reorder_fn
= NULL
;
2385 d
->prev_val
[1] = oldprevval1
;
2386 d
->prev_val
[2] = oldprevval2
;
2388 if (union_p
&& ! seen_default_p
)
2390 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2391 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
2395 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2401 case TYPE_LANG_STRUCT
:
2404 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
2405 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
2408 error_at_line (d
->line
, "structure `%s' differs between languages",
2415 case TYPE_PARAM_STRUCT
:
2417 type_p
*oldparam
= d
->param
;
2419 d
->param
= t
->u
.param_struct
.param
;
2420 walk_type (t
->u
.param_struct
.stru
, d
);
2421 d
->param
= oldparam
;
2430 /* process_field routine for marking routines. */
2433 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
2435 const struct write_types_data
*wtd
;
2436 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
2437 wtd
= (const struct write_types_data
*) d
->cookie
;
2442 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
2443 wtd
->subfield_marker_routine
, cast
, d
->val
);
2444 if (wtd
->param_prefix
)
2446 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
2449 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
2450 output_mangled_typename (d
->of
, d
->orig_s
);
2453 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
2455 if (f
->u
.p
->kind
== TYPE_PARAM_STRUCT
2456 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2458 oprintf (d
->of
, ", gt_e_");
2459 output_mangled_typename (d
->of
, f
);
2461 else if (UNION_OR_STRUCT_P (f
)
2462 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2464 oprintf (d
->of
, ", gt_ggc_e_");
2465 output_mangled_typename (d
->of
, f
);
2468 oprintf (d
->of
, ", gt_types_enum_last");
2470 oprintf (d
->of
, ");\n");
2471 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2472 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
2473 wtd
->reorder_note_routine
, cast
, d
->val
,
2474 d
->prev_val
[3], d
->reorder_fn
);
2480 case TYPE_LANG_STRUCT
:
2481 case TYPE_PARAM_STRUCT
:
2482 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
2483 output_mangled_typename (d
->of
, f
);
2484 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
2485 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2486 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
2487 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
2499 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2502 output_type_enum (outf_p of
, type_p s
)
2504 if (s
->kind
== TYPE_PARAM_STRUCT
&& s
->u
.s
.line
.file
!= NULL
)
2506 oprintf (of
, ", gt_e_");
2507 output_mangled_typename (of
, s
);
2509 else if (UNION_OR_STRUCT_P (s
) && s
->u
.s
.line
.file
!= NULL
)
2511 oprintf (of
, ", gt_ggc_e_");
2512 output_mangled_typename (of
, s
);
2515 oprintf (of
, ", gt_types_enum_last");
2518 /* For S, a structure that's part of ORIG_S, and using parameters
2519 PARAM, write out a routine that:
2520 - Takes a parameter, a void * but actually of type *S
2521 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2522 field of S or its substructures and (in some cases) things
2523 that are pointed to by S.
2527 write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2528 const struct write_types_data
*wtd
)
2530 const char *fn
= s
->u
.s
.line
.file
;
2532 const char *chain_next
= NULL
;
2533 const char *chain_prev
= NULL
;
2534 const char *chain_circular
= NULL
;
2535 const char *mark_hook_name
= NULL
;
2537 struct walk_type_data d
;
2539 /* This is a hack, and not the good kind either. */
2540 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2541 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2542 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2543 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2545 memset (&d
, 0, sizeof (d
));
2546 d
.of
= get_output_file_with_visibility (fn
);
2548 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2549 if (strcmp (opt
->name
, "chain_next") == 0)
2550 chain_next
= opt
->info
;
2551 else if (strcmp (opt
->name
, "chain_prev") == 0)
2552 chain_prev
= opt
->info
;
2553 else if (strcmp (opt
->name
, "chain_circular") == 0)
2554 chain_circular
= opt
->info
;
2555 else if (strcmp (opt
->name
, "mark_hook") == 0)
2556 mark_hook_name
= opt
->info
;
2558 if (chain_prev
!= NULL
&& chain_next
== NULL
)
2559 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
2560 if (chain_circular
!= NULL
&& chain_next
!= NULL
)
2561 error_at_line (&s
->u
.s
.line
, "chain_circular with chain_next");
2562 if (chain_circular
!= NULL
)
2563 chain_next
= chain_circular
;
2565 d
.process_field
= write_types_process_field
;
2569 d
.line
= &s
->u
.s
.line
;
2570 d
.bitmap
= s
->u
.s
.bitmap
;
2572 d
.prev_val
[0] = "*x";
2573 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2574 d
.prev_val
[3] = "x";
2577 oprintf (d
.of
, "\n");
2578 oprintf (d
.of
, "void\n");
2580 oprintf (d
.of
, "gt_%sx_%s", wtd
->prefix
, orig_s
->u
.s
.tag
);
2583 oprintf (d
.of
, "gt_%s_", wtd
->prefix
);
2584 output_mangled_typename (d
.of
, orig_s
);
2586 oprintf (d
.of
, " (void *x_p)\n");
2587 oprintf (d
.of
, "{\n");
2588 oprintf (d
.of
, " %s %s * %sx = (%s %s *)x_p;\n",
2589 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2590 chain_next
== NULL
? "const " : "",
2591 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2592 if (chain_next
!= NULL
)
2593 oprintf (d
.of
, " %s %s * xlimit = x;\n",
2594 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2595 if (chain_next
== NULL
)
2597 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
2598 if (wtd
->param_prefix
)
2600 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
2601 output_mangled_typename (d
.of
, orig_s
);
2602 output_type_enum (d
.of
, orig_s
);
2604 oprintf (d
.of
, "))\n");
2608 if (chain_circular
!= NULL
)
2609 oprintf (d
.of
, " if (!%s (xlimit", wtd
->marker_routine
);
2611 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2612 if (wtd
->param_prefix
)
2614 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2615 output_mangled_typename (d
.of
, orig_s
);
2616 output_type_enum (d
.of
, orig_s
);
2618 oprintf (d
.of
, "))\n");
2619 if (chain_circular
!= NULL
)
2620 oprintf (d
.of
, " return;\n do\n");
2621 if (mark_hook_name
&& !wtd
->skip_hooks
)
2623 oprintf (d
.of
, " {\n");
2624 oprintf (d
.of
, " %s (xlimit);\n ", mark_hook_name
);
2626 oprintf (d
.of
, " xlimit = (");
2627 d
.prev_val
[2] = "*xlimit";
2628 output_escaped_param (&d
, chain_next
, "chain_next");
2629 oprintf (d
.of
, ");\n");
2630 if (mark_hook_name
&& !wtd
->skip_hooks
)
2631 oprintf (d
.of
, " }\n");
2632 if (chain_prev
!= NULL
)
2634 oprintf (d
.of
, " if (x != xlimit)\n");
2635 oprintf (d
.of
, " for (;;)\n");
2636 oprintf (d
.of
, " {\n");
2637 oprintf (d
.of
, " %s %s * const xprev = (",
2638 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2640 d
.prev_val
[2] = "*x";
2641 output_escaped_param (&d
, chain_prev
, "chain_prev");
2642 oprintf (d
.of
, ");\n");
2643 oprintf (d
.of
, " if (xprev == NULL) break;\n");
2644 oprintf (d
.of
, " x = xprev;\n");
2645 oprintf (d
.of
, " (void) %s (xprev",
2646 wtd
->marker_routine
);
2647 if (wtd
->param_prefix
)
2649 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
2650 output_mangled_typename (d
.of
, orig_s
);
2651 output_type_enum (d
.of
, orig_s
);
2653 oprintf (d
.of
, ");\n");
2654 oprintf (d
.of
, " }\n");
2656 if (chain_circular
!= NULL
)
2658 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2659 if (wtd
->param_prefix
)
2661 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2662 output_mangled_typename (d
.of
, orig_s
);
2663 output_type_enum (d
.of
, orig_s
);
2665 oprintf (d
.of
, "));\n");
2666 if (mark_hook_name
&& !wtd
->skip_hooks
)
2667 oprintf (d
.of
, " %s (xlimit);\n", mark_hook_name
);
2668 oprintf (d
.of
, " do\n");
2671 oprintf (d
.of
, " while (x != xlimit)\n");
2673 oprintf (d
.of
, " {\n");
2674 if (mark_hook_name
&& chain_next
== NULL
&& !wtd
->skip_hooks
)
2676 oprintf (d
.of
, " %s (x);\n", mark_hook_name
);
2678 d
.prev_val
[2] = "*x";
2682 if (chain_next
!= NULL
)
2684 oprintf (d
.of
, " x = (");
2685 output_escaped_param (&d
, chain_next
, "chain_next");
2686 oprintf (d
.of
, ");\n");
2689 oprintf (d
.of
, " }\n");
2690 if (chain_circular
!= NULL
)
2691 oprintf (d
.of
, " while (x != xlimit);\n");
2692 oprintf (d
.of
, "}\n");
2695 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
2698 write_types (type_p structures
, type_p param_structs
,
2699 const struct write_types_data
*wtd
)
2703 oprintf (header_file
, "\n/* %s*/\n", wtd
->comment
);
2704 for (s
= structures
; s
; s
= s
->next
)
2705 if (s
->gc_used
== GC_POINTED_TO
2706 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2710 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2711 && s
->u
.s
.line
.file
== NULL
)
2714 oprintf (header_file
, "#define gt_%s_", wtd
->prefix
);
2715 output_mangled_typename (header_file
, s
);
2716 oprintf (header_file
, "(X) do { \\\n");
2717 oprintf (header_file
,
2718 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
2720 oprintf (header_file
,
2723 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2724 if (strcmp (opt
->name
, "ptr_alias") == 0)
2726 const_type_p
const t
= (const_type_p
) opt
->info
;
2727 if (t
->kind
== TYPE_STRUCT
2728 || t
->kind
== TYPE_UNION
2729 || t
->kind
== TYPE_LANG_STRUCT
)
2730 oprintf (header_file
,
2731 "#define gt_%sx_%s gt_%sx_%s\n",
2732 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t
->u
.s
.tag
);
2734 error_at_line (&s
->u
.s
.line
,
2735 "structure alias is not a structure");
2741 /* Declare the marker procedure only once. */
2742 oprintf (header_file
,
2743 "extern void gt_%sx_%s (void *);\n",
2744 wtd
->prefix
, s
->u
.s
.tag
);
2746 if (s
->u
.s
.line
.file
== NULL
)
2748 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2753 if (s
->kind
== TYPE_LANG_STRUCT
)
2756 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2757 write_func_for_structure (s
, ss
, NULL
, wtd
);
2760 write_func_for_structure (s
, s
, NULL
, wtd
);
2763 for (s
= param_structs
; s
; s
= s
->next
)
2764 if (s
->gc_used
== GC_POINTED_TO
)
2766 type_p
* param
= s
->u
.param_struct
.param
;
2767 type_p stru
= s
->u
.param_struct
.stru
;
2769 /* Declare the marker procedure. */
2770 oprintf (header_file
, "extern void gt_%s_", wtd
->prefix
);
2771 output_mangled_typename (header_file
, s
);
2772 oprintf (header_file
, " (void *);\n");
2774 if (stru
->u
.s
.line
.file
== NULL
)
2776 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2781 if (stru
->kind
== TYPE_LANG_STRUCT
)
2784 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2785 write_func_for_structure (s
, ss
, param
, wtd
);
2788 write_func_for_structure (s
, stru
, param
, wtd
);
2792 static const struct write_types_data ggc_wtd
=
2794 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
2795 "GC marker procedures. ",
2799 static const struct write_types_data pch_wtd
=
2801 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
2802 "gt_pch_note_reorder",
2803 "PCH type-walking procedures. ",
2807 /* Write out the local pointer-walking routines. */
2809 /* process_field routine for local pointer-walking. */
2812 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
2819 case TYPE_LANG_STRUCT
:
2820 case TYPE_PARAM_STRUCT
:
2822 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
2824 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
2835 /* For S, a structure that's part of ORIG_S, and using parameters
2836 PARAM, write out a routine that:
2837 - Is of type gt_note_pointers
2838 - Calls PROCESS_FIELD on each field of S or its substructures.
2842 write_local_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
)
2844 const char *fn
= s
->u
.s
.line
.file
;
2846 struct walk_type_data d
;
2848 /* This is a hack, and not the good kind either. */
2849 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2850 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2851 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2852 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2854 memset (&d
, 0, sizeof (d
));
2855 d
.of
= get_output_file_with_visibility (fn
);
2856 d
.process_field
= write_types_local_process_field
;
2858 d
.line
= &s
->u
.s
.line
;
2859 d
.bitmap
= s
->u
.s
.bitmap
;
2861 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
2862 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2863 d
.prev_val
[3] = "x";
2865 d
.fn_wants_lvalue
= true;
2867 oprintf (d
.of
, "\n");
2868 oprintf (d
.of
, "void\n");
2869 oprintf (d
.of
, "gt_pch_p_");
2870 output_mangled_typename (d
.of
, orig_s
);
2871 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
2873 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2874 "\tATTRIBUTE_UNUSED void *cookie)\n");
2875 oprintf (d
.of
, "{\n");
2876 oprintf (d
.of
, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
2877 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2878 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2881 oprintf (d
.of
, "}\n");
2884 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
2887 write_local (type_p structures
, type_p param_structs
)
2893 oprintf (header_file
, "\n/* Local pointer-walking routines. */\n");
2894 for (s
= structures
; s
; s
= s
->next
)
2895 if (s
->gc_used
== GC_POINTED_TO
2896 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2900 if (s
->u
.s
.line
.file
== NULL
)
2903 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2904 if (strcmp (opt
->name
, "ptr_alias") == 0)
2906 const_type_p
const t
= (const_type_p
) opt
->info
;
2907 if (t
->kind
== TYPE_STRUCT
2908 || t
->kind
== TYPE_UNION
2909 || t
->kind
== TYPE_LANG_STRUCT
)
2911 oprintf (header_file
, "#define gt_pch_p_");
2912 output_mangled_typename (header_file
, s
);
2913 oprintf (header_file
, " gt_pch_p_");
2914 output_mangled_typename (header_file
, t
);
2915 oprintf (header_file
, "\n");
2918 error_at_line (&s
->u
.s
.line
,
2919 "structure alias is not a structure");
2925 /* Declare the marker procedure only once. */
2926 oprintf (header_file
, "extern void gt_pch_p_");
2927 output_mangled_typename (header_file
, s
);
2928 oprintf (header_file
,
2929 "\n (void *, void *, gt_pointer_operator, void *);\n");
2931 if (s
->kind
== TYPE_LANG_STRUCT
)
2934 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2935 write_local_func_for_structure (s
, ss
, NULL
);
2938 write_local_func_for_structure (s
, s
, NULL
);
2941 for (s
= param_structs
; s
; s
= s
->next
)
2942 if (s
->gc_used
== GC_POINTED_TO
)
2944 type_p
* param
= s
->u
.param_struct
.param
;
2945 type_p stru
= s
->u
.param_struct
.stru
;
2947 /* Declare the marker procedure. */
2948 oprintf (header_file
, "extern void gt_pch_p_");
2949 output_mangled_typename (header_file
, s
);
2950 oprintf (header_file
,
2951 "\n (void *, void *, gt_pointer_operator, void *);\n");
2953 if (stru
->u
.s
.line
.file
== NULL
)
2955 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2960 if (stru
->kind
== TYPE_LANG_STRUCT
)
2963 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2964 write_local_func_for_structure (s
, ss
, param
);
2967 write_local_func_for_structure (s
, stru
, param
);
2971 /* Write out the 'enum' definition for gt_types_enum. */
2974 write_enum_defn (type_p structures
, type_p param_structs
)
2980 oprintf (header_file
, "\n/* Enumeration of types known. */\n");
2981 oprintf (header_file
, "enum gt_types_enum {\n");
2982 for (s
= structures
; s
; s
= s
->next
)
2983 if (s
->gc_used
== GC_POINTED_TO
2984 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2986 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2987 && s
->u
.s
.line
.file
== NULL
)
2990 oprintf (header_file
, " gt_ggc_e_");
2991 output_mangled_typename (header_file
, s
);
2992 oprintf (header_file
, ", \n");
2994 for (s
= param_structs
; s
; s
= s
->next
)
2995 if (s
->gc_used
== GC_POINTED_TO
)
2997 oprintf (header_file
, " gt_e_");
2998 output_mangled_typename (header_file
, s
);
2999 oprintf (header_file
, ", \n");
3001 oprintf (header_file
, " gt_types_enum_last\n");
3002 oprintf (header_file
, "};\n");
3005 /* Might T contain any non-pointer elements? */
3008 contains_scalar_p (type_p t
)
3016 return contains_scalar_p (t
->u
.a
.p
);
3018 /* Could also check for structures that have no non-pointer
3019 fields, but there aren't enough of those to worry about. */
3024 /* Mangle FN and print it to F. */
3027 put_mangled_filename (outf_p f
, const char *fn
)
3029 const char *name
= get_output_file_name (fn
);
3032 for (; *name
!= 0; name
++)
3033 if (ISALNUM (*name
))
3034 oprintf (f
, "%c", *name
);
3036 oprintf (f
, "%c", '_');
3039 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
3040 LASTNAME, and NAME are all strings to insert in various places in
3041 the resulting code. */
3044 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
3045 const char *tname
, const char *name
)
3049 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3050 if (fli2
->started_p
)
3052 oprintf (fli2
->f
, " %s\n", lastname
);
3053 oprintf (fli2
->f
, "};\n\n");
3056 for (fli2
= flp
; fli2
&& base_files
; fli2
= fli2
->next
)
3057 if (fli2
->started_p
)
3059 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
3062 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
3065 oprintf (base_files
[fnum
],
3066 "extern const struct %s gt_%s_",
3068 put_mangled_filename (base_files
[fnum
], fli2
->name
);
3069 oprintf (base_files
[fnum
], "[];\n");
3075 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3076 oprintf (base_files
[fnum
],
3077 "EXPORTED_CONST struct %s * const %s[] = {\n",
3082 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3083 if (fli2
->started_p
)
3085 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
3088 fli2
->started_p
= 0;
3090 for (fnum
= 0; base_files
&& bitmap
!= 0; fnum
++, bitmap
>>= 1)
3093 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
3094 put_mangled_filename (base_files
[fnum
], fli2
->name
);
3095 oprintf (base_files
[fnum
], ",\n");
3101 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3103 oprintf (base_files
[fnum
], " NULL\n");
3104 oprintf (base_files
[fnum
], "};\n");
3109 /* Write out to F the table entry and any marker routines needed to
3110 mark NAME as TYPE. The original variable is V, at LINE.
3111 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
3112 is nonzero iff we are building the root table for hash table caches. */
3115 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
3116 struct fileloc
*line
, const char *if_marked
)
3123 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
3126 const char *desc
= NULL
;
3129 for (o
= fld
->opt
; o
; o
= o
->next
)
3130 if (strcmp (o
->name
, "skip") == 0)
3132 else if (strcmp (o
->name
, "desc") == 0)
3134 else if (strcmp (o
->name
, "param_is") == 0)
3137 error_at_line (line
,
3138 "field `%s' of global `%s' has unknown option `%s'",
3139 fld
->name
, name
, o
->name
);
3143 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
3145 pair_p validf
= NULL
;
3148 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
3150 const char *tag
= NULL
;
3153 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
3154 if (strcmp (oo
->name
, "tag") == 0)
3156 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
3159 error_at_line (line
,
3160 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3161 name
, fld
->name
, validf
->name
,
3162 name
, fld
->name
, ufld
->name
,
3169 newname
= xasprintf ("%s.%s.%s",
3170 name
, fld
->name
, validf
->name
);
3171 write_root (f
, v
, validf
->type
, newname
, 0, line
,
3177 error_at_line (line
,
3178 "global `%s.%s' has `desc' option but is not union",
3183 newname
= xasprintf ("%s.%s", name
, fld
->name
);
3184 write_root (f
, v
, fld
->type
, newname
, 0, line
, if_marked
);
3194 newname
= xasprintf ("%s[0]", name
);
3195 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, if_marked
);
3204 oprintf (f
, " {\n");
3205 oprintf (f
, " &%s,\n", name
);
3208 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3210 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
3211 else if (ap
== v
->type
)
3212 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
3214 oprintf (f
, " sizeof (%s", v
->name
);
3215 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3217 oprintf (f
, "),\n");
3221 if (! has_length
&& UNION_OR_STRUCT_P (tp
))
3223 oprintf (f
, " >_ggc_mx_%s,\n", tp
->u
.s
.tag
);
3224 oprintf (f
, " >_pch_nx_%s", tp
->u
.s
.tag
);
3226 else if (! has_length
&& tp
->kind
== TYPE_PARAM_STRUCT
)
3228 oprintf (f
, " >_ggc_m_");
3229 output_mangled_typename (f
, tp
);
3230 oprintf (f
, ",\n >_pch_n_");
3231 output_mangled_typename (f
, tp
);
3234 && (tp
->kind
== TYPE_POINTER
|| UNION_OR_STRUCT_P (tp
)))
3236 oprintf (f
, " >_ggc_ma_%s,\n", name
);
3237 oprintf (f
, " >_pch_na_%s", name
);
3241 error_at_line (line
,
3242 "global `%s' is pointer to unimplemented type",
3246 oprintf (f
, ",\n &%s", if_marked
);
3247 oprintf (f
, "\n },\n");
3253 oprintf (f
, " {\n");
3254 oprintf (f
, " &%s,\n", name
);
3255 oprintf (f
, " 1, \n");
3256 oprintf (f
, " sizeof (%s),\n", v
->name
);
3257 oprintf (f
, " (gt_pointer_walker) >_ggc_m_S,\n");
3258 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
3259 oprintf (f
, " },\n");
3267 error_at_line (line
,
3268 "global `%s' is unimplemented type",
3273 /* This generates a routine to walk an array. */
3276 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
3278 struct walk_type_data d
;
3281 memset (&d
, 0, sizeof (d
));
3287 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
3290 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
3292 if (wtd
->param_prefix
)
3294 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
3296 " (void *, void *, gt_pointer_operator, void *);\n");
3297 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3298 wtd
->param_prefix
, v
->name
);
3300 " ATTRIBUTE_UNUSED void *x_p,\n"
3301 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3302 " ATTRIBUTE_UNUSED void * cookie)\n");
3303 oprintf (d
.of
, "{\n");
3304 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3305 d
.process_field
= write_types_local_process_field
;
3306 walk_type (v
->type
, &d
);
3307 oprintf (f
, "}\n\n");
3311 oprintf (f
, "static void gt_%sa_%s (void *);\n",
3312 wtd
->prefix
, v
->name
);
3313 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3314 wtd
->prefix
, v
->name
);
3316 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3317 d
.process_field
= write_types_process_field
;
3318 walk_type (v
->type
, &d
);
3320 oprintf (f
, "}\n\n");
3323 /* Output a table describing the locations and types of VARIABLES. */
3326 write_roots (pair_p variables
)
3329 struct flist
*flp
= NULL
;
3331 for (v
= variables
; v
; v
= v
->next
)
3333 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3335 const char *length
= NULL
;
3336 int deletable_p
= 0;
3339 for (o
= v
->opt
; o
; o
= o
->next
)
3340 if (strcmp (o
->name
, "length") == 0)
3342 else if (strcmp (o
->name
, "deletable") == 0)
3344 else if (strcmp (o
->name
, "param_is") == 0)
3346 else if (strncmp (o
->name
, "param", 5) == 0
3347 && ISDIGIT (o
->name
[5])
3348 && strcmp (o
->name
+ 6, "_is") == 0)
3350 else if (strcmp (o
->name
, "if_marked") == 0)
3353 error_at_line (&v
->line
,
3354 "global `%s' has unknown option `%s'",
3357 for (fli
= flp
; fli
; fli
= fli
->next
)
3358 if (fli
->f
== f
&& f
)
3362 fli
= XNEW (struct flist
);
3366 fli
->name
= v
->line
.file
;
3367 gcc_assert(fli
->name
);
3370 oprintf (f
, "\n/* GC roots. */\n\n");
3375 && v
->type
->kind
== TYPE_POINTER
3376 && (v
->type
->u
.p
->kind
== TYPE_POINTER
3377 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
3379 write_array (f
, v
, &ggc_wtd
);
3380 write_array (f
, v
, &pch_wtd
);
3384 for (v
= variables
; v
; v
= v
->next
)
3386 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3392 for (o
= v
->opt
; o
; o
= o
->next
)
3393 if (strcmp (o
->name
, "length") == 0)
3395 else if (strcmp (o
->name
, "deletable") == 0
3396 || strcmp (o
->name
, "if_marked") == 0)
3402 for (fli
= flp
; fli
; fli
= fli
->next
)
3405 if (! fli
->started_p
)
3409 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3410 put_mangled_filename (f
, v
->line
.file
);
3411 oprintf (f
, "[] = {\n");
3414 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3417 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3420 for (v
= variables
; v
; v
= v
->next
)
3422 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3427 for (o
= v
->opt
; o
; o
= o
->next
)
3428 if (strcmp (o
->name
, "deletable") == 0)
3430 else if (strcmp (o
->name
, "if_marked") == 0)
3436 for (fli
= flp
; fli
; fli
= fli
->next
)
3439 if (! fli
->started_p
)
3443 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3444 put_mangled_filename (f
, v
->line
.file
);
3445 oprintf (f
, "[] = {\n");
3448 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3452 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3453 "gt_ggc_deletable_rtab");
3455 for (v
= variables
; v
; v
= v
->next
)
3457 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3459 const char *if_marked
= NULL
;
3463 for (o
= v
->opt
; o
; o
= o
->next
)
3464 if (strcmp (o
->name
, "length") == 0)
3466 else if (strcmp (o
->name
, "if_marked") == 0)
3467 if_marked
= o
->info
;
3469 if (if_marked
== NULL
)
3472 if (v
->type
->kind
!= TYPE_POINTER
3473 || v
->type
->u
.p
->kind
!= TYPE_PARAM_STRUCT
3474 || v
->type
->u
.p
->u
.param_struct
.stru
!= find_structure ("htab", 0))
3476 error_at_line (&v
->line
, "if_marked option used but not hash table");
3480 for (fli
= flp
; fli
; fli
= fli
->next
)
3483 if (! fli
->started_p
)
3487 oprintf (f
, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
3488 put_mangled_filename (f
, v
->line
.file
);
3489 oprintf (f
, "[] = {\n");
3492 write_root (f
, v
, v
->type
->u
.p
->u
.param_struct
.param
[0],
3493 v
->name
, length_p
, &v
->line
, if_marked
);
3496 finish_root_table (flp
, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
3497 "gt_ggc_cache_rtab");
3499 for (v
= variables
; v
; v
= v
->next
)
3501 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3504 int if_marked_p
= 0;
3507 for (o
= v
->opt
; o
; o
= o
->next
)
3508 if (strcmp (o
->name
, "length") == 0)
3510 else if (strcmp (o
->name
, "if_marked") == 0)
3516 for (fli
= flp
; fli
; fli
= fli
->next
)
3519 if (! fli
->started_p
)
3523 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
3524 put_mangled_filename (f
, v
->line
.file
);
3525 oprintf (f
, "[] = {\n");
3528 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3531 finish_root_table (flp
, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3532 "gt_pch_cache_rtab");
3534 for (v
= variables
; v
; v
= v
->next
)
3536 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3541 for (o
= v
->opt
; o
; o
= o
->next
)
3542 if (strcmp (o
->name
, "deletable") == 0
3543 || strcmp (o
->name
, "if_marked") == 0)
3549 if (! contains_scalar_p (v
->type
))
3552 for (fli
= flp
; fli
; fli
= fli
->next
)
3555 if (! fli
->started_p
)
3559 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
3560 put_mangled_filename (f
, v
->line
.file
);
3561 oprintf (f
, "[] = {\n");
3564 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3568 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3569 "gt_pch_scalar_rtab");
3572 /* Record the definition of a generic VEC structure, as if we had expanded
3573 the macros in vec.h:
3575 typedef struct VEC_<type>_base GTY(()) {
3578 <type> GTY((length ("%h.num"))) vec[1];
3581 where the GTY(()) tags are only present if is_scalar is _false_. */
3584 note_def_vec (const char *type_name
, bool is_scalar
, struct fileloc
*pos
)
3589 type_p len_ty
= create_scalar_type ("unsigned");
3590 const char *name
= concat ("VEC_", type_name
, "_base", (char *)0);
3594 t
= create_scalar_type (type_name
);
3599 t
= resolve_typedef (type_name
, pos
);
3600 o
= create_option (0, "length", "%h.num");
3603 /* We assemble the field list in reverse order. */
3604 fields
= create_field_at (0, create_array (t
, "1"), "vec", o
, pos
);
3605 fields
= create_field_at (fields
, len_ty
, "alloc", 0, pos
);
3606 fields
= create_field_at (fields
, len_ty
, "num", 0, pos
);
3608 do_typedef (name
, new_structure (name
, 0, pos
, fields
, 0), pos
);
3611 /* Record the definition of an allocation-specific VEC structure, as if
3612 we had expanded the macros in vec.h:
3614 typedef struct VEC_<type>_<astrat> {
3615 VEC_<type>_base base;
3616 } VEC_<type>_<astrat>;
3619 note_def_vec_alloc (const char *type
, const char *astrat
, struct fileloc
*pos
)
3621 const char *astratname
= concat ("VEC_", type
, "_", astrat
, (char *)0);
3622 const char *basename
= concat ("VEC_", type
, "_base", (char *)0);
3624 pair_p field
= create_field_at (0, resolve_typedef (basename
, pos
),
3627 do_typedef (astratname
, new_structure (astratname
, 0, pos
, field
, 0), pos
);
3632 main (int argc
, char **argv
)
3635 static struct fileloc pos
= { this_file
, 0 };
3636 char* inputlist
= 0;
3637 /* fatal uses this */
3638 progname
= "gengtype";
3640 if (argc
>= 5 && !strcmp (argv
[1], "-p"))
3643 inputlist
= argv
[3];
3644 plugin_files
= argv
+4;
3645 nb_plugin_files
= argc
-4;
3650 inputlist
= argv
[2];
3653 fatal ("usage: gengtype [-p] srcdir input-list [file1 file2 ... fileN]");
3655 srcdir_len
= strlen (srcdir
);
3657 read_input_list (inputlist
);
3661 scalar_char
.u
.scalar_is_char
= true;
3662 scalar_nonchar
.u
.scalar_is_char
= false;
3665 /* These types are set up with #define or else outside of where
3667 pos
.line
= __LINE__
+ 1;
3668 do_scalar_typedef ("CUMULATIVE_ARGS", &pos
); pos
.line
++;
3669 do_scalar_typedef ("REAL_VALUE_TYPE", &pos
); pos
.line
++;
3670 do_scalar_typedef ("FIXED_VALUE_TYPE", &pos
); pos
.line
++;
3671 do_scalar_typedef ("double_int", &pos
); pos
.line
++;
3672 do_scalar_typedef ("uint8", &pos
); pos
.line
++;
3673 do_scalar_typedef ("jword", &pos
); pos
.line
++;
3674 do_scalar_typedef ("JCF_u2", &pos
); pos
.line
++;
3675 do_scalar_typedef ("void", &pos
); pos
.line
++;
3676 do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos
)), &pos
);
3678 for (i
= 0; i
< num_gt_files
; i
++)
3679 parse_file (gt_files
[i
]);
3684 set_gc_used (variables
);
3687 write_enum_defn (structures
, param_structs
);
3688 write_types (structures
, param_structs
, &ggc_wtd
);
3689 write_types (structures
, param_structs
, &pch_wtd
);
3690 write_local (structures
, param_structs
);
3691 write_roots (variables
);
3693 close_output_files ();