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",
1573 const char *const *ifp
;
1574 outf_p gtype_desc_c
;
1576 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1577 for (ifp
= ifiles
; *ifp
; ifp
++)
1578 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1580 /* Make sure we handle "cfun" specially. */
1581 oprintf (gtype_desc_c
, "\n/* See definition in function.h. */\n");
1582 oprintf (gtype_desc_c
, "#undef cfun\n");
1586 /* For F a filename, return the real basename of F, with all the directory
1587 components skipped. */
1590 get_file_realbasename (const char *f
)
1592 const char * lastslash
= strrchr (f
, '/');
1594 return (lastslash
!= NULL
) ? lastslash
+ 1 : f
;
1597 /* For F a filename, return the relative path to F from $(srcdir) if the
1598 latter is a prefix in F, NULL otherwise. */
1601 get_file_srcdir_relative_path (const char *f
)
1603 if (strlen (f
) > srcdir_len
1604 && IS_DIR_SEPARATOR (f
[srcdir_len
])
1605 && memcmp (f
, srcdir
, srcdir_len
) == 0)
1606 return f
+ srcdir_len
+ 1;
1611 /* For F a filename, return the relative path to F from $(srcdir) if the
1612 latter is a prefix in F, or the real basename of F otherwise. */
1615 get_file_basename (const char *f
)
1617 const char * srcdir_path
= get_file_srcdir_relative_path (f
);
1619 return (srcdir_path
!= NULL
) ? srcdir_path
: get_file_realbasename (f
);
1622 /* For F a filename, return the lang_dir_names relative index of the language
1623 directory that is a prefix in F, if any, -1 otherwise. */
1626 get_prefix_langdir_index (const char *f
)
1628 size_t f_len
= strlen (f
);
1631 for (lang_index
= 0; lang_index
< num_lang_dirs
; lang_index
++)
1633 const char * langdir
= lang_dir_names
[lang_index
];
1634 size_t langdir_len
= strlen (langdir
);
1636 if (f_len
> langdir_len
1637 && IS_DIR_SEPARATOR (f
[langdir_len
])
1638 && memcmp (f
, langdir
, langdir_len
) == 0)
1645 /* For F a filename, return the name of language directory where F is located,
1646 if any, NULL otherwise. */
1649 get_file_langdir (const char *f
)
1651 /* Get the relative path to F from $(srcdir) and find the language by
1652 comparing the prefix with language directory names. If F is not even
1653 srcdir relative, no point in looking further. */
1656 const char * srcdir_relative_path
= get_file_srcdir_relative_path (f
);
1658 if (!srcdir_relative_path
)
1661 lang_index
= get_prefix_langdir_index (srcdir_relative_path
);
1663 return (lang_index
>= 0) ? lang_dir_names
[lang_index
] : NULL
;
1666 /* The gt- output file name for F. */
1669 get_file_gtfilename (const char *f
)
1671 /* Cook up an initial version of the gt- file name from the file real
1672 basename and the language name, if any. */
1674 const char *basename
= get_file_realbasename (f
);
1675 const char *langdir
= get_file_langdir (f
);
1678 (langdir
? xasprintf ("gt-%s-%s", langdir
, basename
)
1679 : xasprintf ("gt-%s", basename
));
1681 /* Then replace all non alphanumerics characters by '-' and change the
1682 extenstion to ".h". We expect the input filename extension was at least
1683 one character long. */
1687 for (; *s
!= '.'; s
++)
1688 if (! ISALNUM (*s
) && *s
!= '-')
1691 memcpy (s
, ".h", sizeof (".h"));
1696 /* An output file, suitable for definitions, that can see declarations
1697 made in INPUT_FILE and is linked into every language that uses
1701 get_output_file_with_visibility (const char *input_file
)
1705 const char *basename
;
1706 const char *for_name
;
1707 const char *output_name
;
1709 /* This can happen when we need a file with visibility on a
1710 structure that we've never seen. We have to just hope that it's
1711 globally visible. */
1712 if (input_file
== NULL
)
1713 input_file
= "system.h";
1715 /* In plugin mode, return NULL unless the input_file is one of the
1717 if (plugin_files
&& nb_plugin_files
> 0)
1720 for (i
= 0; i
< nb_plugin_files
&& ix
< 0; i
++)
1721 if (strcmp (input_file
, plugin_files
[i
]) == 0)
1727 /* Determine the output file name. */
1728 basename
= get_file_basename (input_file
);
1730 len
= strlen (basename
);
1731 if ((len
> 2 && memcmp (basename
+len
-2, ".c", 2) == 0)
1732 || (len
> 2 && memcmp (basename
+len
-2, ".y", 2) == 0)
1733 || (len
> 3 && memcmp (basename
+len
-3, ".in", 3) == 0))
1735 output_name
= get_file_gtfilename (input_file
);
1736 for_name
= basename
;
1738 /* Some headers get used by more than one front-end; hence, it
1739 would be inappropriate to spew them out to a single gtype-<lang>.h
1740 (and gengtype doesn't know how to direct spewage into multiple
1741 gtype-<lang>.h headers at this time). Instead, we pair up these
1742 headers with source files (and their special purpose gt-*.h headers). */
1743 else if (strcmp (basename
, "c-common.h") == 0)
1744 output_name
= "gt-c-common.h", for_name
= "c-common.c";
1745 else if (strcmp (basename
, "c-lang.h") == 0)
1746 output_name
= "gt-c-decl.h", for_name
= "c-decl.c";
1747 else if (strcmp (basename
, "c-tree.h") == 0)
1748 output_name
= "gt-c-decl.h", for_name
= "c-decl.c";
1749 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1750 && strcmp (basename
+ 3, "cp-tree.h") == 0)
1751 output_name
= "gt-cp-tree.h", for_name
= "cp/tree.c";
1752 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1753 && strcmp (basename
+ 3, "decl.h") == 0)
1754 output_name
= "gt-cp-decl.h", for_name
= "cp/decl.c";
1755 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1756 && strcmp (basename
+ 3, "name-lookup.h") == 0)
1757 output_name
= "gt-cp-name-lookup.h", for_name
= "cp/name-lookup.c";
1758 else if (strncmp (basename
, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename
[4])
1759 && strcmp (basename
+ 5, "objc-act.h") == 0)
1760 output_name
= "gt-objc-objc-act.h", for_name
= "objc/objc-act.c";
1763 int lang_index
= get_prefix_langdir_index (basename
);
1765 if (lang_index
>= 0)
1766 return base_files
[lang_index
];
1768 output_name
= "gtype-desc.c";
1772 /* Look through to see if we've ever seen this output filename before. */
1773 for (r
= output_files
; r
; r
= r
->next
)
1774 if (strcmp (r
->name
, output_name
) == 0)
1777 /* If not, create it. */
1778 r
= create_file (for_name
, output_name
);
1780 gcc_assert (r
&& r
->name
);
1784 /* The name of an output file, suitable for definitions, that can see
1785 declarations made in INPUT_FILE and is linked into every language
1786 that uses INPUT_FILE. */
1789 get_output_file_name (const char *input_file
)
1791 outf_p o
= get_output_file_with_visibility (input_file
);
1797 /* Copy the output to its final destination,
1798 but don't unnecessarily change modification times. */
1801 close_output_files (void)
1805 for (of
= output_files
; of
; of
= of
->next
)
1809 newfile
= fopen (of
->name
, "r");
1810 if (newfile
!= NULL
)
1815 for (i
= 0; i
< of
->bufused
; i
++)
1818 ch
= fgetc (newfile
);
1819 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
1822 no_write_p
= i
== of
->bufused
&& fgetc (newfile
) == EOF
;
1829 newfile
= fopen (of
->name
, "w");
1830 if (newfile
== NULL
)
1831 fatal ("opening output file %s: %s", of
->name
, strerror (errno
));
1832 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
1833 fatal ("writing output file %s: %s", of
->name
, strerror (errno
));
1834 if (fclose (newfile
) != 0)
1835 fatal ("closing output file %s: %s", of
->name
, strerror (errno
));
1846 struct walk_type_data
;
1848 /* For scalars and strings, given the item in 'val'.
1849 For structures, given a pointer to the item in 'val'.
1850 For misc. pointers, given the item in 'val'.
1852 typedef void (*process_field_fn
)
1853 (type_p f
, const struct walk_type_data
*p
);
1854 typedef void (*func_name_fn
)
1855 (type_p s
, const struct walk_type_data
*p
);
1857 /* Parameters for write_types. */
1859 struct write_types_data
1862 const char *param_prefix
;
1863 const char *subfield_marker_routine
;
1864 const char *marker_routine
;
1865 const char *reorder_note_routine
;
1866 const char *comment
;
1867 int skip_hooks
; /* skip hook generation if non zero */
1870 static void output_escaped_param (struct walk_type_data
*d
,
1871 const char *, const char *);
1872 static void output_mangled_typename (outf_p
, const_type_p
);
1873 static void walk_type (type_p t
, struct walk_type_data
*d
);
1874 static void write_func_for_structure
1875 (type_p orig_s
, type_p s
, type_p
* param
,
1876 const struct write_types_data
*wtd
);
1877 static void write_types_process_field
1878 (type_p f
, const struct walk_type_data
*d
);
1879 static void write_types (type_p structures
,
1880 type_p param_structs
,
1881 const struct write_types_data
*wtd
);
1882 static void write_types_local_process_field
1883 (type_p f
, const struct walk_type_data
*d
);
1884 static void write_local_func_for_structure
1885 (type_p orig_s
, type_p s
, type_p
* param
);
1886 static void write_local (type_p structures
,
1887 type_p param_structs
);
1888 static void write_enum_defn (type_p structures
, type_p param_structs
);
1889 static int contains_scalar_p (type_p t
);
1890 static void put_mangled_filename (outf_p
, const char *);
1891 static void finish_root_table (struct flist
*flp
, const char *pfx
,
1892 const char *tname
, const char *lastname
,
1894 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
1895 struct fileloc
*, const char *);
1896 static void write_array (outf_p f
, pair_p v
,
1897 const struct write_types_data
*wtd
);
1898 static void write_roots (pair_p
);
1900 /* Parameters for walk_type. */
1902 struct walk_type_data
1904 process_field_fn process_field
;
1909 const char *prev_val
[4];
1912 struct fileloc
*line
;
1917 const char *reorder_fn
;
1919 bool fn_wants_lvalue
;
1922 /* Print a mangled name representing T to OF. */
1925 output_mangled_typename (outf_p of
, const_type_p t
)
1929 else switch (t
->kind
)
1933 output_mangled_typename (of
, t
->u
.p
);
1943 case TYPE_LANG_STRUCT
:
1944 oprintf (of
, "%lu%s", (unsigned long) strlen (t
->u
.s
.tag
), t
->u
.s
.tag
);
1946 case TYPE_PARAM_STRUCT
:
1949 for (i
= 0; i
< NUM_PARAM
; i
++)
1950 if (t
->u
.param_struct
.param
[i
] != NULL
)
1951 output_mangled_typename (of
, t
->u
.param_struct
.param
[i
]);
1952 output_mangled_typename (of
, t
->u
.param_struct
.stru
);
1960 /* Print PARAM to D->OF processing escapes. D->VAL references the
1961 current object, D->PREV_VAL the object containing the current
1962 object, ONAME is the name of the option and D->LINE is used to
1963 print error messages. */
1966 output_escaped_param (struct walk_type_data
*d
, const char *param
,
1971 for (p
= param
; *p
; p
++)
1973 oprintf (d
->of
, "%c", *p
);
1977 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
1980 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
1983 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
1987 const char *pp
= d
->val
+ strlen (d
->val
);
1988 while (pp
[-1] == ']')
1991 oprintf (d
->of
, "%s", pp
);
1995 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
2000 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2001 which is of type T. Write code to D->OF to constrain execution (at
2002 the point that D->PROCESS_FIELD is called) to the appropriate
2003 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2004 pointers to those objects. D->PREV_VAL lists the objects
2005 containing the current object, D->OPT is a list of options to
2006 apply, D->INDENT is the current indentation level, D->LINE is used
2007 to print error messages, D->BITMAP indicates which languages to
2008 print the structure for, and D->PARAM is the current parameter
2009 (from an enclosing param_is option). */
2012 walk_type (type_p t
, struct walk_type_data
*d
)
2014 const char *length
= NULL
;
2015 const char *desc
= NULL
;
2016 int maybe_undef_p
= 0;
2017 int use_param_num
= -1;
2018 int use_params_p
= 0;
2020 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
2022 d
->needs_cast_p
= false;
2023 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
2024 if (strcmp (oo
->name
, "length") == 0)
2026 else if (strcmp (oo
->name
, "maybe_undef") == 0)
2028 else if (strncmp (oo
->name
, "use_param", 9) == 0
2029 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2030 use_param_num
= oo
->name
[9] == '\0' ? 0 : oo
->name
[9] - '0';
2031 else if (strcmp (oo
->name
, "use_params") == 0)
2033 else if (strcmp (oo
->name
, "desc") == 0)
2035 else if (strcmp (oo
->name
, "mark_hook") == 0)
2037 else if (strcmp (oo
->name
, "nested_ptr") == 0)
2038 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
;
2039 else if (strcmp (oo
->name
, "dot") == 0)
2041 else if (strcmp (oo
->name
, "tag") == 0)
2043 else if (strcmp (oo
->name
, "special") == 0)
2045 else if (strcmp (oo
->name
, "skip") == 0)
2047 else if (strcmp (oo
->name
, "default") == 0)
2049 else if (strcmp (oo
->name
, "descbits") == 0)
2051 else if (strcmp (oo
->name
, "param_is") == 0)
2053 else if (strncmp (oo
->name
, "param", 5) == 0
2054 && ISDIGIT (oo
->name
[5])
2055 && strcmp (oo
->name
+ 6, "_is") == 0)
2057 else if (strcmp (oo
->name
, "chain_next") == 0)
2059 else if (strcmp (oo
->name
, "chain_prev") == 0)
2061 else if (strcmp (oo
->name
, "chain_circular") == 0)
2063 else if (strcmp (oo
->name
, "reorder") == 0)
2066 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
2073 int pointer_p
= t
->kind
== TYPE_POINTER
;
2077 if (! UNION_OR_STRUCT_P (t
))
2078 error_at_line (d
->line
, "`use_params' option on unimplemented type");
2080 t
= find_param_structure (t
, d
->param
);
2082 t
= create_pointer (t
);
2085 if (use_param_num
!= -1)
2087 if (d
->param
!= NULL
&& d
->param
[use_param_num
] != NULL
)
2089 type_p nt
= d
->param
[use_param_num
];
2091 if (t
->kind
== TYPE_ARRAY
)
2092 nt
= create_array (nt
, t
->u
.a
.len
);
2093 else if (length
!= NULL
&& t
->kind
== TYPE_POINTER
)
2094 nt
= create_pointer (nt
);
2095 d
->needs_cast_p
= (t
->kind
!= TYPE_POINTER
2096 && (nt
->kind
== TYPE_POINTER
2097 || nt
->kind
== TYPE_STRING
));
2101 error_at_line (d
->line
, "no parameter defined for `%s'",
2106 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
2108 error_at_line (d
->line
,
2109 "field `%s' has invalid option `maybe_undef_p'\n",
2118 d
->process_field (t
, d
);
2124 && t
->u
.p
->u
.s
.line
.file
== NULL
)
2126 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2132 if (! UNION_OR_STRUCT_P (t
->u
.p
)
2133 && t
->u
.p
->kind
!= TYPE_PARAM_STRUCT
)
2135 error_at_line (d
->line
,
2136 "field `%s' is pointer to unimplemented type",
2143 const char *oldprevval2
= d
->prev_val
[2];
2145 if (! UNION_OR_STRUCT_P (nested_ptr_d
->type
))
2147 error_at_line (d
->line
,
2148 "field `%s' has invalid "
2149 "option `nested_ptr'\n",
2154 d
->prev_val
[2] = d
->val
;
2155 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2157 d
->val
= xasprintf ("x%d", d
->counter
++);
2158 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2159 (nested_ptr_d
->type
->kind
== TYPE_UNION
2160 ? "union" : "struct"),
2161 nested_ptr_d
->type
->u
.s
.tag
,
2162 d
->fn_wants_lvalue
? "" : "const ",
2164 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2165 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2167 oprintf (d
->of
, ";\n");
2169 d
->process_field (nested_ptr_d
->type
, d
);
2171 if (d
->fn_wants_lvalue
)
2173 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2175 d
->prev_val
[2] = d
->val
;
2176 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2178 oprintf (d
->of
, ";\n");
2182 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2183 d
->val
= d
->prev_val
[2];
2184 d
->prev_val
[2] = oldprevval2
;
2187 d
->process_field (t
->u
.p
, d
);
2191 int loopcounter
= d
->counter
++;
2192 const char *oldval
= d
->val
;
2193 const char *oldprevval3
= d
->prev_val
[3];
2196 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2198 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2199 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
, "",
2200 loopcounter
, loopcounter
);
2201 output_escaped_param (d
, length
, "length");
2202 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2204 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2206 d
->prev_val
[3] = oldval
;
2207 walk_type (t
->u
.p
, d
);
2210 d
->prev_val
[3] = oldprevval3
;
2213 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2214 d
->process_field(t
, d
);
2216 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2223 int loopcounter
= d
->counter
++;
2224 const char *oldval
= d
->val
;
2227 /* If it's an array of scalars, we optimize by not generating
2229 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2232 /* When walking an array, compute the length and store it in a
2233 local variable before walking the array elements, instead of
2234 recomputing the length expression each time through the loop.
2235 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2236 where the length is stored in the first array element,
2237 because otherwise that operand can get overwritten on the
2239 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2241 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2242 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2243 d
->indent
, "", loopcounter
);
2245 output_escaped_param (d
, length
, "length");
2247 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2248 oprintf (d
->of
, ");\n");
2250 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2252 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2254 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2256 walk_type (t
->u
.a
.p
, d
);
2261 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2263 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2271 const char *oldval
= d
->val
;
2272 const char *oldprevval1
= d
->prev_val
[1];
2273 const char *oldprevval2
= d
->prev_val
[2];
2274 const int union_p
= t
->kind
== TYPE_UNION
;
2275 int seen_default_p
= 0;
2278 if (! t
->u
.s
.line
.file
)
2279 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2281 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2283 error_at_line (d
->line
,
2284 "structure `%s' defined for mismatching languages",
2286 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2289 /* Some things may also be defined in the structure's options. */
2290 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2291 if (! desc
&& strcmp (o
->name
, "desc") == 0)
2294 d
->prev_val
[2] = oldval
;
2295 d
->prev_val
[1] = oldprevval2
;
2300 error_at_line (d
->line
, "missing `desc' option for union `%s'",
2304 oprintf (d
->of
, "%*sswitch (", d
->indent
, "");
2305 output_escaped_param (d
, desc
, "desc");
2306 oprintf (d
->of
, ")\n");
2308 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2310 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
2313 const char *dot
= ".";
2314 const char *tagid
= NULL
;
2317 int use_param_p
= 0;
2320 d
->reorder_fn
= NULL
;
2321 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2322 if (strcmp (oo
->name
, "dot") == 0)
2324 else if (strcmp (oo
->name
, "tag") == 0)
2326 else if (strcmp (oo
->name
, "skip") == 0)
2328 else if (strcmp (oo
->name
, "default") == 0)
2330 else if (strcmp (oo
->name
, "reorder") == 0)
2331 d
->reorder_fn
= oo
->info
;
2332 else if (strncmp (oo
->name
, "use_param", 9) == 0
2333 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2339 if (union_p
&& tagid
)
2341 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
2344 else if (union_p
&& default_p
)
2346 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2350 else if (! union_p
&& (default_p
|| tagid
))
2351 error_at_line (d
->line
,
2352 "can't use `%s' outside a union on field `%s'",
2353 default_p
? "default" : "tag", f
->name
);
2354 else if (union_p
&& ! (default_p
|| tagid
)
2355 && f
->type
->kind
== TYPE_SCALAR
)
2358 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2359 d
->line
->file
, d
->line
->line
, f
->name
);
2362 else if (union_p
&& ! (default_p
|| tagid
))
2363 error_at_line (d
->line
,
2364 "field `%s' is missing `tag' or `default' option",
2368 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
2370 d
->used_length
= false;
2372 if (union_p
&& use_param_p
&& d
->param
== NULL
)
2373 oprintf (d
->of
, "%*sgcc_unreachable ();\n", d
->indent
, "");
2375 walk_type (f
->type
, d
);
2381 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2385 d
->reorder_fn
= NULL
;
2388 d
->prev_val
[1] = oldprevval1
;
2389 d
->prev_val
[2] = oldprevval2
;
2391 if (union_p
&& ! seen_default_p
)
2393 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2394 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
2398 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2404 case TYPE_LANG_STRUCT
:
2407 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
2408 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
2411 error_at_line (d
->line
, "structure `%s' differs between languages",
2418 case TYPE_PARAM_STRUCT
:
2420 type_p
*oldparam
= d
->param
;
2422 d
->param
= t
->u
.param_struct
.param
;
2423 walk_type (t
->u
.param_struct
.stru
, d
);
2424 d
->param
= oldparam
;
2433 /* process_field routine for marking routines. */
2436 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
2438 const struct write_types_data
*wtd
;
2439 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
2440 wtd
= (const struct write_types_data
*) d
->cookie
;
2445 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
2446 wtd
->subfield_marker_routine
, cast
, d
->val
);
2447 if (wtd
->param_prefix
)
2449 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
2452 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
2453 output_mangled_typename (d
->of
, d
->orig_s
);
2456 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
2458 if (f
->u
.p
->kind
== TYPE_PARAM_STRUCT
2459 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2461 oprintf (d
->of
, ", gt_e_");
2462 output_mangled_typename (d
->of
, f
);
2464 else if (UNION_OR_STRUCT_P (f
)
2465 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2467 oprintf (d
->of
, ", gt_ggc_e_");
2468 output_mangled_typename (d
->of
, f
);
2471 oprintf (d
->of
, ", gt_types_enum_last");
2473 oprintf (d
->of
, ");\n");
2474 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2475 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
2476 wtd
->reorder_note_routine
, cast
, d
->val
,
2477 d
->prev_val
[3], d
->reorder_fn
);
2483 case TYPE_LANG_STRUCT
:
2484 case TYPE_PARAM_STRUCT
:
2485 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
2486 output_mangled_typename (d
->of
, f
);
2487 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
2488 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2489 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
2490 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
2502 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2505 output_type_enum (outf_p of
, type_p s
)
2507 if (s
->kind
== TYPE_PARAM_STRUCT
&& s
->u
.s
.line
.file
!= NULL
)
2509 oprintf (of
, ", gt_e_");
2510 output_mangled_typename (of
, s
);
2512 else if (UNION_OR_STRUCT_P (s
) && s
->u
.s
.line
.file
!= NULL
)
2514 oprintf (of
, ", gt_ggc_e_");
2515 output_mangled_typename (of
, s
);
2518 oprintf (of
, ", gt_types_enum_last");
2521 /* For S, a structure that's part of ORIG_S, and using parameters
2522 PARAM, write out a routine that:
2523 - Takes a parameter, a void * but actually of type *S
2524 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2525 field of S or its substructures and (in some cases) things
2526 that are pointed to by S.
2530 write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2531 const struct write_types_data
*wtd
)
2533 const char *fn
= s
->u
.s
.line
.file
;
2535 const char *chain_next
= NULL
;
2536 const char *chain_prev
= NULL
;
2537 const char *chain_circular
= NULL
;
2538 const char *mark_hook_name
= NULL
;
2540 struct walk_type_data d
;
2542 /* This is a hack, and not the good kind either. */
2543 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2544 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2545 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2546 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2548 memset (&d
, 0, sizeof (d
));
2549 d
.of
= get_output_file_with_visibility (fn
);
2551 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2552 if (strcmp (opt
->name
, "chain_next") == 0)
2553 chain_next
= opt
->info
;
2554 else if (strcmp (opt
->name
, "chain_prev") == 0)
2555 chain_prev
= opt
->info
;
2556 else if (strcmp (opt
->name
, "chain_circular") == 0)
2557 chain_circular
= opt
->info
;
2558 else if (strcmp (opt
->name
, "mark_hook") == 0)
2559 mark_hook_name
= opt
->info
;
2561 if (chain_prev
!= NULL
&& chain_next
== NULL
)
2562 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
2563 if (chain_circular
!= NULL
&& chain_next
!= NULL
)
2564 error_at_line (&s
->u
.s
.line
, "chain_circular with chain_next");
2565 if (chain_circular
!= NULL
)
2566 chain_next
= chain_circular
;
2568 d
.process_field
= write_types_process_field
;
2572 d
.line
= &s
->u
.s
.line
;
2573 d
.bitmap
= s
->u
.s
.bitmap
;
2575 d
.prev_val
[0] = "*x";
2576 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2577 d
.prev_val
[3] = "x";
2580 oprintf (d
.of
, "\n");
2581 oprintf (d
.of
, "void\n");
2583 oprintf (d
.of
, "gt_%sx_%s", wtd
->prefix
, orig_s
->u
.s
.tag
);
2586 oprintf (d
.of
, "gt_%s_", wtd
->prefix
);
2587 output_mangled_typename (d
.of
, orig_s
);
2589 oprintf (d
.of
, " (void *x_p)\n");
2590 oprintf (d
.of
, "{\n");
2591 oprintf (d
.of
, " %s %s * %sx = (%s %s *)x_p;\n",
2592 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2593 chain_next
== NULL
? "const " : "",
2594 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2595 if (chain_next
!= NULL
)
2596 oprintf (d
.of
, " %s %s * xlimit = x;\n",
2597 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2598 if (chain_next
== NULL
)
2600 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
2601 if (wtd
->param_prefix
)
2603 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
2604 output_mangled_typename (d
.of
, orig_s
);
2605 output_type_enum (d
.of
, orig_s
);
2607 oprintf (d
.of
, "))\n");
2611 if (chain_circular
!= NULL
)
2612 oprintf (d
.of
, " if (!%s (xlimit", wtd
->marker_routine
);
2614 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2615 if (wtd
->param_prefix
)
2617 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2618 output_mangled_typename (d
.of
, orig_s
);
2619 output_type_enum (d
.of
, orig_s
);
2621 oprintf (d
.of
, "))\n");
2622 if (chain_circular
!= NULL
)
2623 oprintf (d
.of
, " return;\n do\n");
2624 if (mark_hook_name
&& !wtd
->skip_hooks
)
2626 oprintf (d
.of
, " {\n");
2627 oprintf (d
.of
, " %s (xlimit);\n ", mark_hook_name
);
2629 oprintf (d
.of
, " xlimit = (");
2630 d
.prev_val
[2] = "*xlimit";
2631 output_escaped_param (&d
, chain_next
, "chain_next");
2632 oprintf (d
.of
, ");\n");
2633 if (mark_hook_name
&& !wtd
->skip_hooks
)
2634 oprintf (d
.of
, " }\n");
2635 if (chain_prev
!= NULL
)
2637 oprintf (d
.of
, " if (x != xlimit)\n");
2638 oprintf (d
.of
, " for (;;)\n");
2639 oprintf (d
.of
, " {\n");
2640 oprintf (d
.of
, " %s %s * const xprev = (",
2641 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2643 d
.prev_val
[2] = "*x";
2644 output_escaped_param (&d
, chain_prev
, "chain_prev");
2645 oprintf (d
.of
, ");\n");
2646 oprintf (d
.of
, " if (xprev == NULL) break;\n");
2647 oprintf (d
.of
, " x = xprev;\n");
2648 oprintf (d
.of
, " (void) %s (xprev",
2649 wtd
->marker_routine
);
2650 if (wtd
->param_prefix
)
2652 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
2653 output_mangled_typename (d
.of
, orig_s
);
2654 output_type_enum (d
.of
, orig_s
);
2656 oprintf (d
.of
, ");\n");
2657 oprintf (d
.of
, " }\n");
2659 if (chain_circular
!= NULL
)
2661 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2662 if (wtd
->param_prefix
)
2664 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2665 output_mangled_typename (d
.of
, orig_s
);
2666 output_type_enum (d
.of
, orig_s
);
2668 oprintf (d
.of
, "));\n");
2669 if (mark_hook_name
&& !wtd
->skip_hooks
)
2670 oprintf (d
.of
, " %s (xlimit);\n", mark_hook_name
);
2671 oprintf (d
.of
, " do\n");
2674 oprintf (d
.of
, " while (x != xlimit)\n");
2676 oprintf (d
.of
, " {\n");
2677 if (mark_hook_name
&& chain_next
== NULL
&& !wtd
->skip_hooks
)
2679 oprintf (d
.of
, " %s (x);\n", mark_hook_name
);
2681 d
.prev_val
[2] = "*x";
2685 if (chain_next
!= NULL
)
2687 oprintf (d
.of
, " x = (");
2688 output_escaped_param (&d
, chain_next
, "chain_next");
2689 oprintf (d
.of
, ");\n");
2692 oprintf (d
.of
, " }\n");
2693 if (chain_circular
!= NULL
)
2694 oprintf (d
.of
, " while (x != xlimit);\n");
2695 oprintf (d
.of
, "}\n");
2698 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
2701 write_types (type_p structures
, type_p param_structs
,
2702 const struct write_types_data
*wtd
)
2706 oprintf (header_file
, "\n/* %s*/\n", wtd
->comment
);
2707 for (s
= structures
; s
; s
= s
->next
)
2708 if (s
->gc_used
== GC_POINTED_TO
2709 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2713 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2714 && s
->u
.s
.line
.file
== NULL
)
2717 oprintf (header_file
, "#define gt_%s_", wtd
->prefix
);
2718 output_mangled_typename (header_file
, s
);
2719 oprintf (header_file
, "(X) do { \\\n");
2720 oprintf (header_file
,
2721 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
2723 oprintf (header_file
,
2726 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2727 if (strcmp (opt
->name
, "ptr_alias") == 0)
2729 const_type_p
const t
= (const_type_p
) opt
->info
;
2730 if (t
->kind
== TYPE_STRUCT
2731 || t
->kind
== TYPE_UNION
2732 || t
->kind
== TYPE_LANG_STRUCT
)
2733 oprintf (header_file
,
2734 "#define gt_%sx_%s gt_%sx_%s\n",
2735 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t
->u
.s
.tag
);
2737 error_at_line (&s
->u
.s
.line
,
2738 "structure alias is not a structure");
2744 /* Declare the marker procedure only once. */
2745 oprintf (header_file
,
2746 "extern void gt_%sx_%s (void *);\n",
2747 wtd
->prefix
, s
->u
.s
.tag
);
2749 if (s
->u
.s
.line
.file
== NULL
)
2751 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2756 if (s
->kind
== TYPE_LANG_STRUCT
)
2759 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2760 write_func_for_structure (s
, ss
, NULL
, wtd
);
2763 write_func_for_structure (s
, s
, NULL
, wtd
);
2766 for (s
= param_structs
; s
; s
= s
->next
)
2767 if (s
->gc_used
== GC_POINTED_TO
)
2769 type_p
* param
= s
->u
.param_struct
.param
;
2770 type_p stru
= s
->u
.param_struct
.stru
;
2772 /* Declare the marker procedure. */
2773 oprintf (header_file
, "extern void gt_%s_", wtd
->prefix
);
2774 output_mangled_typename (header_file
, s
);
2775 oprintf (header_file
, " (void *);\n");
2777 if (stru
->u
.s
.line
.file
== NULL
)
2779 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2784 if (stru
->kind
== TYPE_LANG_STRUCT
)
2787 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2788 write_func_for_structure (s
, ss
, param
, wtd
);
2791 write_func_for_structure (s
, stru
, param
, wtd
);
2795 static const struct write_types_data ggc_wtd
=
2797 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
2798 "GC marker procedures. ",
2802 static const struct write_types_data pch_wtd
=
2804 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
2805 "gt_pch_note_reorder",
2806 "PCH type-walking procedures. ",
2810 /* Write out the local pointer-walking routines. */
2812 /* process_field routine for local pointer-walking. */
2815 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
2822 case TYPE_LANG_STRUCT
:
2823 case TYPE_PARAM_STRUCT
:
2825 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
2827 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
2838 /* For S, a structure that's part of ORIG_S, and using parameters
2839 PARAM, write out a routine that:
2840 - Is of type gt_note_pointers
2841 - Calls PROCESS_FIELD on each field of S or its substructures.
2845 write_local_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
)
2847 const char *fn
= s
->u
.s
.line
.file
;
2849 struct walk_type_data d
;
2851 /* This is a hack, and not the good kind either. */
2852 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2853 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2854 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2855 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2857 memset (&d
, 0, sizeof (d
));
2858 d
.of
= get_output_file_with_visibility (fn
);
2859 d
.process_field
= write_types_local_process_field
;
2861 d
.line
= &s
->u
.s
.line
;
2862 d
.bitmap
= s
->u
.s
.bitmap
;
2864 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
2865 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2866 d
.prev_val
[3] = "x";
2868 d
.fn_wants_lvalue
= true;
2870 oprintf (d
.of
, "\n");
2871 oprintf (d
.of
, "void\n");
2872 oprintf (d
.of
, "gt_pch_p_");
2873 output_mangled_typename (d
.of
, orig_s
);
2874 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
2876 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2877 "\tATTRIBUTE_UNUSED void *cookie)\n");
2878 oprintf (d
.of
, "{\n");
2879 oprintf (d
.of
, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
2880 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2881 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2884 oprintf (d
.of
, "}\n");
2887 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
2890 write_local (type_p structures
, type_p param_structs
)
2896 oprintf (header_file
, "\n/* Local pointer-walking routines. */\n");
2897 for (s
= structures
; s
; s
= s
->next
)
2898 if (s
->gc_used
== GC_POINTED_TO
2899 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2903 if (s
->u
.s
.line
.file
== NULL
)
2906 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2907 if (strcmp (opt
->name
, "ptr_alias") == 0)
2909 const_type_p
const t
= (const_type_p
) opt
->info
;
2910 if (t
->kind
== TYPE_STRUCT
2911 || t
->kind
== TYPE_UNION
2912 || t
->kind
== TYPE_LANG_STRUCT
)
2914 oprintf (header_file
, "#define gt_pch_p_");
2915 output_mangled_typename (header_file
, s
);
2916 oprintf (header_file
, " gt_pch_p_");
2917 output_mangled_typename (header_file
, t
);
2918 oprintf (header_file
, "\n");
2921 error_at_line (&s
->u
.s
.line
,
2922 "structure alias is not a structure");
2928 /* Declare the marker procedure only once. */
2929 oprintf (header_file
, "extern void gt_pch_p_");
2930 output_mangled_typename (header_file
, s
);
2931 oprintf (header_file
,
2932 "\n (void *, void *, gt_pointer_operator, void *);\n");
2934 if (s
->kind
== TYPE_LANG_STRUCT
)
2937 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2938 write_local_func_for_structure (s
, ss
, NULL
);
2941 write_local_func_for_structure (s
, s
, NULL
);
2944 for (s
= param_structs
; s
; s
= s
->next
)
2945 if (s
->gc_used
== GC_POINTED_TO
)
2947 type_p
* param
= s
->u
.param_struct
.param
;
2948 type_p stru
= s
->u
.param_struct
.stru
;
2950 /* Declare the marker procedure. */
2951 oprintf (header_file
, "extern void gt_pch_p_");
2952 output_mangled_typename (header_file
, s
);
2953 oprintf (header_file
,
2954 "\n (void *, void *, gt_pointer_operator, void *);\n");
2956 if (stru
->u
.s
.line
.file
== NULL
)
2958 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2963 if (stru
->kind
== TYPE_LANG_STRUCT
)
2966 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2967 write_local_func_for_structure (s
, ss
, param
);
2970 write_local_func_for_structure (s
, stru
, param
);
2974 /* Write out the 'enum' definition for gt_types_enum. */
2977 write_enum_defn (type_p structures
, type_p param_structs
)
2983 oprintf (header_file
, "\n/* Enumeration of types known. */\n");
2984 oprintf (header_file
, "enum gt_types_enum {\n");
2985 for (s
= structures
; s
; s
= s
->next
)
2986 if (s
->gc_used
== GC_POINTED_TO
2987 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2989 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2990 && s
->u
.s
.line
.file
== NULL
)
2993 oprintf (header_file
, " gt_ggc_e_");
2994 output_mangled_typename (header_file
, s
);
2995 oprintf (header_file
, ", \n");
2997 for (s
= param_structs
; s
; s
= s
->next
)
2998 if (s
->gc_used
== GC_POINTED_TO
)
3000 oprintf (header_file
, " gt_e_");
3001 output_mangled_typename (header_file
, s
);
3002 oprintf (header_file
, ", \n");
3004 oprintf (header_file
, " gt_types_enum_last\n");
3005 oprintf (header_file
, "};\n");
3008 /* Might T contain any non-pointer elements? */
3011 contains_scalar_p (type_p t
)
3019 return contains_scalar_p (t
->u
.a
.p
);
3021 /* Could also check for structures that have no non-pointer
3022 fields, but there aren't enough of those to worry about. */
3027 /* Mangle FN and print it to F. */
3030 put_mangled_filename (outf_p f
, const char *fn
)
3032 const char *name
= get_output_file_name (fn
);
3035 for (; *name
!= 0; name
++)
3036 if (ISALNUM (*name
))
3037 oprintf (f
, "%c", *name
);
3039 oprintf (f
, "%c", '_');
3042 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
3043 LASTNAME, and NAME are all strings to insert in various places in
3044 the resulting code. */
3047 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
3048 const char *tname
, const char *name
)
3052 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3053 if (fli2
->started_p
)
3055 oprintf (fli2
->f
, " %s\n", lastname
);
3056 oprintf (fli2
->f
, "};\n\n");
3059 for (fli2
= flp
; fli2
&& base_files
; fli2
= fli2
->next
)
3060 if (fli2
->started_p
)
3062 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
3065 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
3068 oprintf (base_files
[fnum
],
3069 "extern const struct %s gt_%s_",
3071 put_mangled_filename (base_files
[fnum
], fli2
->name
);
3072 oprintf (base_files
[fnum
], "[];\n");
3078 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3079 oprintf (base_files
[fnum
],
3080 "EXPORTED_CONST struct %s * const %s[] = {\n",
3085 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3086 if (fli2
->started_p
)
3088 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
3091 fli2
->started_p
= 0;
3093 for (fnum
= 0; base_files
&& bitmap
!= 0; fnum
++, bitmap
>>= 1)
3096 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
3097 put_mangled_filename (base_files
[fnum
], fli2
->name
);
3098 oprintf (base_files
[fnum
], ",\n");
3104 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3106 oprintf (base_files
[fnum
], " NULL\n");
3107 oprintf (base_files
[fnum
], "};\n");
3112 /* Write out to F the table entry and any marker routines needed to
3113 mark NAME as TYPE. The original variable is V, at LINE.
3114 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
3115 is nonzero iff we are building the root table for hash table caches. */
3118 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
3119 struct fileloc
*line
, const char *if_marked
)
3126 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
3129 const char *desc
= NULL
;
3132 for (o
= fld
->opt
; o
; o
= o
->next
)
3133 if (strcmp (o
->name
, "skip") == 0)
3135 else if (strcmp (o
->name
, "desc") == 0)
3137 else if (strcmp (o
->name
, "param_is") == 0)
3140 error_at_line (line
,
3141 "field `%s' of global `%s' has unknown option `%s'",
3142 fld
->name
, name
, o
->name
);
3146 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
3148 pair_p validf
= NULL
;
3151 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
3153 const char *tag
= NULL
;
3156 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
3157 if (strcmp (oo
->name
, "tag") == 0)
3159 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
3162 error_at_line (line
,
3163 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3164 name
, fld
->name
, validf
->name
,
3165 name
, fld
->name
, ufld
->name
,
3172 newname
= xasprintf ("%s.%s.%s",
3173 name
, fld
->name
, validf
->name
);
3174 write_root (f
, v
, validf
->type
, newname
, 0, line
,
3180 error_at_line (line
,
3181 "global `%s.%s' has `desc' option but is not union",
3186 newname
= xasprintf ("%s.%s", name
, fld
->name
);
3187 write_root (f
, v
, fld
->type
, newname
, 0, line
, if_marked
);
3197 newname
= xasprintf ("%s[0]", name
);
3198 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, if_marked
);
3207 oprintf (f
, " {\n");
3208 oprintf (f
, " &%s,\n", name
);
3211 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3213 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
3214 else if (ap
== v
->type
)
3215 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
3217 oprintf (f
, " sizeof (%s", v
->name
);
3218 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3220 oprintf (f
, "),\n");
3224 if (! has_length
&& UNION_OR_STRUCT_P (tp
))
3226 oprintf (f
, " >_ggc_mx_%s,\n", tp
->u
.s
.tag
);
3227 oprintf (f
, " >_pch_nx_%s", tp
->u
.s
.tag
);
3229 else if (! has_length
&& tp
->kind
== TYPE_PARAM_STRUCT
)
3231 oprintf (f
, " >_ggc_m_");
3232 output_mangled_typename (f
, tp
);
3233 oprintf (f
, ",\n >_pch_n_");
3234 output_mangled_typename (f
, tp
);
3237 && (tp
->kind
== TYPE_POINTER
|| UNION_OR_STRUCT_P (tp
)))
3239 oprintf (f
, " >_ggc_ma_%s,\n", name
);
3240 oprintf (f
, " >_pch_na_%s", name
);
3244 error_at_line (line
,
3245 "global `%s' is pointer to unimplemented type",
3249 oprintf (f
, ",\n &%s", if_marked
);
3250 oprintf (f
, "\n },\n");
3256 oprintf (f
, " {\n");
3257 oprintf (f
, " &%s,\n", name
);
3258 oprintf (f
, " 1, \n");
3259 oprintf (f
, " sizeof (%s),\n", v
->name
);
3260 oprintf (f
, " (gt_pointer_walker) >_ggc_m_S,\n");
3261 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
3262 oprintf (f
, " },\n");
3270 error_at_line (line
,
3271 "global `%s' is unimplemented type",
3276 /* This generates a routine to walk an array. */
3279 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
3281 struct walk_type_data d
;
3284 memset (&d
, 0, sizeof (d
));
3290 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
3293 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
3295 if (wtd
->param_prefix
)
3297 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
3299 " (void *, void *, gt_pointer_operator, void *);\n");
3300 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3301 wtd
->param_prefix
, v
->name
);
3303 " ATTRIBUTE_UNUSED void *x_p,\n"
3304 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3305 " ATTRIBUTE_UNUSED void * cookie)\n");
3306 oprintf (d
.of
, "{\n");
3307 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3308 d
.process_field
= write_types_local_process_field
;
3309 walk_type (v
->type
, &d
);
3310 oprintf (f
, "}\n\n");
3314 oprintf (f
, "static void gt_%sa_%s (void *);\n",
3315 wtd
->prefix
, v
->name
);
3316 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3317 wtd
->prefix
, v
->name
);
3319 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3320 d
.process_field
= write_types_process_field
;
3321 walk_type (v
->type
, &d
);
3323 oprintf (f
, "}\n\n");
3326 /* Output a table describing the locations and types of VARIABLES. */
3329 write_roots (pair_p variables
)
3332 struct flist
*flp
= NULL
;
3334 for (v
= variables
; v
; v
= v
->next
)
3336 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3338 const char *length
= NULL
;
3339 int deletable_p
= 0;
3342 for (o
= v
->opt
; o
; o
= o
->next
)
3343 if (strcmp (o
->name
, "length") == 0)
3345 else if (strcmp (o
->name
, "deletable") == 0)
3347 else if (strcmp (o
->name
, "param_is") == 0)
3349 else if (strncmp (o
->name
, "param", 5) == 0
3350 && ISDIGIT (o
->name
[5])
3351 && strcmp (o
->name
+ 6, "_is") == 0)
3353 else if (strcmp (o
->name
, "if_marked") == 0)
3356 error_at_line (&v
->line
,
3357 "global `%s' has unknown option `%s'",
3360 for (fli
= flp
; fli
; fli
= fli
->next
)
3361 if (fli
->f
== f
&& f
)
3365 fli
= XNEW (struct flist
);
3369 fli
->name
= v
->line
.file
;
3370 gcc_assert(fli
->name
);
3373 oprintf (f
, "\n/* GC roots. */\n\n");
3378 && v
->type
->kind
== TYPE_POINTER
3379 && (v
->type
->u
.p
->kind
== TYPE_POINTER
3380 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
3382 write_array (f
, v
, &ggc_wtd
);
3383 write_array (f
, v
, &pch_wtd
);
3387 for (v
= variables
; v
; v
= v
->next
)
3389 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3395 for (o
= v
->opt
; o
; o
= o
->next
)
3396 if (strcmp (o
->name
, "length") == 0)
3398 else if (strcmp (o
->name
, "deletable") == 0
3399 || strcmp (o
->name
, "if_marked") == 0)
3405 for (fli
= flp
; fli
; fli
= fli
->next
)
3408 if (! fli
->started_p
)
3412 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3413 put_mangled_filename (f
, v
->line
.file
);
3414 oprintf (f
, "[] = {\n");
3417 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3420 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3423 for (v
= variables
; v
; v
= v
->next
)
3425 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3430 for (o
= v
->opt
; o
; o
= o
->next
)
3431 if (strcmp (o
->name
, "deletable") == 0)
3433 else if (strcmp (o
->name
, "if_marked") == 0)
3439 for (fli
= flp
; fli
; fli
= fli
->next
)
3442 if (! fli
->started_p
)
3446 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3447 put_mangled_filename (f
, v
->line
.file
);
3448 oprintf (f
, "[] = {\n");
3451 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3455 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3456 "gt_ggc_deletable_rtab");
3458 for (v
= variables
; v
; v
= v
->next
)
3460 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3462 const char *if_marked
= NULL
;
3466 for (o
= v
->opt
; o
; o
= o
->next
)
3467 if (strcmp (o
->name
, "length") == 0)
3469 else if (strcmp (o
->name
, "if_marked") == 0)
3470 if_marked
= o
->info
;
3472 if (if_marked
== NULL
)
3475 if (v
->type
->kind
!= TYPE_POINTER
3476 || v
->type
->u
.p
->kind
!= TYPE_PARAM_STRUCT
3477 || v
->type
->u
.p
->u
.param_struct
.stru
!= find_structure ("htab", 0))
3479 error_at_line (&v
->line
, "if_marked option used but not hash table");
3483 for (fli
= flp
; fli
; fli
= fli
->next
)
3486 if (! fli
->started_p
)
3490 oprintf (f
, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
3491 put_mangled_filename (f
, v
->line
.file
);
3492 oprintf (f
, "[] = {\n");
3495 write_root (f
, v
, v
->type
->u
.p
->u
.param_struct
.param
[0],
3496 v
->name
, length_p
, &v
->line
, if_marked
);
3499 finish_root_table (flp
, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
3500 "gt_ggc_cache_rtab");
3502 for (v
= variables
; v
; v
= v
->next
)
3504 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3507 int if_marked_p
= 0;
3510 for (o
= v
->opt
; o
; o
= o
->next
)
3511 if (strcmp (o
->name
, "length") == 0)
3513 else if (strcmp (o
->name
, "if_marked") == 0)
3519 for (fli
= flp
; fli
; fli
= fli
->next
)
3522 if (! fli
->started_p
)
3526 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
3527 put_mangled_filename (f
, v
->line
.file
);
3528 oprintf (f
, "[] = {\n");
3531 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3534 finish_root_table (flp
, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3535 "gt_pch_cache_rtab");
3537 for (v
= variables
; v
; v
= v
->next
)
3539 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3544 for (o
= v
->opt
; o
; o
= o
->next
)
3545 if (strcmp (o
->name
, "deletable") == 0
3546 || strcmp (o
->name
, "if_marked") == 0)
3552 if (! contains_scalar_p (v
->type
))
3555 for (fli
= flp
; fli
; fli
= fli
->next
)
3558 if (! fli
->started_p
)
3562 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
3563 put_mangled_filename (f
, v
->line
.file
);
3564 oprintf (f
, "[] = {\n");
3567 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3571 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3572 "gt_pch_scalar_rtab");
3575 /* Record the definition of a generic VEC structure, as if we had expanded
3576 the macros in vec.h:
3578 typedef struct VEC_<type>_base GTY(()) {
3581 <type> GTY((length ("%h.num"))) vec[1];
3584 where the GTY(()) tags are only present if is_scalar is _false_. */
3587 note_def_vec (const char *type_name
, bool is_scalar
, struct fileloc
*pos
)
3592 type_p len_ty
= create_scalar_type ("unsigned");
3593 const char *name
= concat ("VEC_", type_name
, "_base", (char *)0);
3597 t
= create_scalar_type (type_name
);
3602 t
= resolve_typedef (type_name
, pos
);
3603 o
= create_option (0, "length", "%h.num");
3606 /* We assemble the field list in reverse order. */
3607 fields
= create_field_at (0, create_array (t
, "1"), "vec", o
, pos
);
3608 fields
= create_field_at (fields
, len_ty
, "alloc", 0, pos
);
3609 fields
= create_field_at (fields
, len_ty
, "num", 0, pos
);
3611 do_typedef (name
, new_structure (name
, 0, pos
, fields
, 0), pos
);
3614 /* Record the definition of an allocation-specific VEC structure, as if
3615 we had expanded the macros in vec.h:
3617 typedef struct VEC_<type>_<astrat> {
3618 VEC_<type>_base base;
3619 } VEC_<type>_<astrat>;
3622 note_def_vec_alloc (const char *type
, const char *astrat
, struct fileloc
*pos
)
3624 const char *astratname
= concat ("VEC_", type
, "_", astrat
, (char *)0);
3625 const char *basename
= concat ("VEC_", type
, "_base", (char *)0);
3627 pair_p field
= create_field_at (0, resolve_typedef (basename
, pos
),
3630 do_typedef (astratname
, new_structure (astratname
, 0, pos
, field
, 0), pos
);
3635 main (int argc
, char **argv
)
3638 static struct fileloc pos
= { this_file
, 0 };
3639 char* inputlist
= 0;
3640 /* fatal uses this */
3641 progname
= "gengtype";
3643 if (argc
>= 5 && !strcmp (argv
[1], "-p"))
3646 inputlist
= argv
[3];
3647 plugin_files
= argv
+4;
3648 nb_plugin_files
= argc
-4;
3653 inputlist
= argv
[2];
3656 fatal ("usage: gengtype [-p] srcdir input-list [file1 file2 ... fileN]");
3658 srcdir_len
= strlen (srcdir
);
3660 read_input_list (inputlist
);
3664 scalar_char
.u
.scalar_is_char
= true;
3665 scalar_nonchar
.u
.scalar_is_char
= false;
3668 /* These types are set up with #define or else outside of where
3670 pos
.line
= __LINE__
+ 1;
3671 do_scalar_typedef ("CUMULATIVE_ARGS", &pos
); pos
.line
++;
3672 do_scalar_typedef ("REAL_VALUE_TYPE", &pos
); pos
.line
++;
3673 do_scalar_typedef ("FIXED_VALUE_TYPE", &pos
); pos
.line
++;
3674 do_scalar_typedef ("double_int", &pos
); pos
.line
++;
3675 do_scalar_typedef ("uint64_t", &pos
); pos
.line
++;
3676 do_scalar_typedef ("uint8", &pos
); pos
.line
++;
3677 do_scalar_typedef ("jword", &pos
); pos
.line
++;
3678 do_scalar_typedef ("JCF_u2", &pos
); pos
.line
++;
3679 do_scalar_typedef ("void", &pos
); pos
.line
++;
3680 do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos
)), &pos
);
3682 for (i
= 0; i
< num_gt_files
; i
++)
3683 parse_file (gt_files
[i
]);
3688 set_gc_used (variables
);
3691 write_enum_defn (structures
, param_structs
);
3692 write_types (structures
, param_structs
, &ggc_wtd
);
3693 write_types (structures
, param_structs
, &pch_wtd
);
3694 write_local (structures
, param_structs
);
3695 write_roots (variables
);
3697 close_output_files ();