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
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. */
137 static void oprintf (outf_p o
, const char *S
, ...)
140 /* The list of output files. */
141 static outf_p output_files
;
143 /* The output header file that is included into pretty much every
145 static outf_p header_file
;
147 /* Source directory. */
148 static const char *srcdir
;
150 /* Length of srcdir name. */
151 static size_t srcdir_len
= 0;
153 static outf_p
create_file (const char *, const char *);
155 static const char * get_file_basename (const char *);
156 static const char * get_file_realbasename (const char *);
157 static const char * get_file_srcdir_relative_path (const char *);
159 static int get_prefix_langdir_index (const char *);
160 static const char * get_file_langdir (const char *);
163 /* Nonzero iff an error has occurred. */
164 bool hit_error
= false;
166 static void gen_rtx_next (void);
167 static void write_rtx_next (void);
168 static void open_base_files (void);
169 static void close_output_files (void);
171 /* Report an error at POS, printing MSG. */
174 error_at_line (struct fileloc
*pos
, const char *msg
, ...)
180 fprintf (stderr
, "%s:%d: ", pos
->file
, pos
->line
);
181 vfprintf (stderr
, msg
, ap
);
182 fputc ('\n', stderr
);
188 /* asprintf, but produces fatal message on out-of-memory. */
190 xasprintf (const char *format
, ...)
196 va_start (ap
, format
);
197 n
= vasprintf (&result
, format
, ap
);
198 if (result
== NULL
|| n
< 0)
199 fatal ("out of memory");
205 /* Input file handling. */
207 /* Table of all input files. */
208 static const char **gt_files
;
209 static size_t num_gt_files
;
211 /* A number of places use the name of this file for a location for
212 things that we can't rely on the source to define. Make sure we
213 can still use pointer comparison on filenames. */
214 static const char this_file
[] = __FILE__
;
216 /* Vector of per-language directories. */
217 static const char **lang_dir_names
;
218 static size_t num_lang_dirs
;
220 /* An array of output files suitable for definitions. There is one
221 BASE_FILES entry for each language. */
222 static outf_p
*base_files
;
224 /* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
225 INPUT_FILE is used by <lang>.
227 This function should be written to assume that a file _is_ used
228 if the situation is unclear. If it wrongly assumes a file _is_ used,
229 a linker error will result. If it wrongly assumes a file _is not_ used,
230 some GC roots may be missed, which is a much harder-to-debug problem.
232 The relevant bitmap is stored immediately before the file's name in the
233 buffer set up by read_input_list. It may be unaligned, so we have to
234 read it byte-by-byte. */
237 get_lang_bitmap (const char *gtfile
)
240 if (gtfile
== this_file
)
241 /* Things defined in this file are universal. */
242 return (((lang_bitmap
)1) << num_lang_dirs
) - 1;
247 for (i
= -(int) sizeof (lang_bitmap
); i
< 0; i
++)
248 n
= (n
<< CHAR_BIT
) + (unsigned char)gtfile
[i
];
253 /* Set the bitmap returned by get_lang_bitmap. The only legitimate
254 caller of this function is read_input_list. */
256 set_lang_bitmap (char *gtfile
, lang_bitmap n
)
259 for (i
= -1; i
>= -(int) sizeof (lang_bitmap
); i
--)
261 gtfile
[i
] = n
& ((1U << CHAR_BIT
)-1);
266 /* Scan the input file, LIST, and determine how much space we need to
267 store strings in. Also, count the number of language directories
268 and files. The numbers returned are overestimates as they does not
269 consider repeated files. */
271 measure_input_list (FILE *list
)
278 while ((c
= getc (list
)) != EOF
)
287 /* Add space for a lang_bitmap before the input file name. */
288 n
+= sizeof (lang_bitmap
);
302 /* Read one input line from LIST to HEREP (which is updated). A
303 pointer to the string is returned via LINEP. If it was a language
304 subdirectory in square brackets, strip off the square brackets and
305 return true. Otherwise, leave space before the string for a
306 lang_bitmap, and return false. At EOF, returns false, does not
307 touch *HEREP, and sets *LINEP to NULL. POS is used for
310 read_input_line (FILE *list
, char **herep
, char **linep
,
317 /* Read over whitespace. */
318 while (c
== '\n' || c
== ' ')
328 /* No space for a lang_bitmap is necessary. Discard the '['. */
331 while (c
!= ']' && c
!= '\n' && c
!= EOF
)
340 c
= getc (list
); /* eat what should be a newline */
341 if (c
!= '\n' && c
!= EOF
)
342 error_at_line (pos
, "junk on line after language tag [%s]", line
);
345 error_at_line (pos
, "missing close bracket for language tag [%s", line
);
353 /* Leave space for a lang_bitmap. */
354 memset (here
, 0, sizeof (lang_bitmap
));
355 here
+= sizeof (lang_bitmap
);
362 while (c
!= EOF
&& c
!= '\n');
370 /* Read the list of input files from LIST and compute all of the
371 relevant tables. There is one file per line of the list. At
372 first, all the files on the list are language-generic, but
373 eventually a line will appear which is the name of a language
374 subdirectory in square brackets, like this: [cp]. All subsequent
375 files are specific to that language, until another language
376 subdirectory tag appears. Files can appear more than once, if
377 they apply to more than one language. */
379 read_input_list (const char *listname
)
381 FILE *list
= fopen (listname
, "r");
383 fatal ("cannot open %s: %s", listname
, strerror (errno
));
387 size_t bufsz
= measure_input_list (list
);
388 char *buf
= XNEWVEC (char, bufsz
);
390 char *committed
= buf
;
391 char *limit
= buf
+ bufsz
;
396 lang_bitmap curlangs
= (1 << num_lang_dirs
) - 1;
398 epos
.file
= listname
;
401 lang_dir_names
= XNEWVEC (const char *, num_lang_dirs
);
402 gt_files
= XNEWVEC (const char *, num_gt_files
);
409 is_language
= read_input_line (list
, &here
, &line
, &epos
);
410 gcc_assert (here
<= limit
);
413 else if (is_language
)
416 gcc_assert (langno
<= num_lang_dirs
);
417 for (i
= 0; i
< langno
; i
++)
418 if (strcmp (lang_dir_names
[i
], line
) == 0)
420 error_at_line (&epos
, "duplicate language tag [%s]", line
);
426 curlangs
= 1 << langno
;
427 lang_dir_names
[langno
++] = line
;
432 gcc_assert (nfiles
<= num_gt_files
);
433 for (i
= 0; i
< nfiles
; i
++)
434 if (strcmp (gt_files
[i
], line
) == 0)
436 /* Throw away the string we just read, and add the
437 current language to the existing string's bitmap. */
438 lang_bitmap bmap
= get_lang_bitmap (gt_files
[i
]);
440 error_at_line (&epos
, "file %s specified more than once "
441 "for language %s", line
, langno
== 0
443 : lang_dir_names
[langno
- 1]);
446 set_lang_bitmap (CONST_CAST(char *, gt_files
[i
]), bmap
);
451 set_lang_bitmap (line
, curlangs
);
452 gt_files
[nfiles
++] = line
;
455 /* Update the global counts now that we know accurately how many
456 things there are. (We do not bother resizing the arrays down.) */
457 num_lang_dirs
= langno
;
458 num_gt_files
= nfiles
;
461 /* Sanity check: any file that resides in a language subdirectory
462 (e.g. 'cp') ought to belong to the corresponding language.
463 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
464 (Can you even do that? Should you be allowed to?) */
467 for (f
= 0; f
< num_gt_files
; f
++)
469 lang_bitmap bitmap
= get_lang_bitmap (gt_files
[f
]);
470 const char *basename
= get_file_basename (gt_files
[f
]);
471 const char *slashpos
= strchr (basename
, '/');
476 for (l
= 0; l
< num_lang_dirs
; l
++)
477 if ((size_t)(slashpos
- basename
) == strlen (lang_dir_names
[l
])
478 && memcmp (basename
, lang_dir_names
[l
],
479 strlen (lang_dir_names
[l
])) == 0)
481 if (!(bitmap
& (1 << l
)))
482 error ("%s is in language directory '%s' but is not "
483 "tagged for that language",
484 basename
, lang_dir_names
[l
]);
492 fatal ("error reading %s: %s", listname
, strerror (errno
));
499 /* The one and only TYPE_STRING. */
501 static struct type string_type
= {
502 TYPE_STRING
, 0, 0, GC_USED
, {0}
505 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
506 set to appropriate values at the beginning of main. */
508 static struct type scalar_nonchar
= {
509 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
511 static struct type scalar_char
= {
512 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
515 /* Lists of various things. */
517 static pair_p typedefs
;
518 static type_p structures
;
519 static type_p param_structs
;
520 static pair_p variables
;
522 static type_p find_param_structure
523 (type_p t
, type_p param
[NUM_PARAM
]);
524 static type_p
adjust_field_tree_exp (type_p t
, options_p opt
);
525 static type_p
adjust_field_rtx_def (type_p t
, options_p opt
);
527 /* Define S as a typedef to T at POS. */
530 do_typedef (const char *s
, type_p t
, struct fileloc
*pos
)
534 /* temporary kludge - gengtype doesn't handle conditionals or
535 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
536 is coming from this file (main() sets them up with safe dummy
538 if (!strcmp (s
, "CUMULATIVE_ARGS") && pos
->file
!= this_file
)
541 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
542 if (strcmp (p
->name
, s
) == 0)
546 error_at_line (pos
, "type `%s' previously defined", s
);
547 error_at_line (&p
->line
, "previously defined here");
552 p
= XNEW (struct pair
);
560 /* Define S as a typename of a scalar. Cannot be used to define
561 typedefs of 'char'. Note: is also used for pointer-to-function
562 typedefs (which are therefore not treated as pointers). */
565 do_scalar_typedef (const char *s
, struct fileloc
*pos
)
567 do_typedef (s
, &scalar_nonchar
, pos
);
570 /* Return the type previously defined for S. Use POS to report errors. */
573 resolve_typedef (const char *s
, struct fileloc
*pos
)
576 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
577 if (strcmp (p
->name
, s
) == 0)
579 error_at_line (pos
, "unidentified type `%s'", s
);
580 return &scalar_nonchar
; /* treat as "int" */
583 /* Create and return a new structure with tag NAME (or a union iff
584 ISUNION is nonzero), at POS with fields FIELDS and options O. */
587 new_structure (const char *name
, int isunion
, struct fileloc
*pos
,
588 pair_p fields
, options_p o
)
592 lang_bitmap bitmap
= get_lang_bitmap (pos
->file
);
594 /* temporary kludge - gengtype doesn't handle conditionals or
595 macros. Ignore any attempt to define struct location_s, unless
596 it is coming from this file (main() sets it up safely). */
597 if (!strcmp (name
, "location_s") && !isunion
598 && pos
->file
!= this_file
)
599 return find_structure (name
, 0);
601 for (si
= structures
; si
!= NULL
; si
= si
->next
)
602 if (strcmp (name
, si
->u
.s
.tag
) == 0
603 && UNION_P (si
) == isunion
)
606 if (si
->kind
== TYPE_LANG_STRUCT
)
610 for (si
= ls
->u
.s
.lang_struct
; si
!= NULL
; si
= si
->next
)
611 if (si
->u
.s
.bitmap
== bitmap
)
614 else if (si
->u
.s
.line
.file
!= NULL
&& si
->u
.s
.bitmap
!= bitmap
)
617 si
= XCNEW (struct type
);
618 memcpy (si
, ls
, sizeof (struct type
));
619 ls
->kind
= TYPE_LANG_STRUCT
;
620 ls
->u
.s
.lang_struct
= si
;
621 ls
->u
.s
.fields
= NULL
;
623 si
->pointer_to
= NULL
;
624 si
->u
.s
.lang_struct
= ls
;
629 if (ls
!= NULL
&& s
== NULL
)
631 s
= XCNEW (struct type
);
632 s
->next
= ls
->u
.s
.lang_struct
;
633 ls
->u
.s
.lang_struct
= s
;
634 s
->u
.s
.lang_struct
= ls
;
641 s
= XCNEW (struct type
);
642 s
->next
= structures
;
646 if (s
->u
.s
.line
.file
!= NULL
647 || (s
->u
.s
.lang_struct
&& (s
->u
.s
.lang_struct
->u
.s
.bitmap
& bitmap
)))
649 error_at_line (pos
, "duplicate definition of '%s %s'",
650 isunion
? "union" : "struct", s
->u
.s
.tag
);
651 error_at_line (&s
->u
.s
.line
, "previous definition here");
654 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
657 s
->u
.s
.fields
= fields
;
659 s
->u
.s
.bitmap
= bitmap
;
660 if (s
->u
.s
.lang_struct
)
661 s
->u
.s
.lang_struct
->u
.s
.bitmap
|= bitmap
;
663 /* Reset location_s's location to input.h so that we know where to
664 write out its mark routine. */
665 if (!strcmp (name
, "location_s") && !isunion
666 && pos
->file
== this_file
)
669 for (n
= 0; n
< num_gt_files
; n
++)
670 if (!strcmp (gt_files
[n
] + strlen (gt_files
[n
]) - strlen ("input.h"),
673 s
->u
.s
.line
.file
= gt_files
[n
];
681 /* Return the previously-defined structure with tag NAME (or a union
682 iff ISUNION is nonzero), or a new empty structure or union if none
683 was defined previously. */
686 find_structure (const char *name
, int isunion
)
690 for (s
= structures
; s
!= NULL
; s
= s
->next
)
691 if (strcmp (name
, s
->u
.s
.tag
) == 0
692 && UNION_P (s
) == isunion
)
695 s
= XCNEW (struct type
);
696 s
->next
= structures
;
698 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
704 /* Return the previously-defined parameterized structure for structure
705 T and parameters PARAM, or a new parameterized empty structure or
706 union if none was defined previously. */
709 find_param_structure (type_p t
, type_p param
[NUM_PARAM
])
713 for (res
= param_structs
; res
; res
= res
->next
)
714 if (res
->u
.param_struct
.stru
== t
715 && memcmp (res
->u
.param_struct
.param
, param
,
716 sizeof (type_p
) * NUM_PARAM
) == 0)
720 res
= XCNEW (struct type
);
721 res
->kind
= TYPE_PARAM_STRUCT
;
722 res
->next
= param_structs
;
724 res
->u
.param_struct
.stru
= t
;
725 memcpy (res
->u
.param_struct
.param
, param
, sizeof (type_p
) * NUM_PARAM
);
730 /* Return a scalar type with name NAME. */
733 create_scalar_type (const char *name
)
735 if (!strcmp (name
, "char") || !strcmp (name
, "unsigned char"))
738 return &scalar_nonchar
;
741 /* Return a pointer to T. */
744 create_pointer (type_p t
)
748 type_p r
= XCNEW (struct type
);
749 r
->kind
= TYPE_POINTER
;
753 return t
->pointer_to
;
756 /* Return an array of length LEN. */
759 create_array (type_p t
, const char *len
)
763 v
= XCNEW (struct type
);
764 v
->kind
= TYPE_ARRAY
;
770 /* Return an options structure with name NAME and info INFO. NEXT is the
771 next option in the chain. */
774 create_option (options_p next
, const char *name
, const void *info
)
776 options_p o
= XNEW (struct options
);
779 o
->info
= (const char*) info
;
783 /* Return an options structure for a "nested_ptr" option. */
785 create_nested_ptr_option (options_p next
, type_p t
,
786 const char *to
, const char *from
)
788 struct nested_ptr_data
*d
= XNEW (struct nested_ptr_data
);
790 d
->type
= adjust_field_type (t
, 0);
792 d
->convert_from
= from
;
793 return create_option (next
, "nested_ptr", d
);
796 /* Add a variable named S of type T with options O defined at POS,
800 note_variable (const char *s
, type_p t
, options_p o
, struct fileloc
*pos
)
803 n
= XNEW (struct pair
);
812 /* Most-general structure field creator. */
814 create_field_all (pair_p next
, type_p type
, const char *name
, options_p opt
,
815 const char *file
, int line
)
819 field
= XNEW (struct pair
);
824 field
->line
.file
= file
;
825 field
->line
.line
= line
;
829 /* Create a field that came from the source code we are scanning,
830 i.e. we have a 'struct fileloc', and possibly options; also,
831 adjust_field_type should be called. */
833 create_field_at (pair_p next
, type_p type
, const char *name
, options_p opt
,
836 return create_field_all (next
, adjust_field_type (type
, opt
),
837 name
, opt
, pos
->file
, pos
->line
);
840 /* Create a fake field with the given type and name. NEXT is the next
841 field in the chain. */
842 #define create_field(next,type,name) \
843 create_field_all(next,type,name, 0, this_file, __LINE__)
845 /* Like create_field, but the field is only valid when condition COND
849 create_optional_field_ (pair_p next
, type_p type
, const char *name
,
850 const char *cond
, int line
)
856 /* Create a fake union type with a single nameless field of type TYPE.
857 The field has a tag of "1". This allows us to make the presence
858 of a field of type TYPE depend on some boolean "desc" being true. */
859 union_fields
= create_field (NULL
, type
, "");
860 union_fields
->opt
= create_option (union_fields
->opt
, "dot", "");
861 union_fields
->opt
= create_option (union_fields
->opt
, "tag", "1");
862 union_type
= new_structure (xasprintf ("%s_%d", "fake_union", id
++), 1,
863 &lexer_line
, union_fields
, NULL
);
865 /* Create the field and give it the new fake union type. Add a "desc"
866 tag that specifies the condition under which the field is valid. */
867 return create_field_all (next
, union_type
, name
,
868 create_option (0, "desc", cond
),
871 #define create_optional_field(next,type,name,cond) \
872 create_optional_field_(next,type,name,cond,__LINE__)
874 /* Reverse a linked list of 'struct pair's in place. */
876 nreverse_pairs (pair_p list
)
878 pair_p prev
= 0, p
, next
;
879 for (p
= list
; p
; p
= next
)
889 /* We don't care how long a CONST_DOUBLE is. */
890 #define CONST_DOUBLE_FORMAT "ww"
891 /* We don't want to see codes that are only for generator files. */
892 #undef GENERATOR_FILE
895 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
901 static const char * const rtx_name
[NUM_RTX_CODE
] = {
902 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
907 static const char * const rtx_format
[NUM_RTX_CODE
] = {
908 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
913 static int rtx_next_new
[NUM_RTX_CODE
];
915 /* We also need codes and names for insn notes (not register notes).
916 Note that we do *not* bias the note values here. */
918 #define DEF_INSN_NOTE(NAME) NAME,
919 #include "insn-notes.def"
925 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
926 default field for line number notes. */
927 static const char *const note_insn_name
[NOTE_INSN_MAX
+1] = {
928 #define DEF_INSN_NOTE(NAME) #NAME,
929 #include "insn-notes.def"
933 #undef CONST_DOUBLE_FORMAT
934 #define GENERATOR_FILE
936 /* Generate the contents of the rtx_next array. This really doesn't belong
937 in gengtype at all, but it's needed for adjust_field_rtx_def. */
943 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
947 rtx_next_new
[i
] = -1;
948 if (strncmp (rtx_format
[i
], "iuu", 3) == 0)
950 else if (i
== COND_EXEC
|| i
== SET
|| i
== EXPR_LIST
|| i
== INSN_LIST
)
953 for (k
= strlen (rtx_format
[i
]) - 1; k
>= 0; k
--)
954 if (rtx_format
[i
][k
] == 'e' || rtx_format
[i
][k
] == 'u')
959 /* Write out the contents of the rtx_next array. */
961 write_rtx_next (void)
963 outf_p f
= get_output_file_with_visibility (NULL
);
966 oprintf (f
, "\n/* Used to implement the RTX_NEXT macro. */\n");
967 oprintf (f
, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
968 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
969 if (rtx_next_new
[i
] == -1)
970 oprintf (f
, " 0,\n");
973 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n",
978 /* Handle `special("rtx_def")'. This is a special case for field
979 `fld' of struct rtx_def, which is an array of unions whose values
980 are based in a complex way on the type of RTL. */
983 adjust_field_rtx_def (type_p t
, options_p
ARG_UNUSED (opt
))
988 type_p rtx_tp
, rtvec_tp
, tree_tp
, mem_attrs_tp
, note_union_tp
, scalar_tp
;
989 type_p bitmap_tp
, basic_block_tp
, reg_attrs_tp
, constant_tp
, symbol_union_tp
;
991 if (t
->kind
!= TYPE_UNION
)
993 error_at_line (&lexer_line
,
994 "special `rtx_def' must be applied to a union");
998 nodot
= create_option (NULL
, "dot", "");
1000 rtx_tp
= create_pointer (find_structure ("rtx_def", 0));
1001 rtvec_tp
= create_pointer (find_structure ("rtvec_def", 0));
1002 tree_tp
= create_pointer (find_structure ("tree_node", 1));
1003 mem_attrs_tp
= create_pointer (find_structure ("mem_attrs", 0));
1004 reg_attrs_tp
= create_pointer (find_structure ("reg_attrs", 0));
1005 bitmap_tp
= create_pointer (find_structure ("bitmap_element_def", 0));
1006 basic_block_tp
= create_pointer (find_structure ("basic_block_def", 0));
1007 constant_tp
= create_pointer (find_structure ("constant_descriptor_rtx", 0));
1008 scalar_tp
= &scalar_nonchar
; /* rtunion int */
1011 pair_p note_flds
= NULL
;
1014 for (c
= 0; c
<= NOTE_INSN_MAX
; c
++)
1019 case NOTE_INSN_DELETED_LABEL
:
1020 note_flds
= create_field (note_flds
, &string_type
, "rt_str");
1023 case NOTE_INSN_BLOCK_BEG
:
1024 case NOTE_INSN_BLOCK_END
:
1025 note_flds
= create_field (note_flds
, tree_tp
, "rt_tree");
1028 case NOTE_INSN_VAR_LOCATION
:
1029 note_flds
= create_field (note_flds
, rtx_tp
, "rt_rtx");
1033 note_flds
= create_field (note_flds
, scalar_tp
, "rt_int");
1036 /* NOTE_INSN_MAX is used as the default field for line
1038 if (c
== NOTE_INSN_MAX
)
1039 note_flds
->opt
= create_option (nodot
, "default", "");
1041 note_flds
->opt
= create_option (nodot
, "tag", note_insn_name
[c
]);
1043 note_union_tp
= new_structure ("rtx_def_note_subunion", 1,
1044 &lexer_line
, note_flds
, NULL
);
1046 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1050 sym_flds
= create_field (NULL
, tree_tp
, "rt_tree");
1051 sym_flds
->opt
= create_option (nodot
, "default", "");
1053 sym_flds
= create_field (sym_flds
, constant_tp
, "rt_constant");
1054 sym_flds
->opt
= create_option (nodot
, "tag", "1");
1056 symbol_union_tp
= new_structure ("rtx_def_symbol_subunion", 1,
1057 &lexer_line
, sym_flds
, NULL
);
1059 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1061 pair_p subfields
= NULL
;
1062 size_t aindex
, nmindex
;
1067 for (aindex
= 0; aindex
< strlen (rtx_format
[i
]); aindex
++)
1070 const char *subname
;
1072 switch (rtx_format
[i
][aindex
])
1083 if (i
== MEM
&& aindex
== 1)
1084 t
= mem_attrs_tp
, subname
= "rt_mem";
1085 else if (i
== JUMP_INSN
&& aindex
== 8)
1086 t
= rtx_tp
, subname
= "rt_rtx";
1087 else if (i
== CODE_LABEL
&& aindex
== 4)
1088 t
= scalar_tp
, subname
= "rt_int";
1089 else if (i
== CODE_LABEL
&& aindex
== 5)
1090 t
= rtx_tp
, subname
= "rt_rtx";
1091 else if (i
== LABEL_REF
1092 && (aindex
== 1 || aindex
== 2))
1093 t
= rtx_tp
, subname
= "rt_rtx";
1094 else if (i
== NOTE
&& aindex
== 4)
1095 t
= note_union_tp
, subname
= "";
1096 else if (i
== NOTE
&& aindex
== 5)
1097 t
= scalar_tp
, subname
= "rt_int";
1098 else if (i
== NOTE
&& aindex
>= 7)
1099 t
= scalar_tp
, subname
= "rt_int";
1100 else if (i
== ADDR_DIFF_VEC
&& aindex
== 4)
1101 t
= scalar_tp
, subname
= "rt_int";
1102 else if (i
== VALUE
&& aindex
== 0)
1103 t
= scalar_tp
, subname
= "rt_int";
1104 else if (i
== REG
&& aindex
== 1)
1105 t
= scalar_tp
, subname
= "rt_int";
1106 else if (i
== REG
&& aindex
== 2)
1107 t
= reg_attrs_tp
, subname
= "rt_reg";
1108 else if (i
== SCRATCH
&& aindex
== 0)
1109 t
= scalar_tp
, subname
= "rt_int";
1110 else if (i
== SYMBOL_REF
&& aindex
== 1)
1111 t
= scalar_tp
, subname
= "rt_int";
1112 else if (i
== SYMBOL_REF
&& aindex
== 2)
1113 t
= symbol_union_tp
, subname
= "";
1114 else if (i
== BARRIER
&& aindex
>= 3)
1115 t
= scalar_tp
, subname
= "rt_int";
1118 error_at_line (&lexer_line
,
1119 "rtx type `%s' has `0' in position %lu, can't handle",
1120 rtx_name
[i
], (unsigned long) aindex
);
1142 subname
= "rt_rtvec";
1147 subname
= "rt_tree";
1161 error_at_line (&lexer_line
,
1162 "rtx type `%s' has `%c' in position %lu, can't handle",
1163 rtx_name
[i
], rtx_format
[i
][aindex
],
1164 (unsigned long)aindex
);
1170 subfields
= create_field (subfields
, t
,
1171 xasprintf (".fld[%lu].%s",
1172 (unsigned long) aindex
,
1174 subfields
->opt
= nodot
;
1175 if (t
== note_union_tp
)
1176 subfields
->opt
= create_option (subfields
->opt
, "desc",
1178 if (t
== symbol_union_tp
)
1179 subfields
->opt
= create_option (subfields
->opt
, "desc",
1180 "CONSTANT_POOL_ADDRESS_P (&%0)");
1183 if (i
== SYMBOL_REF
)
1185 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds. */
1186 type_p field_tp
= find_structure ("block_symbol", 0);
1188 = create_optional_field (subfields
, field_tp
, "block_sym",
1189 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1192 sname
= xasprintf ("rtx_def_%s", rtx_name
[i
]);
1193 substruct
= new_structure (sname
, 0, &lexer_line
, subfields
, NULL
);
1195 ftag
= xstrdup (rtx_name
[i
]);
1196 for (nmindex
= 0; nmindex
< strlen (ftag
); nmindex
++)
1197 ftag
[nmindex
] = TOUPPER (ftag
[nmindex
]);
1199 flds
= create_field (flds
, substruct
, "");
1200 flds
->opt
= create_option (nodot
, "tag", ftag
);
1203 return new_structure ("rtx_def_subunion", 1, &lexer_line
, flds
, nodot
);
1206 /* Handle `special("tree_exp")'. This is a special case for
1207 field `operands' of struct tree_exp, which although it claims to contain
1208 pointers to trees, actually sometimes contains pointers to RTL too.
1209 Passed T, the old type of the field, and OPT its options. Returns
1210 a new type for the field. */
1213 adjust_field_tree_exp (type_p t
, options_p opt ATTRIBUTE_UNUSED
)
1218 if (t
->kind
!= TYPE_ARRAY
)
1220 error_at_line (&lexer_line
,
1221 "special `tree_exp' must be applied to an array");
1222 return &string_type
;
1225 nodot
= create_option (NULL
, "dot", "");
1227 flds
= create_field (NULL
, t
, "");
1228 flds
->opt
= create_option (nodot
, "length",
1229 "TREE_OPERAND_LENGTH ((tree) &%0)");
1230 flds
->opt
= create_option (flds
->opt
, "default", "");
1232 return new_structure ("tree_exp_subunion", 1, &lexer_line
, flds
, nodot
);
1235 /* Perform any special processing on a type T, about to become the type
1236 of a field. Return the appropriate type for the field.
1238 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1239 - Similarly for arrays of pointer-to-char;
1240 - Converts structures for which a parameter is provided to
1242 - Handles "special" options.
1246 adjust_field_type (type_p t
, options_p opt
)
1249 const int pointer_p
= t
->kind
== TYPE_POINTER
;
1250 type_p params
[NUM_PARAM
];
1254 for (i
= 0; i
< NUM_PARAM
; i
++)
1257 for (; opt
; opt
= opt
->next
)
1258 if (strcmp (opt
->name
, "length") == 0)
1260 else if (strcmp (opt
->name
, "param_is") == 0
1261 || (strncmp (opt
->name
, "param", 5) == 0
1262 && ISDIGIT (opt
->name
[5])
1263 && strcmp (opt
->name
+ 6, "_is") == 0))
1265 int num
= ISDIGIT (opt
->name
[5]) ? opt
->name
[5] - '0' : 0;
1267 if (! UNION_OR_STRUCT_P (t
)
1268 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
1270 error_at_line (&lexer_line
,
1271 "option `%s' may only be applied to structures or structure pointers",
1277 if (params
[num
] != NULL
)
1278 error_at_line (&lexer_line
, "duplicate `%s' option", opt
->name
);
1279 if (! ISDIGIT (opt
->name
[5]))
1280 params
[num
] = create_pointer (CONST_CAST2(type_p
, const char *, opt
->info
));
1282 params
[num
] = CONST_CAST2 (type_p
, const char *, opt
->info
);
1284 else if (strcmp (opt
->name
, "special") == 0)
1286 const char *special_name
= opt
->info
;
1287 if (strcmp (special_name
, "tree_exp") == 0)
1288 t
= adjust_field_tree_exp (t
, opt
);
1289 else if (strcmp (special_name
, "rtx_def") == 0)
1290 t
= adjust_field_rtx_def (t
, opt
);
1292 error_at_line (&lexer_line
, "unknown special `%s'", special_name
);
1301 realt
= find_param_structure (t
, params
);
1302 t
= pointer_p
? create_pointer (realt
) : realt
;
1307 && t
->u
.p
->kind
== TYPE_SCALAR
1308 && t
->u
.p
->u
.scalar_is_char
)
1309 return &string_type
;
1310 if (t
->kind
== TYPE_ARRAY
&& t
->u
.a
.p
->kind
== TYPE_POINTER
1311 && t
->u
.a
.p
->u
.p
->kind
== TYPE_SCALAR
1312 && t
->u
.a
.p
->u
.p
->u
.scalar_is_char
)
1313 return create_array (&string_type
, t
->u
.a
.len
);
1319 static void set_gc_used_type (type_p
, enum gc_used_enum
, type_p
*);
1320 static void set_gc_used (pair_p
);
1322 /* Handle OPT for set_gc_used_type. */
1325 process_gc_options (options_p opt
, enum gc_used_enum level
, int *maybe_undef
,
1326 int *pass_param
, int *length
, int *skip
, type_p
*nested_ptr
)
1329 for (o
= opt
; o
; o
= o
->next
)
1330 if (strcmp (o
->name
, "ptr_alias") == 0 && level
== GC_POINTED_TO
)
1331 set_gc_used_type (CONST_CAST2 (type_p
, const char *, o
->info
),
1332 GC_POINTED_TO
, NULL
);
1333 else if (strcmp (o
->name
, "maybe_undef") == 0)
1335 else if (strcmp (o
->name
, "use_params") == 0)
1337 else if (strcmp (o
->name
, "length") == 0)
1339 else if (strcmp (o
->name
, "skip") == 0)
1341 else if (strcmp (o
->name
, "nested_ptr") == 0)
1342 *nested_ptr
= ((const struct nested_ptr_data
*) o
->info
)->type
;
1345 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1348 set_gc_used_type (type_p t
, enum gc_used_enum level
, type_p param
[NUM_PARAM
])
1350 if (t
->gc_used
>= level
)
1364 process_gc_options (t
->u
.s
.opt
, level
, &dummy
, &dummy
, &dummy
, &dummy
,
1367 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
1369 int maybe_undef
= 0;
1373 type_p nested_ptr
= NULL
;
1374 process_gc_options (f
->opt
, level
, &maybe_undef
, &pass_param
,
1375 &length
, &skip
, &nested_ptr
);
1377 if (nested_ptr
&& f
->type
->kind
== TYPE_POINTER
)
1378 set_gc_used_type (nested_ptr
, GC_POINTED_TO
,
1379 pass_param
? param
: NULL
);
1380 else if (length
&& f
->type
->kind
== TYPE_POINTER
)
1381 set_gc_used_type (f
->type
->u
.p
, GC_USED
, NULL
);
1382 else if (maybe_undef
&& f
->type
->kind
== TYPE_POINTER
)
1383 set_gc_used_type (f
->type
->u
.p
, GC_MAYBE_POINTED_TO
, NULL
);
1384 else if (pass_param
&& f
->type
->kind
== TYPE_POINTER
&& param
)
1385 set_gc_used_type (find_param_structure (f
->type
->u
.p
, param
),
1386 GC_POINTED_TO
, NULL
);
1388 ; /* target type is not used through this field */
1390 set_gc_used_type (f
->type
, GC_USED
, pass_param
? param
: NULL
);
1396 set_gc_used_type (t
->u
.p
, GC_POINTED_TO
, NULL
);
1400 set_gc_used_type (t
->u
.a
.p
, GC_USED
, param
);
1403 case TYPE_LANG_STRUCT
:
1404 for (t
= t
->u
.s
.lang_struct
; t
; t
= t
->next
)
1405 set_gc_used_type (t
, level
, param
);
1408 case TYPE_PARAM_STRUCT
:
1411 for (i
= 0; i
< NUM_PARAM
; i
++)
1412 if (t
->u
.param_struct
.param
[i
] != 0)
1413 set_gc_used_type (t
->u
.param_struct
.param
[i
], GC_USED
, NULL
);
1415 if (t
->u
.param_struct
.stru
->gc_used
== GC_POINTED_TO
)
1416 level
= GC_POINTED_TO
;
1419 t
->u
.param_struct
.stru
->gc_used
= GC_UNUSED
;
1420 set_gc_used_type (t
->u
.param_struct
.stru
, level
,
1421 t
->u
.param_struct
.param
);
1429 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1432 set_gc_used (pair_p variables
)
1435 for (p
= variables
; p
; p
= p
->next
)
1436 set_gc_used_type (p
->type
, GC_USED
, NULL
);
1439 /* File mapping routines. For each input file, there is one output .c file
1440 (but some output files have many input files), and there is one .h file
1441 for the whole build. */
1443 /* Output file handling. */
1445 /* Create and return an outf_p for a new file for NAME, to be called
1449 create_file (const char *name
, const char *oname
)
1451 static const char *const hdr
[] = {
1452 " Copyright (C) 2004, 2007 Free Software Foundation, Inc.\n",
1454 "This file is part of GCC.\n",
1456 "GCC is free software; you can redistribute it and/or modify it under\n",
1457 "the terms of the GNU General Public License as published by the Free\n",
1458 "Software Foundation; either version 3, or (at your option) any later\n",
1461 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1462 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1463 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1464 "for more details.\n",
1466 "You should have received a copy of the GNU General Public License\n",
1467 "along with GCC; see the file COPYING3. If not see\n",
1468 "<http://www.gnu.org/licenses/>. */\n",
1470 "/* This file is machine generated. Do not edit. */\n"
1475 f
= XCNEW (struct outf
);
1476 f
->next
= output_files
;
1480 oprintf (f
, "/* Type information for %s.\n", name
);
1481 for (i
= 0; i
< ARRAY_SIZE (hdr
); i
++)
1482 oprintf (f
, "%s", hdr
[i
]);
1486 /* Print, like fprintf, to O.
1487 N.B. You might think this could be implemented more efficiently
1488 with vsnprintf(). Unfortunately, there are C libraries that
1489 provide that function but without the C99 semantics for its return
1490 value, making it impossible to know how much space is required. */
1492 oprintf (outf_p o
, const char *format
, ...)
1498 va_start (ap
, format
);
1499 slength
= vasprintf (&s
, format
, ap
);
1500 if (s
== NULL
|| (int)slength
< 0)
1501 fatal ("out of memory");
1504 if (o
->bufused
+ slength
> o
->buflength
)
1506 size_t new_len
= o
->buflength
;
1511 } while (o
->bufused
+ slength
>= new_len
);
1512 o
->buf
= XRESIZEVEC (char, o
->buf
, new_len
);
1513 o
->buflength
= new_len
;
1515 memcpy (o
->buf
+ o
->bufused
, s
, slength
);
1516 o
->bufused
+= slength
;
1520 /* Open the global header file and the language-specific header files. */
1523 open_base_files (void)
1527 header_file
= create_file ("GCC", "gtype-desc.h");
1529 base_files
= XNEWVEC (outf_p
, num_lang_dirs
);
1531 for (i
= 0; i
< num_lang_dirs
; i
++)
1532 base_files
[i
] = create_file (lang_dir_names
[i
],
1533 xasprintf ("gtype-%s.h", lang_dir_names
[i
]));
1535 /* gtype-desc.c is a little special, so we create it here. */
1537 /* The order of files here matters very much. */
1538 static const char *const ifiles
[] = {
1539 "config.h", "system.h", "coretypes.h", "tm.h", "varray.h",
1540 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1541 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1542 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1543 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1544 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1545 "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h", NULL
1547 const char *const *ifp
;
1548 outf_p gtype_desc_c
;
1550 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1551 for (ifp
= ifiles
; *ifp
; ifp
++)
1552 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1554 /* Make sure we handle "cfun" specially. */
1555 oprintf (gtype_desc_c
, "\n/* See definition in function.h. */\n");
1556 oprintf (gtype_desc_c
, "#undef cfun\n");
1560 /* For F a filename, return the real basename of F, with all the directory
1561 components skipped. */
1564 get_file_realbasename (const char *f
)
1566 const char * lastslash
= strrchr (f
, '/');
1568 return (lastslash
!= NULL
) ? lastslash
+ 1 : f
;
1571 /* For F a filename, return the relative path to F from $(srcdir) if the
1572 latter is a prefix in F, NULL otherwise. */
1575 get_file_srcdir_relative_path (const char *f
)
1577 if (strlen (f
) > srcdir_len
1578 && IS_DIR_SEPARATOR (f
[srcdir_len
])
1579 && memcmp (f
, srcdir
, srcdir_len
) == 0)
1580 return f
+ srcdir_len
+ 1;
1585 /* For F a filename, return the relative path to F from $(srcdir) if the
1586 latter is a prefix in F, or the real basename of F otherwise. */
1589 get_file_basename (const char *f
)
1591 const char * srcdir_path
= get_file_srcdir_relative_path (f
);
1593 return (srcdir_path
!= NULL
) ? srcdir_path
: get_file_realbasename (f
);
1596 /* For F a filename, return the lang_dir_names relative index of the language
1597 directory that is a prefix in F, if any, -1 otherwise. */
1600 get_prefix_langdir_index (const char *f
)
1602 size_t f_len
= strlen (f
);
1605 for (lang_index
= 0; lang_index
< num_lang_dirs
; lang_index
++)
1607 const char * langdir
= lang_dir_names
[lang_index
];
1608 size_t langdir_len
= strlen (langdir
);
1610 if (f_len
> langdir_len
1611 && IS_DIR_SEPARATOR (f
[langdir_len
])
1612 && memcmp (f
, langdir
, langdir_len
) == 0)
1619 /* For F a filename, return the name of language directory where F is located,
1620 if any, NULL otherwise. */
1623 get_file_langdir (const char *f
)
1625 /* Get the relative path to F from $(srcdir) and find the language by
1626 comparing the prefix with language directory names. If F is not even
1627 srcdir relative, no point in looking further. */
1630 const char * srcdir_relative_path
= get_file_srcdir_relative_path (f
);
1632 if (!srcdir_relative_path
)
1635 lang_index
= get_prefix_langdir_index (srcdir_relative_path
);
1637 return (lang_index
>= 0) ? lang_dir_names
[lang_index
] : NULL
;
1640 /* The gt- output file name for F. */
1643 get_file_gtfilename (const char *f
)
1645 /* Cook up an initial version of the gt- file name from the file real
1646 basename and the language name, if any. */
1648 const char *basename
= get_file_realbasename (f
);
1649 const char *langdir
= get_file_langdir (f
);
1652 (langdir
? xasprintf ("gt-%s-%s", langdir
, basename
)
1653 : xasprintf ("gt-%s", basename
));
1655 /* Then replace all non alphanumerics characters by '-' and change the
1656 extenstion to ".h". We expect the input filename extension was at least
1657 one character long. */
1661 for (; *s
!= '.'; s
++)
1662 if (! ISALNUM (*s
) && *s
!= '-')
1665 memcpy (s
, ".h", sizeof (".h"));
1670 /* An output file, suitable for definitions, that can see declarations
1671 made in INPUT_FILE and is linked into every language that uses
1675 get_output_file_with_visibility (const char *input_file
)
1679 const char *basename
;
1680 const char *for_name
;
1681 const char *output_name
;
1683 /* This can happen when we need a file with visibility on a
1684 structure that we've never seen. We have to just hope that it's
1685 globally visible. */
1686 if (input_file
== NULL
)
1687 input_file
= "system.h";
1689 /* Determine the output file name. */
1690 basename
= get_file_basename (input_file
);
1692 len
= strlen (basename
);
1693 if ((len
> 2 && memcmp (basename
+len
-2, ".c", 2) == 0)
1694 || (len
> 2 && memcmp (basename
+len
-2, ".y", 2) == 0)
1695 || (len
> 3 && memcmp (basename
+len
-3, ".in", 3) == 0))
1697 output_name
= get_file_gtfilename (input_file
);
1698 for_name
= basename
;
1700 /* Some headers get used by more than one front-end; hence, it
1701 would be inappropriate to spew them out to a single gtype-<lang>.h
1702 (and gengtype doesn't know how to direct spewage into multiple
1703 gtype-<lang>.h headers at this time). Instead, we pair up these
1704 headers with source files (and their special purpose gt-*.h headers). */
1705 else if (strcmp (basename
, "c-common.h") == 0)
1706 output_name
= "gt-c-common.h", for_name
= "c-common.c";
1707 else if (strcmp (basename
, "c-tree.h") == 0)
1708 output_name
= "gt-c-decl.h", for_name
= "c-decl.c";
1709 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1710 && strcmp (basename
+ 3, "cp-tree.h") == 0)
1711 output_name
= "gt-cp-tree.h", for_name
= "cp/tree.c";
1712 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1713 && strcmp (basename
+ 3, "decl.h") == 0)
1714 output_name
= "gt-cp-decl.h", for_name
= "cp/decl.c";
1715 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1716 && strcmp (basename
+ 3, "name-lookup.h") == 0)
1717 output_name
= "gt-cp-name-lookup.h", for_name
= "cp/name-lookup.c";
1718 else if (strncmp (basename
, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename
[4])
1719 && strcmp (basename
+ 5, "objc-act.h") == 0)
1720 output_name
= "gt-objc-objc-act.h", for_name
= "objc/objc-act.c";
1723 int lang_index
= get_prefix_langdir_index (basename
);
1725 if (lang_index
>= 0)
1726 return base_files
[lang_index
];
1728 output_name
= "gtype-desc.c";
1732 /* Look through to see if we've ever seen this output filename before. */
1733 for (r
= output_files
; r
; r
= r
->next
)
1734 if (strcmp (r
->name
, output_name
) == 0)
1737 /* If not, create it. */
1738 r
= create_file (for_name
, output_name
);
1743 /* The name of an output file, suitable for definitions, that can see
1744 declarations made in INPUT_FILE and is linked into every language
1745 that uses INPUT_FILE. */
1748 get_output_file_name (const char *input_file
)
1750 return get_output_file_with_visibility (input_file
)->name
;
1753 /* Copy the output to its final destination,
1754 but don't unnecessarily change modification times. */
1757 close_output_files (void)
1761 for (of
= output_files
; of
; of
= of
->next
)
1765 newfile
= fopen (of
->name
, "r");
1766 if (newfile
!= NULL
)
1771 for (i
= 0; i
< of
->bufused
; i
++)
1774 ch
= fgetc (newfile
);
1775 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
1778 no_write_p
= i
== of
->bufused
&& fgetc (newfile
) == EOF
;
1785 newfile
= fopen (of
->name
, "w");
1786 if (newfile
== NULL
)
1787 fatal ("opening output file %s: %s", of
->name
, strerror (errno
));
1788 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
1789 fatal ("writing output file %s: %s", of
->name
, strerror (errno
));
1790 if (fclose (newfile
) != 0)
1791 fatal ("closing output file %s: %s", of
->name
, strerror (errno
));
1802 struct walk_type_data
;
1804 /* For scalars and strings, given the item in 'val'.
1805 For structures, given a pointer to the item in 'val'.
1806 For misc. pointers, given the item in 'val'.
1808 typedef void (*process_field_fn
)
1809 (type_p f
, const struct walk_type_data
*p
);
1810 typedef void (*func_name_fn
)
1811 (type_p s
, const struct walk_type_data
*p
);
1813 /* Parameters for write_types. */
1815 struct write_types_data
1818 const char *param_prefix
;
1819 const char *subfield_marker_routine
;
1820 const char *marker_routine
;
1821 const char *reorder_note_routine
;
1822 const char *comment
;
1823 int skip_hooks
; /* skip hook generation if non zero */
1826 static void output_escaped_param (struct walk_type_data
*d
,
1827 const char *, const char *);
1828 static void output_mangled_typename (outf_p
, const_type_p
);
1829 static void walk_type (type_p t
, struct walk_type_data
*d
);
1830 static void write_func_for_structure
1831 (type_p orig_s
, type_p s
, type_p
* param
,
1832 const struct write_types_data
*wtd
);
1833 static void write_types_process_field
1834 (type_p f
, const struct walk_type_data
*d
);
1835 static void write_types (type_p structures
,
1836 type_p param_structs
,
1837 const struct write_types_data
*wtd
);
1838 static void write_types_local_process_field
1839 (type_p f
, const struct walk_type_data
*d
);
1840 static void write_local_func_for_structure
1841 (type_p orig_s
, type_p s
, type_p
* param
);
1842 static void write_local (type_p structures
,
1843 type_p param_structs
);
1844 static void write_enum_defn (type_p structures
, type_p param_structs
);
1845 static int contains_scalar_p (type_p t
);
1846 static void put_mangled_filename (outf_p
, const char *);
1847 static void finish_root_table (struct flist
*flp
, const char *pfx
,
1848 const char *tname
, const char *lastname
,
1850 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
1851 struct fileloc
*, const char *);
1852 static void write_array (outf_p f
, pair_p v
,
1853 const struct write_types_data
*wtd
);
1854 static void write_roots (pair_p
);
1856 /* Parameters for walk_type. */
1858 struct walk_type_data
1860 process_field_fn process_field
;
1865 const char *prev_val
[4];
1868 struct fileloc
*line
;
1873 const char *reorder_fn
;
1875 bool fn_wants_lvalue
;
1878 /* Print a mangled name representing T to OF. */
1881 output_mangled_typename (outf_p of
, const_type_p t
)
1885 else switch (t
->kind
)
1889 output_mangled_typename (of
, t
->u
.p
);
1899 case TYPE_LANG_STRUCT
:
1900 oprintf (of
, "%lu%s", (unsigned long) strlen (t
->u
.s
.tag
), t
->u
.s
.tag
);
1902 case TYPE_PARAM_STRUCT
:
1905 for (i
= 0; i
< NUM_PARAM
; i
++)
1906 if (t
->u
.param_struct
.param
[i
] != NULL
)
1907 output_mangled_typename (of
, t
->u
.param_struct
.param
[i
]);
1908 output_mangled_typename (of
, t
->u
.param_struct
.stru
);
1916 /* Print PARAM to D->OF processing escapes. D->VAL references the
1917 current object, D->PREV_VAL the object containing the current
1918 object, ONAME is the name of the option and D->LINE is used to
1919 print error messages. */
1922 output_escaped_param (struct walk_type_data
*d
, const char *param
,
1927 for (p
= param
; *p
; p
++)
1929 oprintf (d
->of
, "%c", *p
);
1933 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
1936 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
1939 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
1943 const char *pp
= d
->val
+ strlen (d
->val
);
1944 while (pp
[-1] == ']')
1947 oprintf (d
->of
, "%s", pp
);
1951 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
1956 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
1957 which is of type T. Write code to D->OF to constrain execution (at
1958 the point that D->PROCESS_FIELD is called) to the appropriate
1959 cases. Call D->PROCESS_FIELD on subobjects before calling it on
1960 pointers to those objects. D->PREV_VAL lists the objects
1961 containing the current object, D->OPT is a list of options to
1962 apply, D->INDENT is the current indentation level, D->LINE is used
1963 to print error messages, D->BITMAP indicates which languages to
1964 print the structure for, and D->PARAM is the current parameter
1965 (from an enclosing param_is option). */
1968 walk_type (type_p t
, struct walk_type_data
*d
)
1970 const char *length
= NULL
;
1971 const char *desc
= NULL
;
1972 int maybe_undef_p
= 0;
1973 int use_param_num
= -1;
1974 int use_params_p
= 0;
1976 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
1978 d
->needs_cast_p
= false;
1979 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
1980 if (strcmp (oo
->name
, "length") == 0)
1982 else if (strcmp (oo
->name
, "maybe_undef") == 0)
1984 else if (strncmp (oo
->name
, "use_param", 9) == 0
1985 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
1986 use_param_num
= oo
->name
[9] == '\0' ? 0 : oo
->name
[9] - '0';
1987 else if (strcmp (oo
->name
, "use_params") == 0)
1989 else if (strcmp (oo
->name
, "desc") == 0)
1991 else if (strcmp (oo
->name
, "mark_hook") == 0)
1993 else if (strcmp (oo
->name
, "nested_ptr") == 0)
1994 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
;
1995 else if (strcmp (oo
->name
, "dot") == 0)
1997 else if (strcmp (oo
->name
, "tag") == 0)
1999 else if (strcmp (oo
->name
, "special") == 0)
2001 else if (strcmp (oo
->name
, "skip") == 0)
2003 else if (strcmp (oo
->name
, "default") == 0)
2005 else if (strcmp (oo
->name
, "descbits") == 0)
2007 else if (strcmp (oo
->name
, "param_is") == 0)
2009 else if (strncmp (oo
->name
, "param", 5) == 0
2010 && ISDIGIT (oo
->name
[5])
2011 && strcmp (oo
->name
+ 6, "_is") == 0)
2013 else if (strcmp (oo
->name
, "chain_next") == 0)
2015 else if (strcmp (oo
->name
, "chain_prev") == 0)
2017 else if (strcmp (oo
->name
, "chain_circular") == 0)
2019 else if (strcmp (oo
->name
, "reorder") == 0)
2022 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
2029 int pointer_p
= t
->kind
== TYPE_POINTER
;
2033 if (! UNION_OR_STRUCT_P (t
))
2034 error_at_line (d
->line
, "`use_params' option on unimplemented type");
2036 t
= find_param_structure (t
, d
->param
);
2038 t
= create_pointer (t
);
2041 if (use_param_num
!= -1)
2043 if (d
->param
!= NULL
&& d
->param
[use_param_num
] != NULL
)
2045 type_p nt
= d
->param
[use_param_num
];
2047 if (t
->kind
== TYPE_ARRAY
)
2048 nt
= create_array (nt
, t
->u
.a
.len
);
2049 else if (length
!= NULL
&& t
->kind
== TYPE_POINTER
)
2050 nt
= create_pointer (nt
);
2051 d
->needs_cast_p
= (t
->kind
!= TYPE_POINTER
2052 && (nt
->kind
== TYPE_POINTER
2053 || nt
->kind
== TYPE_STRING
));
2057 error_at_line (d
->line
, "no parameter defined for `%s'",
2062 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
2064 error_at_line (d
->line
,
2065 "field `%s' has invalid option `maybe_undef_p'\n",
2074 d
->process_field (t
, d
);
2080 && t
->u
.p
->u
.s
.line
.file
== NULL
)
2082 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2088 if (! UNION_OR_STRUCT_P (t
->u
.p
)
2089 && t
->u
.p
->kind
!= TYPE_PARAM_STRUCT
)
2091 error_at_line (d
->line
,
2092 "field `%s' is pointer to unimplemented type",
2099 const char *oldprevval2
= d
->prev_val
[2];
2101 if (! UNION_OR_STRUCT_P (nested_ptr_d
->type
))
2103 error_at_line (d
->line
,
2104 "field `%s' has invalid "
2105 "option `nested_ptr'\n",
2110 d
->prev_val
[2] = d
->val
;
2111 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2113 d
->val
= xasprintf ("x%d", d
->counter
++);
2114 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2115 (nested_ptr_d
->type
->kind
== TYPE_UNION
2116 ? "union" : "struct"),
2117 nested_ptr_d
->type
->u
.s
.tag
,
2118 d
->fn_wants_lvalue
? "" : "const ",
2120 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2121 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2123 oprintf (d
->of
, ";\n");
2125 d
->process_field (nested_ptr_d
->type
, d
);
2127 if (d
->fn_wants_lvalue
)
2129 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2131 d
->prev_val
[2] = d
->val
;
2132 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2134 oprintf (d
->of
, ";\n");
2138 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2139 d
->val
= d
->prev_val
[2];
2140 d
->prev_val
[2] = oldprevval2
;
2143 d
->process_field (t
->u
.p
, d
);
2147 int loopcounter
= d
->counter
++;
2148 const char *oldval
= d
->val
;
2149 const char *oldprevval3
= d
->prev_val
[3];
2152 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2154 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2155 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
, "",
2156 loopcounter
, loopcounter
);
2157 output_escaped_param (d
, length
, "length");
2158 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2160 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2162 d
->prev_val
[3] = oldval
;
2163 walk_type (t
->u
.p
, d
);
2166 d
->prev_val
[3] = oldprevval3
;
2169 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2170 d
->process_field(t
, d
);
2172 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2179 int loopcounter
= d
->counter
++;
2180 const char *oldval
= d
->val
;
2183 /* If it's an array of scalars, we optimize by not generating
2185 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2188 /* When walking an array, compute the length and store it in a
2189 local variable before walking the array elements, instead of
2190 recomputing the length expression each time through the loop.
2191 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2192 where the length is stored in the first array element,
2193 because otherwise that operand can get overwritten on the
2195 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2197 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2198 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2199 d
->indent
, "", loopcounter
);
2201 output_escaped_param (d
, length
, "length");
2203 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2204 oprintf (d
->of
, ");\n");
2206 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2208 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2210 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2212 walk_type (t
->u
.a
.p
, d
);
2217 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2219 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2227 const char *oldval
= d
->val
;
2228 const char *oldprevval1
= d
->prev_val
[1];
2229 const char *oldprevval2
= d
->prev_val
[2];
2230 const int union_p
= t
->kind
== TYPE_UNION
;
2231 int seen_default_p
= 0;
2234 if (! t
->u
.s
.line
.file
)
2235 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2237 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2239 error_at_line (d
->line
,
2240 "structure `%s' defined for mismatching languages",
2242 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2245 /* Some things may also be defined in the structure's options. */
2246 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2247 if (! desc
&& strcmp (o
->name
, "desc") == 0)
2250 d
->prev_val
[2] = oldval
;
2251 d
->prev_val
[1] = oldprevval2
;
2256 error_at_line (d
->line
, "missing `desc' option for union `%s'",
2260 oprintf (d
->of
, "%*sswitch (", d
->indent
, "");
2261 output_escaped_param (d
, desc
, "desc");
2262 oprintf (d
->of
, ")\n");
2264 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2266 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
2269 const char *dot
= ".";
2270 const char *tagid
= NULL
;
2273 int use_param_p
= 0;
2276 d
->reorder_fn
= NULL
;
2277 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2278 if (strcmp (oo
->name
, "dot") == 0)
2280 else if (strcmp (oo
->name
, "tag") == 0)
2282 else if (strcmp (oo
->name
, "skip") == 0)
2284 else if (strcmp (oo
->name
, "default") == 0)
2286 else if (strcmp (oo
->name
, "reorder") == 0)
2287 d
->reorder_fn
= oo
->info
;
2288 else if (strncmp (oo
->name
, "use_param", 9) == 0
2289 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2295 if (union_p
&& tagid
)
2297 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
2300 else if (union_p
&& default_p
)
2302 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2306 else if (! union_p
&& (default_p
|| tagid
))
2307 error_at_line (d
->line
,
2308 "can't use `%s' outside a union on field `%s'",
2309 default_p
? "default" : "tag", f
->name
);
2310 else if (union_p
&& ! (default_p
|| tagid
)
2311 && f
->type
->kind
== TYPE_SCALAR
)
2314 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2315 d
->line
->file
, d
->line
->line
, f
->name
);
2318 else if (union_p
&& ! (default_p
|| tagid
))
2319 error_at_line (d
->line
,
2320 "field `%s' is missing `tag' or `default' option",
2324 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
2326 d
->used_length
= false;
2328 if (union_p
&& use_param_p
&& d
->param
== NULL
)
2329 oprintf (d
->of
, "%*sgcc_unreachable ();\n", d
->indent
, "");
2331 walk_type (f
->type
, d
);
2337 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2341 d
->reorder_fn
= NULL
;
2344 d
->prev_val
[1] = oldprevval1
;
2345 d
->prev_val
[2] = oldprevval2
;
2347 if (union_p
&& ! seen_default_p
)
2349 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2350 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
2354 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2360 case TYPE_LANG_STRUCT
:
2363 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
2364 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
2367 error_at_line (d
->line
, "structure `%s' differs between languages",
2374 case TYPE_PARAM_STRUCT
:
2376 type_p
*oldparam
= d
->param
;
2378 d
->param
= t
->u
.param_struct
.param
;
2379 walk_type (t
->u
.param_struct
.stru
, d
);
2380 d
->param
= oldparam
;
2389 /* process_field routine for marking routines. */
2392 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
2394 const struct write_types_data
*wtd
;
2395 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
2396 wtd
= (const struct write_types_data
*) d
->cookie
;
2401 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
2402 wtd
->subfield_marker_routine
, cast
, d
->val
);
2403 if (wtd
->param_prefix
)
2405 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
2408 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
2409 output_mangled_typename (d
->of
, d
->orig_s
);
2412 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
2414 if (f
->u
.p
->kind
== TYPE_PARAM_STRUCT
2415 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2417 oprintf (d
->of
, ", gt_e_");
2418 output_mangled_typename (d
->of
, f
);
2420 else if (UNION_OR_STRUCT_P (f
)
2421 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2423 oprintf (d
->of
, ", gt_ggc_e_");
2424 output_mangled_typename (d
->of
, f
);
2427 oprintf (d
->of
, ", gt_types_enum_last");
2429 oprintf (d
->of
, ");\n");
2430 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2431 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
2432 wtd
->reorder_note_routine
, cast
, d
->val
,
2433 d
->prev_val
[3], d
->reorder_fn
);
2439 case TYPE_LANG_STRUCT
:
2440 case TYPE_PARAM_STRUCT
:
2441 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
2442 output_mangled_typename (d
->of
, f
);
2443 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
2444 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2445 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
2446 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
2458 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2461 output_type_enum (outf_p of
, type_p s
)
2463 if (s
->kind
== TYPE_PARAM_STRUCT
&& s
->u
.s
.line
.file
!= NULL
)
2465 oprintf (of
, ", gt_e_");
2466 output_mangled_typename (of
, s
);
2468 else if (UNION_OR_STRUCT_P (s
) && s
->u
.s
.line
.file
!= NULL
)
2470 oprintf (of
, ", gt_ggc_e_");
2471 output_mangled_typename (of
, s
);
2474 oprintf (of
, ", gt_types_enum_last");
2477 /* For S, a structure that's part of ORIG_S, and using parameters
2478 PARAM, write out a routine that:
2479 - Takes a parameter, a void * but actually of type *S
2480 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2481 field of S or its substructures and (in some cases) things
2482 that are pointed to by S.
2486 write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2487 const struct write_types_data
*wtd
)
2489 const char *fn
= s
->u
.s
.line
.file
;
2491 const char *chain_next
= NULL
;
2492 const char *chain_prev
= NULL
;
2493 const char *chain_circular
= NULL
;
2494 const char *mark_hook_name
= NULL
;
2496 struct walk_type_data d
;
2498 /* This is a hack, and not the good kind either. */
2499 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2500 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2501 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2502 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2504 memset (&d
, 0, sizeof (d
));
2505 d
.of
= get_output_file_with_visibility (fn
);
2507 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2508 if (strcmp (opt
->name
, "chain_next") == 0)
2509 chain_next
= opt
->info
;
2510 else if (strcmp (opt
->name
, "chain_prev") == 0)
2511 chain_prev
= opt
->info
;
2512 else if (strcmp (opt
->name
, "chain_circular") == 0)
2513 chain_circular
= opt
->info
;
2514 else if (strcmp (opt
->name
, "mark_hook") == 0)
2515 mark_hook_name
= opt
->info
;
2517 if (chain_prev
!= NULL
&& chain_next
== NULL
)
2518 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
2519 if (chain_circular
!= NULL
&& chain_next
!= NULL
)
2520 error_at_line (&s
->u
.s
.line
, "chain_circular with chain_next");
2521 if (chain_circular
!= NULL
)
2522 chain_next
= chain_circular
;
2524 d
.process_field
= write_types_process_field
;
2528 d
.line
= &s
->u
.s
.line
;
2529 d
.bitmap
= s
->u
.s
.bitmap
;
2531 d
.prev_val
[0] = "*x";
2532 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2533 d
.prev_val
[3] = "x";
2536 oprintf (d
.of
, "\n");
2537 oprintf (d
.of
, "void\n");
2539 oprintf (d
.of
, "gt_%sx_%s", wtd
->prefix
, orig_s
->u
.s
.tag
);
2542 oprintf (d
.of
, "gt_%s_", wtd
->prefix
);
2543 output_mangled_typename (d
.of
, orig_s
);
2545 oprintf (d
.of
, " (void *x_p)\n");
2546 oprintf (d
.of
, "{\n");
2547 oprintf (d
.of
, " %s %s * %sx = (%s %s *)x_p;\n",
2548 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2549 chain_next
== NULL
? "const " : "",
2550 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2551 if (chain_next
!= NULL
)
2552 oprintf (d
.of
, " %s %s * xlimit = x;\n",
2553 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2554 if (chain_next
== NULL
)
2556 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
2557 if (wtd
->param_prefix
)
2559 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
2560 output_mangled_typename (d
.of
, orig_s
);
2561 output_type_enum (d
.of
, orig_s
);
2563 oprintf (d
.of
, "))\n");
2567 if (chain_circular
!= NULL
)
2568 oprintf (d
.of
, " if (!%s (xlimit", wtd
->marker_routine
);
2570 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2571 if (wtd
->param_prefix
)
2573 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2574 output_mangled_typename (d
.of
, orig_s
);
2575 output_type_enum (d
.of
, orig_s
);
2577 oprintf (d
.of
, "))\n");
2578 if (chain_circular
!= NULL
)
2579 oprintf (d
.of
, " return;\n do\n");
2580 if (mark_hook_name
&& !wtd
->skip_hooks
)
2582 oprintf (d
.of
, " {\n");
2583 oprintf (d
.of
, " %s (xlimit);\n ", mark_hook_name
);
2585 oprintf (d
.of
, " xlimit = (");
2586 d
.prev_val
[2] = "*xlimit";
2587 output_escaped_param (&d
, chain_next
, "chain_next");
2588 oprintf (d
.of
, ");\n");
2589 if (mark_hook_name
&& !wtd
->skip_hooks
)
2590 oprintf (d
.of
, " }\n");
2591 if (chain_prev
!= NULL
)
2593 oprintf (d
.of
, " if (x != xlimit)\n");
2594 oprintf (d
.of
, " for (;;)\n");
2595 oprintf (d
.of
, " {\n");
2596 oprintf (d
.of
, " %s %s * const xprev = (",
2597 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2599 d
.prev_val
[2] = "*x";
2600 output_escaped_param (&d
, chain_prev
, "chain_prev");
2601 oprintf (d
.of
, ");\n");
2602 oprintf (d
.of
, " if (xprev == NULL) break;\n");
2603 oprintf (d
.of
, " x = xprev;\n");
2604 oprintf (d
.of
, " (void) %s (xprev",
2605 wtd
->marker_routine
);
2606 if (wtd
->param_prefix
)
2608 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
2609 output_mangled_typename (d
.of
, orig_s
);
2610 output_type_enum (d
.of
, orig_s
);
2612 oprintf (d
.of
, ");\n");
2613 oprintf (d
.of
, " }\n");
2615 if (chain_circular
!= NULL
)
2617 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2618 if (wtd
->param_prefix
)
2620 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2621 output_mangled_typename (d
.of
, orig_s
);
2622 output_type_enum (d
.of
, orig_s
);
2624 oprintf (d
.of
, "));\n");
2625 if (mark_hook_name
&& !wtd
->skip_hooks
)
2626 oprintf (d
.of
, " %s (xlimit);\n", mark_hook_name
);
2627 oprintf (d
.of
, " do\n");
2630 oprintf (d
.of
, " while (x != xlimit)\n");
2632 oprintf (d
.of
, " {\n");
2633 if (mark_hook_name
&& chain_next
== NULL
&& !wtd
->skip_hooks
)
2635 oprintf (d
.of
, " %s (x);\n", mark_hook_name
);
2637 d
.prev_val
[2] = "*x";
2641 if (chain_next
!= NULL
)
2643 oprintf (d
.of
, " x = (");
2644 output_escaped_param (&d
, chain_next
, "chain_next");
2645 oprintf (d
.of
, ");\n");
2648 oprintf (d
.of
, " }\n");
2649 if (chain_circular
!= NULL
)
2650 oprintf (d
.of
, " while (x != xlimit);\n");
2651 oprintf (d
.of
, "}\n");
2654 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
2657 write_types (type_p structures
, type_p param_structs
,
2658 const struct write_types_data
*wtd
)
2662 oprintf (header_file
, "\n/* %s*/\n", wtd
->comment
);
2663 for (s
= structures
; s
; s
= s
->next
)
2664 if (s
->gc_used
== GC_POINTED_TO
2665 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2669 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2670 && s
->u
.s
.line
.file
== NULL
)
2673 oprintf (header_file
, "#define gt_%s_", wtd
->prefix
);
2674 output_mangled_typename (header_file
, s
);
2675 oprintf (header_file
, "(X) do { \\\n");
2676 oprintf (header_file
,
2677 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
2679 oprintf (header_file
,
2682 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2683 if (strcmp (opt
->name
, "ptr_alias") == 0)
2685 const_type_p
const t
= (const_type_p
) opt
->info
;
2686 if (t
->kind
== TYPE_STRUCT
2687 || t
->kind
== TYPE_UNION
2688 || t
->kind
== TYPE_LANG_STRUCT
)
2689 oprintf (header_file
,
2690 "#define gt_%sx_%s gt_%sx_%s\n",
2691 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t
->u
.s
.tag
);
2693 error_at_line (&s
->u
.s
.line
,
2694 "structure alias is not a structure");
2700 /* Declare the marker procedure only once. */
2701 oprintf (header_file
,
2702 "extern void gt_%sx_%s (void *);\n",
2703 wtd
->prefix
, s
->u
.s
.tag
);
2705 if (s
->u
.s
.line
.file
== NULL
)
2707 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2712 if (s
->kind
== TYPE_LANG_STRUCT
)
2715 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2716 write_func_for_structure (s
, ss
, NULL
, wtd
);
2719 write_func_for_structure (s
, s
, NULL
, wtd
);
2722 for (s
= param_structs
; s
; s
= s
->next
)
2723 if (s
->gc_used
== GC_POINTED_TO
)
2725 type_p
* param
= s
->u
.param_struct
.param
;
2726 type_p stru
= s
->u
.param_struct
.stru
;
2728 /* Declare the marker procedure. */
2729 oprintf (header_file
, "extern void gt_%s_", wtd
->prefix
);
2730 output_mangled_typename (header_file
, s
);
2731 oprintf (header_file
, " (void *);\n");
2733 if (stru
->u
.s
.line
.file
== NULL
)
2735 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2740 if (stru
->kind
== TYPE_LANG_STRUCT
)
2743 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2744 write_func_for_structure (s
, ss
, param
, wtd
);
2747 write_func_for_structure (s
, stru
, param
, wtd
);
2751 static const struct write_types_data ggc_wtd
=
2753 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
2754 "GC marker procedures. ",
2758 static const struct write_types_data pch_wtd
=
2760 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
2761 "gt_pch_note_reorder",
2762 "PCH type-walking procedures. ",
2766 /* Write out the local pointer-walking routines. */
2768 /* process_field routine for local pointer-walking. */
2771 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
2778 case TYPE_LANG_STRUCT
:
2779 case TYPE_PARAM_STRUCT
:
2781 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
2783 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
2794 /* For S, a structure that's part of ORIG_S, and using parameters
2795 PARAM, write out a routine that:
2796 - Is of type gt_note_pointers
2797 - Calls PROCESS_FIELD on each field of S or its substructures.
2801 write_local_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
)
2803 const char *fn
= s
->u
.s
.line
.file
;
2805 struct walk_type_data d
;
2807 /* This is a hack, and not the good kind either. */
2808 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2809 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2810 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2811 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2813 memset (&d
, 0, sizeof (d
));
2814 d
.of
= get_output_file_with_visibility (fn
);
2816 d
.process_field
= write_types_local_process_field
;
2818 d
.line
= &s
->u
.s
.line
;
2819 d
.bitmap
= s
->u
.s
.bitmap
;
2821 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
2822 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2823 d
.prev_val
[3] = "x";
2825 d
.fn_wants_lvalue
= true;
2827 oprintf (d
.of
, "\n");
2828 oprintf (d
.of
, "void\n");
2829 oprintf (d
.of
, "gt_pch_p_");
2830 output_mangled_typename (d
.of
, orig_s
);
2831 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
2833 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2834 "\tATTRIBUTE_UNUSED void *cookie)\n");
2835 oprintf (d
.of
, "{\n");
2836 oprintf (d
.of
, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
2837 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2838 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2841 oprintf (d
.of
, "}\n");
2844 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
2847 write_local (type_p structures
, type_p param_structs
)
2851 oprintf (header_file
, "\n/* Local pointer-walking routines. */\n");
2852 for (s
= structures
; s
; s
= s
->next
)
2853 if (s
->gc_used
== GC_POINTED_TO
2854 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2858 if (s
->u
.s
.line
.file
== NULL
)
2861 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2862 if (strcmp (opt
->name
, "ptr_alias") == 0)
2864 const_type_p
const t
= (const_type_p
) opt
->info
;
2865 if (t
->kind
== TYPE_STRUCT
2866 || t
->kind
== TYPE_UNION
2867 || t
->kind
== TYPE_LANG_STRUCT
)
2869 oprintf (header_file
, "#define gt_pch_p_");
2870 output_mangled_typename (header_file
, s
);
2871 oprintf (header_file
, " gt_pch_p_");
2872 output_mangled_typename (header_file
, t
);
2873 oprintf (header_file
, "\n");
2876 error_at_line (&s
->u
.s
.line
,
2877 "structure alias is not a structure");
2883 /* Declare the marker procedure only once. */
2884 oprintf (header_file
, "extern void gt_pch_p_");
2885 output_mangled_typename (header_file
, s
);
2886 oprintf (header_file
,
2887 "\n (void *, void *, gt_pointer_operator, void *);\n");
2889 if (s
->kind
== TYPE_LANG_STRUCT
)
2892 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2893 write_local_func_for_structure (s
, ss
, NULL
);
2896 write_local_func_for_structure (s
, s
, NULL
);
2899 for (s
= param_structs
; s
; s
= s
->next
)
2900 if (s
->gc_used
== GC_POINTED_TO
)
2902 type_p
* param
= s
->u
.param_struct
.param
;
2903 type_p stru
= s
->u
.param_struct
.stru
;
2905 /* Declare the marker procedure. */
2906 oprintf (header_file
, "extern void gt_pch_p_");
2907 output_mangled_typename (header_file
, s
);
2908 oprintf (header_file
,
2909 "\n (void *, void *, gt_pointer_operator, void *);\n");
2911 if (stru
->u
.s
.line
.file
== NULL
)
2913 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2918 if (stru
->kind
== TYPE_LANG_STRUCT
)
2921 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2922 write_local_func_for_structure (s
, ss
, param
);
2925 write_local_func_for_structure (s
, stru
, param
);
2929 /* Write out the 'enum' definition for gt_types_enum. */
2932 write_enum_defn (type_p structures
, type_p param_structs
)
2936 oprintf (header_file
, "\n/* Enumeration of types known. */\n");
2937 oprintf (header_file
, "enum gt_types_enum {\n");
2938 for (s
= structures
; s
; s
= s
->next
)
2939 if (s
->gc_used
== GC_POINTED_TO
2940 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2942 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2943 && s
->u
.s
.line
.file
== NULL
)
2946 oprintf (header_file
, " gt_ggc_e_");
2947 output_mangled_typename (header_file
, s
);
2948 oprintf (header_file
, ", \n");
2950 for (s
= param_structs
; s
; s
= s
->next
)
2951 if (s
->gc_used
== GC_POINTED_TO
)
2953 oprintf (header_file
, " gt_e_");
2954 output_mangled_typename (header_file
, s
);
2955 oprintf (header_file
, ", \n");
2957 oprintf (header_file
, " gt_types_enum_last\n");
2958 oprintf (header_file
, "};\n");
2961 /* Might T contain any non-pointer elements? */
2964 contains_scalar_p (type_p t
)
2972 return contains_scalar_p (t
->u
.a
.p
);
2974 /* Could also check for structures that have no non-pointer
2975 fields, but there aren't enough of those to worry about. */
2980 /* Mangle FN and print it to F. */
2983 put_mangled_filename (outf_p f
, const char *fn
)
2985 const char *name
= get_output_file_name (fn
);
2986 for (; *name
!= 0; name
++)
2987 if (ISALNUM (*name
))
2988 oprintf (f
, "%c", *name
);
2990 oprintf (f
, "%c", '_');
2993 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
2994 LASTNAME, and NAME are all strings to insert in various places in
2995 the resulting code. */
2998 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
2999 const char *tname
, const char *name
)
3003 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3004 if (fli2
->started_p
)
3006 oprintf (fli2
->f
, " %s\n", lastname
);
3007 oprintf (fli2
->f
, "};\n\n");
3010 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3011 if (fli2
->started_p
)
3013 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
3016 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
3019 oprintf (base_files
[fnum
],
3020 "extern const struct %s gt_%s_",
3022 put_mangled_filename (base_files
[fnum
], fli2
->name
);
3023 oprintf (base_files
[fnum
], "[];\n");
3029 for (fnum
= 0; fnum
< num_lang_dirs
; fnum
++)
3030 oprintf (base_files
[fnum
],
3031 "EXPORTED_CONST struct %s * const %s[] = {\n",
3036 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3037 if (fli2
->started_p
)
3039 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
3042 fli2
->started_p
= 0;
3044 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
3047 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
3048 put_mangled_filename (base_files
[fnum
], fli2
->name
);
3049 oprintf (base_files
[fnum
], ",\n");
3055 for (fnum
= 0; fnum
< num_lang_dirs
; fnum
++)
3057 oprintf (base_files
[fnum
], " NULL\n");
3058 oprintf (base_files
[fnum
], "};\n");
3063 /* Write out to F the table entry and any marker routines needed to
3064 mark NAME as TYPE. The original variable is V, at LINE.
3065 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
3066 is nonzero iff we are building the root table for hash table caches. */
3069 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
3070 struct fileloc
*line
, const char *if_marked
)
3077 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
3080 const char *desc
= NULL
;
3083 for (o
= fld
->opt
; o
; o
= o
->next
)
3084 if (strcmp (o
->name
, "skip") == 0)
3086 else if (strcmp (o
->name
, "desc") == 0)
3088 else if (strcmp (o
->name
, "param_is") == 0)
3091 error_at_line (line
,
3092 "field `%s' of global `%s' has unknown option `%s'",
3093 fld
->name
, name
, o
->name
);
3097 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
3099 pair_p validf
= NULL
;
3102 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
3104 const char *tag
= NULL
;
3107 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
3108 if (strcmp (oo
->name
, "tag") == 0)
3110 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
3113 error_at_line (line
,
3114 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3115 name
, fld
->name
, validf
->name
,
3116 name
, fld
->name
, ufld
->name
,
3123 newname
= xasprintf ("%s.%s.%s",
3124 name
, fld
->name
, validf
->name
);
3125 write_root (f
, v
, validf
->type
, newname
, 0, line
,
3131 error_at_line (line
,
3132 "global `%s.%s' has `desc' option but is not union",
3137 newname
= xasprintf ("%s.%s", name
, fld
->name
);
3138 write_root (f
, v
, fld
->type
, newname
, 0, line
, if_marked
);
3148 newname
= xasprintf ("%s[0]", name
);
3149 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, if_marked
);
3158 oprintf (f
, " {\n");
3159 oprintf (f
, " &%s,\n", name
);
3162 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3164 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
3165 else if (ap
== v
->type
)
3166 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
3168 oprintf (f
, " sizeof (%s", v
->name
);
3169 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3171 oprintf (f
, "),\n");
3175 if (! has_length
&& UNION_OR_STRUCT_P (tp
))
3177 oprintf (f
, " >_ggc_mx_%s,\n", tp
->u
.s
.tag
);
3178 oprintf (f
, " >_pch_nx_%s", tp
->u
.s
.tag
);
3180 else if (! has_length
&& tp
->kind
== TYPE_PARAM_STRUCT
)
3182 oprintf (f
, " >_ggc_m_");
3183 output_mangled_typename (f
, tp
);
3184 oprintf (f
, ",\n >_pch_n_");
3185 output_mangled_typename (f
, tp
);
3188 && (tp
->kind
== TYPE_POINTER
|| UNION_OR_STRUCT_P (tp
)))
3190 oprintf (f
, " >_ggc_ma_%s,\n", name
);
3191 oprintf (f
, " >_pch_na_%s", name
);
3195 error_at_line (line
,
3196 "global `%s' is pointer to unimplemented type",
3200 oprintf (f
, ",\n &%s", if_marked
);
3201 oprintf (f
, "\n },\n");
3207 oprintf (f
, " {\n");
3208 oprintf (f
, " &%s,\n", name
);
3209 oprintf (f
, " 1, \n");
3210 oprintf (f
, " sizeof (%s),\n", v
->name
);
3211 oprintf (f
, " (gt_pointer_walker) >_ggc_m_S,\n");
3212 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
3213 oprintf (f
, " },\n");
3221 error_at_line (line
,
3222 "global `%s' is unimplemented type",
3227 /* This generates a routine to walk an array. */
3230 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
3232 struct walk_type_data d
;
3235 memset (&d
, 0, sizeof (d
));
3241 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
3244 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
3246 if (wtd
->param_prefix
)
3248 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
3250 " (void *, void *, gt_pointer_operator, void *);\n");
3251 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3252 wtd
->param_prefix
, v
->name
);
3254 " ATTRIBUTE_UNUSED void *x_p,\n"
3255 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3256 " ATTRIBUTE_UNUSED void * cookie)\n");
3257 oprintf (d
.of
, "{\n");
3258 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3259 d
.process_field
= write_types_local_process_field
;
3260 walk_type (v
->type
, &d
);
3261 oprintf (f
, "}\n\n");
3265 oprintf (f
, "static void gt_%sa_%s (void *);\n",
3266 wtd
->prefix
, v
->name
);
3267 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3268 wtd
->prefix
, v
->name
);
3270 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3271 d
.process_field
= write_types_process_field
;
3272 walk_type (v
->type
, &d
);
3274 oprintf (f
, "}\n\n");
3277 /* Output a table describing the locations and types of VARIABLES. */
3280 write_roots (pair_p variables
)
3283 struct flist
*flp
= NULL
;
3285 for (v
= variables
; v
; v
= v
->next
)
3287 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3289 const char *length
= NULL
;
3290 int deletable_p
= 0;
3293 for (o
= v
->opt
; o
; o
= o
->next
)
3294 if (strcmp (o
->name
, "length") == 0)
3296 else if (strcmp (o
->name
, "deletable") == 0)
3298 else if (strcmp (o
->name
, "param_is") == 0)
3300 else if (strncmp (o
->name
, "param", 5) == 0
3301 && ISDIGIT (o
->name
[5])
3302 && strcmp (o
->name
+ 6, "_is") == 0)
3304 else if (strcmp (o
->name
, "if_marked") == 0)
3307 error_at_line (&v
->line
,
3308 "global `%s' has unknown option `%s'",
3311 for (fli
= flp
; fli
; fli
= fli
->next
)
3316 fli
= XNEW (struct flist
);
3320 fli
->name
= v
->line
.file
;
3323 oprintf (f
, "\n/* GC roots. */\n\n");
3328 && v
->type
->kind
== TYPE_POINTER
3329 && (v
->type
->u
.p
->kind
== TYPE_POINTER
3330 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
3332 write_array (f
, v
, &ggc_wtd
);
3333 write_array (f
, v
, &pch_wtd
);
3337 for (v
= variables
; v
; v
= v
->next
)
3339 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3345 for (o
= v
->opt
; o
; o
= o
->next
)
3346 if (strcmp (o
->name
, "length") == 0)
3348 else if (strcmp (o
->name
, "deletable") == 0
3349 || strcmp (o
->name
, "if_marked") == 0)
3355 for (fli
= flp
; fli
; fli
= fli
->next
)
3358 if (! fli
->started_p
)
3362 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3363 put_mangled_filename (f
, v
->line
.file
);
3364 oprintf (f
, "[] = {\n");
3367 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3370 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3373 for (v
= variables
; v
; v
= v
->next
)
3375 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3380 for (o
= v
->opt
; o
; o
= o
->next
)
3381 if (strcmp (o
->name
, "deletable") == 0)
3383 else if (strcmp (o
->name
, "if_marked") == 0)
3389 for (fli
= flp
; fli
; fli
= fli
->next
)
3392 if (! fli
->started_p
)
3396 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3397 put_mangled_filename (f
, v
->line
.file
);
3398 oprintf (f
, "[] = {\n");
3401 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3405 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3406 "gt_ggc_deletable_rtab");
3408 for (v
= variables
; v
; v
= v
->next
)
3410 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3412 const char *if_marked
= NULL
;
3416 for (o
= v
->opt
; o
; o
= o
->next
)
3417 if (strcmp (o
->name
, "length") == 0)
3419 else if (strcmp (o
->name
, "if_marked") == 0)
3420 if_marked
= o
->info
;
3422 if (if_marked
== NULL
)
3425 if (v
->type
->kind
!= TYPE_POINTER
3426 || v
->type
->u
.p
->kind
!= TYPE_PARAM_STRUCT
3427 || v
->type
->u
.p
->u
.param_struct
.stru
!= find_structure ("htab", 0))
3429 error_at_line (&v
->line
, "if_marked option used but not hash table");
3433 for (fli
= flp
; fli
; fli
= fli
->next
)
3436 if (! fli
->started_p
)
3440 oprintf (f
, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
3441 put_mangled_filename (f
, v
->line
.file
);
3442 oprintf (f
, "[] = {\n");
3445 write_root (f
, v
, v
->type
->u
.p
->u
.param_struct
.param
[0],
3446 v
->name
, length_p
, &v
->line
, if_marked
);
3449 finish_root_table (flp
, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
3450 "gt_ggc_cache_rtab");
3452 for (v
= variables
; v
; v
= v
->next
)
3454 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3457 int if_marked_p
= 0;
3460 for (o
= v
->opt
; o
; o
= o
->next
)
3461 if (strcmp (o
->name
, "length") == 0)
3463 else if (strcmp (o
->name
, "if_marked") == 0)
3469 for (fli
= flp
; fli
; fli
= fli
->next
)
3472 if (! fli
->started_p
)
3476 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
3477 put_mangled_filename (f
, v
->line
.file
);
3478 oprintf (f
, "[] = {\n");
3481 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3484 finish_root_table (flp
, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3485 "gt_pch_cache_rtab");
3487 for (v
= variables
; v
; v
= v
->next
)
3489 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3494 for (o
= v
->opt
; o
; o
= o
->next
)
3495 if (strcmp (o
->name
, "deletable") == 0
3496 || strcmp (o
->name
, "if_marked") == 0)
3502 if (! contains_scalar_p (v
->type
))
3505 for (fli
= flp
; fli
; fli
= fli
->next
)
3508 if (! fli
->started_p
)
3512 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
3513 put_mangled_filename (f
, v
->line
.file
);
3514 oprintf (f
, "[] = {\n");
3517 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3521 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3522 "gt_pch_scalar_rtab");
3525 /* Record the definition of a generic VEC structure, as if we had expanded
3526 the macros in vec.h:
3528 typedef struct VEC_<type>_base GTY(()) {
3531 <type> GTY((length ("%h.num"))) vec[1];
3534 where the GTY(()) tags are only present if is_scalar is _false_. */
3537 note_def_vec (const char *type_name
, bool is_scalar
, struct fileloc
*pos
)
3542 type_p len_ty
= create_scalar_type ("unsigned");
3543 const char *name
= concat ("VEC_", type_name
, "_base", (char *)0);
3547 t
= create_scalar_type (type_name
);
3552 t
= resolve_typedef (type_name
, pos
);
3553 o
= create_option (0, "length", "%h.num");
3556 /* We assemble the field list in reverse order. */
3557 fields
= create_field_at (0, create_array (t
, "1"), "vec", o
, pos
);
3558 fields
= create_field_at (fields
, len_ty
, "alloc", 0, pos
);
3559 fields
= create_field_at (fields
, len_ty
, "num", 0, pos
);
3561 do_typedef (name
, new_structure (name
, 0, pos
, fields
, 0), pos
);
3564 /* Record the definition of an allocation-specific VEC structure, as if
3565 we had expanded the macros in vec.h:
3567 typedef struct VEC_<type>_<astrat> {
3568 VEC_<type>_base base;
3569 } VEC_<type>_<astrat>;
3572 note_def_vec_alloc (const char *type
, const char *astrat
, struct fileloc
*pos
)
3574 const char *astratname
= concat ("VEC_", type
, "_", astrat
, (char *)0);
3575 const char *basename
= concat ("VEC_", type
, "_base", (char *)0);
3577 pair_p field
= create_field_at (0, resolve_typedef (basename
, pos
),
3580 do_typedef (astratname
, new_structure (astratname
, 0, pos
, field
, 0), pos
);
3585 main (int argc
, char **argv
)
3588 static struct fileloc pos
= { this_file
, 0 };
3590 /* fatal uses this */
3591 progname
= "gengtype";
3594 fatal ("usage: gengtype srcdir input-list");
3597 srcdir_len
= strlen (srcdir
);
3599 read_input_list (argv
[2]);
3603 scalar_char
.u
.scalar_is_char
= true;
3604 scalar_nonchar
.u
.scalar_is_char
= false;
3607 /* These types are set up with #define or else outside of where
3609 pos
.line
= __LINE__
+ 1;
3610 do_scalar_typedef ("CUMULATIVE_ARGS", &pos
); pos
.line
++;
3611 do_scalar_typedef ("REAL_VALUE_TYPE", &pos
); pos
.line
++;
3612 do_scalar_typedef ("FIXED_VALUE_TYPE", &pos
); pos
.line
++;
3613 do_scalar_typedef ("double_int", &pos
); pos
.line
++;
3614 do_scalar_typedef ("uint8", &pos
); pos
.line
++;
3615 do_scalar_typedef ("jword", &pos
); pos
.line
++;
3616 do_scalar_typedef ("JCF_u2", &pos
); pos
.line
++;
3617 do_scalar_typedef ("void", &pos
); pos
.line
++;
3618 do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos
)), &pos
);
3620 for (i
= 0; i
< num_gt_files
; i
++)
3621 parse_file (gt_files
[i
]);
3626 set_gc_used (variables
);
3629 write_enum_defn (structures
, param_structs
);
3630 write_types (structures
, param_structs
, &ggc_wtd
);
3631 write_types (structures
, param_structs
, &pch_wtd
);
3632 write_local (structures
, param_structs
);
3633 write_roots (variables
);
3635 close_output_files ();