1 /* Process source files and output type information.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
24 #include "errors.h" /* for fatal */
25 #include "double-int.h"
28 /* Data types, macros, etc. used only in this file. */
30 /* Kinds of types we can understand. */
42 typedef unsigned lang_bitmap
;
44 /* A way to pass data through to the output end. */
52 /* Option data for the 'nested_ptr' option. */
53 struct nested_ptr_data
56 const char *convert_to
;
57 const char *convert_from
;
60 /* A name and a type. */
72 /* A description of a type. */
77 /* Used for structures whose definitions we haven't seen so far when
78 we encounter a pointer to it that is annotated with ``maybe_undef''.
79 If after reading in everything we don't have source file
80 information for it, we assume that it never has been defined. */
90 enum gc_used_enum gc_used
;
108 type_p param
[NUM_PARAM
];
115 ((x)->kind == TYPE_UNION || \
116 ((x)->kind == TYPE_LANG_STRUCT \
117 && (x)->u.s.lang_struct->kind == TYPE_UNION))
118 #define UNION_OR_STRUCT_P(x) \
119 ((x)->kind == TYPE_UNION \
120 || (x)->kind == TYPE_STRUCT \
121 || (x)->kind == TYPE_LANG_STRUCT)
123 /* Structure representing an output file. */
132 typedef struct outf
* outf_p
;
134 /* An output file, suitable for definitions, that can see declarations
135 made in INPUT_FILE and is linked into every language that uses
136 INPUT_FILE. May return NULL in plugin mode. */
137 extern outf_p get_output_file_with_visibility
138 (const char *input_file
);
139 const char *get_output_file_name (const char *);
141 /* Print, like fprintf, to O. No-op if O is NULL. */
142 static void oprintf (outf_p o
, const char *S
, ...)
145 /* The list of output files. */
146 static outf_p output_files
;
148 /* The plugin input files and their number; in that case only
149 a single file is produced. */
150 static char** plugin_files
;
151 static size_t nb_plugin_files
;
152 /* the generated plugin output name & file */
153 static outf_p plugin_output
;
155 /* The output header file that is included into pretty much every
157 static outf_p header_file
;
159 /* Source directory. */
160 static const char *srcdir
;
162 /* Length of srcdir name. */
163 static size_t srcdir_len
= 0;
165 static outf_p
create_file (const char *, const char *);
167 static const char * get_file_basename (const char *);
168 static const char * get_file_realbasename (const char *);
169 static const char * get_file_srcdir_relative_path (const char *);
171 static int get_prefix_langdir_index (const char *);
172 static const char * get_file_langdir (const char *);
175 /* Nonzero iff an error has occurred. */
176 bool hit_error
= false;
178 static void gen_rtx_next (void);
179 static void write_rtx_next (void);
180 static void open_base_files (void);
181 static void close_output_files (void);
183 /* Report an error at POS, printing MSG. */
186 error_at_line (const struct fileloc
*pos
, const char *msg
, ...)
192 fprintf (stderr
, "%s:%d: ", pos
->file
, pos
->line
);
193 vfprintf (stderr
, msg
, ap
);
194 fputc ('\n', stderr
);
200 /* asprintf, but produces fatal message on out-of-memory. */
202 xasprintf (const char *format
, ...)
208 va_start (ap
, format
);
209 n
= vasprintf (&result
, format
, ap
);
210 if (result
== NULL
|| n
< 0)
211 fatal ("out of memory");
217 /* Input file handling. */
219 /* Table of all input files. */
220 static const char **gt_files
;
221 static size_t num_gt_files
;
223 /* A number of places use the name of this file for a location for
224 things that we can't rely on the source to define. Make sure we
225 can still use pointer comparison on filenames. */
226 static const char this_file
[] = __FILE__
;
228 /* Vector of per-language directories. */
229 static const char **lang_dir_names
;
230 static size_t num_lang_dirs
;
232 /* An array of output files suitable for definitions. There is one
233 BASE_FILES entry for each language. */
234 static outf_p
*base_files
;
236 /* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
237 INPUT_FILE is used by <lang>.
239 This function should be written to assume that a file _is_ used
240 if the situation is unclear. If it wrongly assumes a file _is_ used,
241 a linker error will result. If it wrongly assumes a file _is not_ used,
242 some GC roots may be missed, which is a much harder-to-debug problem.
244 The relevant bitmap is stored immediately before the file's name in the
245 buffer set up by read_input_list. It may be unaligned, so we have to
246 read it byte-by-byte. */
249 get_lang_bitmap (const char *gtfile
)
252 if (gtfile
== this_file
)
253 /* Things defined in this file are universal. */
254 return (((lang_bitmap
)1) << num_lang_dirs
) - 1;
259 for (i
= -(int) sizeof (lang_bitmap
); i
< 0; i
++)
260 n
= (n
<< CHAR_BIT
) + (unsigned char)gtfile
[i
];
265 /* Set the bitmap returned by get_lang_bitmap. The only legitimate
266 caller of this function is read_input_list. */
268 set_lang_bitmap (char *gtfile
, lang_bitmap n
)
271 for (i
= -1; i
>= -(int) sizeof (lang_bitmap
); i
--)
273 gtfile
[i
] = n
& ((1U << CHAR_BIT
)-1);
278 /* Scan the input file, LIST, and determine how much space we need to
279 store strings in. Also, count the number of language directories
280 and files. The numbers returned are overestimates as they does not
281 consider repeated files. */
283 measure_input_list (FILE *list
)
289 num_gt_files
= plugin_files
? nb_plugin_files
: 0;
290 while ((c
= getc (list
)) != EOF
)
299 /* Add space for a lang_bitmap before the input file name. */
300 n
+= sizeof (lang_bitmap
);
314 /* Read one input line from LIST to HEREP (which is updated). A
315 pointer to the string is returned via LINEP. If it was a language
316 subdirectory in square brackets, strip off the square brackets and
317 return true. Otherwise, leave space before the string for a
318 lang_bitmap, and return false. At EOF, returns false, does not
319 touch *HEREP, and sets *LINEP to NULL. POS is used for
322 read_input_line (FILE *list
, char **herep
, char **linep
,
329 /* Read over whitespace. */
330 while (c
== '\n' || c
== ' ')
340 /* No space for a lang_bitmap is necessary. Discard the '['. */
343 while (c
!= ']' && c
!= '\n' && c
!= EOF
)
352 c
= getc (list
); /* eat what should be a newline */
353 if (c
!= '\n' && c
!= EOF
)
354 error_at_line (pos
, "junk on line after language tag [%s]", line
);
357 error_at_line (pos
, "missing close bracket for language tag [%s", line
);
365 /* Leave space for a lang_bitmap. */
366 memset (here
, 0, sizeof (lang_bitmap
));
367 here
+= sizeof (lang_bitmap
);
374 while (c
!= EOF
&& c
!= '\n');
382 /* Read the list of input files from LIST and compute all of the
383 relevant tables. There is one file per line of the list. At
384 first, all the files on the list are language-generic, but
385 eventually a line will appear which is the name of a language
386 subdirectory in square brackets, like this: [cp]. All subsequent
387 files are specific to that language, until another language
388 subdirectory tag appears. Files can appear more than once, if
389 they apply to more than one language. */
391 read_input_list (const char *listname
)
393 FILE *list
= fopen (listname
, "r");
395 fatal ("cannot open %s: %s", listname
, xstrerror (errno
));
399 size_t bufsz
= measure_input_list (list
);
400 char *buf
= XNEWVEC (char, bufsz
);
402 char *committed
= buf
;
403 char *limit
= buf
+ bufsz
;
408 lang_bitmap curlangs
= (1 << num_lang_dirs
) - 1;
410 epos
.file
= listname
;
413 lang_dir_names
= XNEWVEC (const char *, num_lang_dirs
);
414 gt_files
= XNEWVEC (const char *, num_gt_files
);
421 is_language
= read_input_line (list
, &here
, &line
, &epos
);
422 gcc_assert (here
<= limit
);
425 else if (is_language
)
428 gcc_assert (langno
<= num_lang_dirs
);
429 for (i
= 0; i
< langno
; i
++)
430 if (strcmp (lang_dir_names
[i
], line
) == 0)
432 error_at_line (&epos
, "duplicate language tag [%s]", line
);
438 curlangs
= 1 << langno
;
439 lang_dir_names
[langno
++] = line
;
444 gcc_assert (nfiles
<= num_gt_files
);
445 for (i
= 0; i
< nfiles
; i
++)
446 if (strcmp (gt_files
[i
], line
) == 0)
448 /* Throw away the string we just read, and add the
449 current language to the existing string's bitmap. */
450 lang_bitmap bmap
= get_lang_bitmap (gt_files
[i
]);
452 error_at_line (&epos
, "file %s specified more than once "
453 "for language %s", line
, langno
== 0
455 : lang_dir_names
[langno
- 1]);
458 set_lang_bitmap (CONST_CAST(char *, gt_files
[i
]), bmap
);
463 set_lang_bitmap (line
, curlangs
);
464 gt_files
[nfiles
++] = line
;
467 /* Update the global counts now that we know accurately how many
468 things there are. (We do not bother resizing the arrays down.) */
469 num_lang_dirs
= langno
;
470 /* Add the plugin files if provided. */
474 for (i
= 0; i
< nb_plugin_files
; i
++)
475 gt_files
[nfiles
++] = plugin_files
[i
];
477 num_gt_files
= nfiles
;
480 /* Sanity check: any file that resides in a language subdirectory
481 (e.g. 'cp') ought to belong to the corresponding language.
482 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
483 (Can you even do that? Should you be allowed to?) */
486 for (f
= 0; f
< num_gt_files
; f
++)
488 lang_bitmap bitmap
= get_lang_bitmap (gt_files
[f
]);
489 const char *basename
= get_file_basename (gt_files
[f
]);
490 const char *slashpos
= strchr (basename
, '/');
495 for (l
= 0; l
< num_lang_dirs
; l
++)
496 if ((size_t)(slashpos
- basename
) == strlen (lang_dir_names
[l
])
497 && memcmp (basename
, lang_dir_names
[l
],
498 strlen (lang_dir_names
[l
])) == 0)
500 if (!(bitmap
& (1 << l
)))
501 error ("%s is in language directory '%s' but is not "
502 "tagged for that language",
503 basename
, lang_dir_names
[l
]);
511 fatal ("error reading %s: %s", listname
, xstrerror (errno
));
518 /* The one and only TYPE_STRING. */
520 static struct type string_type
= {
521 TYPE_STRING
, 0, 0, GC_USED
, {0}
524 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
525 set to appropriate values at the beginning of main. */
527 static struct type scalar_nonchar
= {
528 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
530 static struct type scalar_char
= {
531 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
534 /* Lists of various things. */
536 static pair_p typedefs
;
537 static type_p structures
;
538 static type_p param_structs
;
539 static pair_p variables
;
541 static type_p find_param_structure
542 (type_p t
, type_p param
[NUM_PARAM
]);
543 static type_p
adjust_field_tree_exp (type_p t
, options_p opt
);
544 static type_p
adjust_field_rtx_def (type_p t
, options_p opt
);
546 /* Define S as a typedef to T at POS. */
549 do_typedef (const char *s
, type_p t
, struct fileloc
*pos
)
553 /* temporary kludge - gengtype doesn't handle conditionals or
554 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
555 is coming from this file (main() sets them up with safe dummy
557 if (!strcmp (s
, "CUMULATIVE_ARGS") && pos
->file
!= this_file
)
560 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
561 if (strcmp (p
->name
, s
) == 0)
565 error_at_line (pos
, "type `%s' previously defined", s
);
566 error_at_line (&p
->line
, "previously defined here");
571 p
= XNEW (struct pair
);
580 /* Define S as a typename of a scalar. Cannot be used to define
581 typedefs of 'char'. Note: is also used for pointer-to-function
582 typedefs (which are therefore not treated as pointers). */
585 do_scalar_typedef (const char *s
, struct fileloc
*pos
)
587 do_typedef (s
, &scalar_nonchar
, pos
);
590 /* Return the type previously defined for S. Use POS to report errors. */
593 resolve_typedef (const char *s
, struct fileloc
*pos
)
596 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
597 if (strcmp (p
->name
, s
) == 0)
599 error_at_line (pos
, "unidentified type `%s'", s
);
600 return &scalar_nonchar
; /* treat as "int" */
603 /* Create and return a new structure with tag NAME (or a union iff
604 ISUNION is nonzero), at POS with fields FIELDS and options O. */
607 new_structure (const char *name
, int isunion
, struct fileloc
*pos
,
608 pair_p fields
, options_p o
)
612 lang_bitmap bitmap
= get_lang_bitmap (pos
->file
);
614 /* temporary kludge - gengtype doesn't handle conditionals or
615 macros. Ignore any attempt to define struct location_s, unless
616 it is coming from this file (main() sets it up safely). */
617 if (!strcmp (name
, "location_s") && !isunion
618 && pos
->file
!= this_file
)
619 return find_structure (name
, 0);
621 for (si
= structures
; si
!= NULL
; si
= si
->next
)
622 if (strcmp (name
, si
->u
.s
.tag
) == 0
623 && UNION_P (si
) == isunion
)
626 if (si
->kind
== TYPE_LANG_STRUCT
)
630 for (si
= ls
->u
.s
.lang_struct
; si
!= NULL
; si
= si
->next
)
631 if (si
->u
.s
.bitmap
== bitmap
)
634 else if (si
->u
.s
.line
.file
!= NULL
&& si
->u
.s
.bitmap
!= bitmap
)
637 si
= XCNEW (struct type
);
638 memcpy (si
, ls
, sizeof (struct type
));
639 ls
->kind
= TYPE_LANG_STRUCT
;
640 ls
->u
.s
.lang_struct
= si
;
641 ls
->u
.s
.fields
= NULL
;
643 si
->pointer_to
= NULL
;
644 si
->u
.s
.lang_struct
= ls
;
649 if (ls
!= NULL
&& s
== NULL
)
651 s
= XCNEW (struct type
);
652 s
->next
= ls
->u
.s
.lang_struct
;
653 ls
->u
.s
.lang_struct
= s
;
654 s
->u
.s
.lang_struct
= ls
;
661 s
= XCNEW (struct type
);
662 s
->next
= structures
;
666 if (s
->u
.s
.line
.file
!= NULL
667 || (s
->u
.s
.lang_struct
&& (s
->u
.s
.lang_struct
->u
.s
.bitmap
& bitmap
)))
669 error_at_line (pos
, "duplicate definition of '%s %s'",
670 isunion
? "union" : "struct", s
->u
.s
.tag
);
671 error_at_line (&s
->u
.s
.line
, "previous definition here");
674 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
677 s
->u
.s
.fields
= fields
;
679 s
->u
.s
.bitmap
= bitmap
;
680 if (s
->u
.s
.lang_struct
)
681 s
->u
.s
.lang_struct
->u
.s
.bitmap
|= bitmap
;
683 /* Reset location_s's location to input.h so that we know where to
684 write out its mark routine. */
685 if (!strcmp (name
, "location_s") && !isunion
686 && pos
->file
== this_file
)
689 for (n
= 0; n
< num_gt_files
; n
++)
690 if (!strcmp (gt_files
[n
] + strlen (gt_files
[n
]) - strlen ("input.h"),
693 s
->u
.s
.line
.file
= gt_files
[n
];
701 /* Return the previously-defined structure with tag NAME (or a union
702 iff ISUNION is nonzero), or a new empty structure or union if none
703 was defined previously. */
706 find_structure (const char *name
, int isunion
)
710 for (s
= structures
; s
!= NULL
; s
= s
->next
)
711 if (strcmp (name
, s
->u
.s
.tag
) == 0
712 && UNION_P (s
) == isunion
)
715 s
= XCNEW (struct type
);
716 s
->next
= structures
;
718 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
724 /* Return the previously-defined parameterized structure for structure
725 T and parameters PARAM, or a new parameterized empty structure or
726 union if none was defined previously. */
729 find_param_structure (type_p t
, type_p param
[NUM_PARAM
])
733 for (res
= param_structs
; res
; res
= res
->next
)
734 if (res
->u
.param_struct
.stru
== t
735 && memcmp (res
->u
.param_struct
.param
, param
,
736 sizeof (type_p
) * NUM_PARAM
) == 0)
740 res
= XCNEW (struct type
);
741 res
->kind
= TYPE_PARAM_STRUCT
;
742 res
->next
= param_structs
;
744 res
->u
.param_struct
.stru
= t
;
745 memcpy (res
->u
.param_struct
.param
, param
, sizeof (type_p
) * NUM_PARAM
);
750 /* Return a scalar type with name NAME. */
753 create_scalar_type (const char *name
)
755 if (!strcmp (name
, "char") || !strcmp (name
, "unsigned char"))
758 return &scalar_nonchar
;
761 /* Return a pointer to T. */
764 create_pointer (type_p t
)
768 type_p r
= XCNEW (struct type
);
769 r
->kind
= TYPE_POINTER
;
773 return t
->pointer_to
;
776 /* Return an array of length LEN. */
779 create_array (type_p t
, const char *len
)
783 v
= XCNEW (struct type
);
784 v
->kind
= TYPE_ARRAY
;
790 /* Return an options structure with name NAME and info INFO. NEXT is the
791 next option in the chain. */
794 create_option (options_p next
, const char *name
, const void *info
)
796 options_p o
= XNEW (struct options
);
799 o
->info
= (const char*) info
;
803 /* Return an options structure for a "nested_ptr" option. */
805 create_nested_ptr_option (options_p next
, type_p t
,
806 const char *to
, const char *from
)
808 struct nested_ptr_data
*d
= XNEW (struct nested_ptr_data
);
810 d
->type
= adjust_field_type (t
, 0);
812 d
->convert_from
= from
;
813 return create_option (next
, "nested_ptr", d
);
816 /* Add a variable named S of type T with options O defined at POS,
820 note_variable (const char *s
, type_p t
, options_p o
, struct fileloc
*pos
)
823 n
= XNEW (struct pair
);
832 /* Most-general structure field creator. */
834 create_field_all (pair_p next
, type_p type
, const char *name
, options_p opt
,
835 const char *file
, int line
)
839 field
= XNEW (struct pair
);
844 field
->line
.file
= file
;
845 field
->line
.line
= line
;
849 /* Create a field that came from the source code we are scanning,
850 i.e. we have a 'struct fileloc', and possibly options; also,
851 adjust_field_type should be called. */
853 create_field_at (pair_p next
, type_p type
, const char *name
, options_p opt
,
856 return create_field_all (next
, adjust_field_type (type
, opt
),
857 name
, opt
, pos
->file
, pos
->line
);
860 /* Create a fake field with the given type and name. NEXT is the next
861 field in the chain. */
862 #define create_field(next,type,name) \
863 create_field_all(next,type,name, 0, this_file, __LINE__)
865 /* Like create_field, but the field is only valid when condition COND
869 create_optional_field_ (pair_p next
, type_p type
, const char *name
,
870 const char *cond
, int line
)
876 /* Create a fake union type with a single nameless field of type TYPE.
877 The field has a tag of "1". This allows us to make the presence
878 of a field of type TYPE depend on some boolean "desc" being true. */
879 union_fields
= create_field (NULL
, type
, "");
880 union_fields
->opt
= create_option (union_fields
->opt
, "dot", "");
881 union_fields
->opt
= create_option (union_fields
->opt
, "tag", "1");
882 union_type
= new_structure (xasprintf ("%s_%d", "fake_union", id
++), 1,
883 &lexer_line
, union_fields
, NULL
);
885 /* Create the field and give it the new fake union type. Add a "desc"
886 tag that specifies the condition under which the field is valid. */
887 return create_field_all (next
, union_type
, name
,
888 create_option (0, "desc", cond
),
891 #define create_optional_field(next,type,name,cond) \
892 create_optional_field_(next,type,name,cond,__LINE__)
894 /* Reverse a linked list of 'struct pair's in place. */
896 nreverse_pairs (pair_p list
)
898 pair_p prev
= 0, p
, next
;
899 for (p
= list
; p
; p
= next
)
909 /* We don't care how long a CONST_DOUBLE is. */
910 #define CONST_DOUBLE_FORMAT "ww"
911 /* We don't want to see codes that are only for generator files. */
912 #undef GENERATOR_FILE
915 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
921 static const char * const rtx_name
[NUM_RTX_CODE
] = {
922 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
927 static const char * const rtx_format
[NUM_RTX_CODE
] = {
928 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
933 static int rtx_next_new
[NUM_RTX_CODE
];
935 /* We also need codes and names for insn notes (not register notes).
936 Note that we do *not* bias the note values here. */
938 #define DEF_INSN_NOTE(NAME) NAME,
939 #include "insn-notes.def"
945 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
946 default field for line number notes. */
947 static const char *const note_insn_name
[NOTE_INSN_MAX
+1] = {
948 #define DEF_INSN_NOTE(NAME) #NAME,
949 #include "insn-notes.def"
953 #undef CONST_DOUBLE_FORMAT
954 #define GENERATOR_FILE
956 /* Generate the contents of the rtx_next array. This really doesn't belong
957 in gengtype at all, but it's needed for adjust_field_rtx_def. */
963 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
967 rtx_next_new
[i
] = -1;
968 if (strncmp (rtx_format
[i
], "iuu", 3) == 0)
970 else if (i
== COND_EXEC
|| i
== SET
|| i
== EXPR_LIST
|| i
== INSN_LIST
)
973 for (k
= strlen (rtx_format
[i
]) - 1; k
>= 0; k
--)
974 if (rtx_format
[i
][k
] == 'e' || rtx_format
[i
][k
] == 'u')
979 /* Write out the contents of the rtx_next array. */
981 write_rtx_next (void)
983 outf_p f
= get_output_file_with_visibility (NULL
);
988 oprintf (f
, "\n/* Used to implement the RTX_NEXT macro. */\n");
989 oprintf (f
, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
990 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
991 if (rtx_next_new
[i
] == -1)
992 oprintf (f
, " 0,\n");
995 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n",
1000 /* Handle `special("rtx_def")'. This is a special case for field
1001 `fld' of struct rtx_def, which is an array of unions whose values
1002 are based in a complex way on the type of RTL. */
1005 adjust_field_rtx_def (type_p t
, options_p
ARG_UNUSED (opt
))
1010 type_p rtx_tp
, rtvec_tp
, tree_tp
, mem_attrs_tp
, note_union_tp
, scalar_tp
;
1011 type_p basic_block_tp
, reg_attrs_tp
, constant_tp
, symbol_union_tp
;
1013 if (t
->kind
!= TYPE_UNION
)
1015 error_at_line (&lexer_line
,
1016 "special `rtx_def' must be applied to a union");
1017 return &string_type
;
1020 nodot
= create_option (NULL
, "dot", "");
1022 rtx_tp
= create_pointer (find_structure ("rtx_def", 0));
1023 rtvec_tp
= create_pointer (find_structure ("rtvec_def", 0));
1024 tree_tp
= create_pointer (find_structure ("tree_node", 1));
1025 mem_attrs_tp
= create_pointer (find_structure ("mem_attrs", 0));
1026 reg_attrs_tp
= create_pointer (find_structure ("reg_attrs", 0));
1027 basic_block_tp
= create_pointer (find_structure ("basic_block_def", 0));
1028 constant_tp
= create_pointer (find_structure ("constant_descriptor_rtx", 0));
1029 scalar_tp
= &scalar_nonchar
; /* rtunion int */
1032 pair_p note_flds
= NULL
;
1035 for (c
= 0; c
<= NOTE_INSN_MAX
; c
++)
1040 case NOTE_INSN_DELETED_LABEL
:
1041 note_flds
= create_field (note_flds
, &string_type
, "rt_str");
1044 case NOTE_INSN_BLOCK_BEG
:
1045 case NOTE_INSN_BLOCK_END
:
1046 note_flds
= create_field (note_flds
, tree_tp
, "rt_tree");
1049 case NOTE_INSN_VAR_LOCATION
:
1050 note_flds
= create_field (note_flds
, rtx_tp
, "rt_rtx");
1054 note_flds
= create_field (note_flds
, scalar_tp
, "rt_int");
1057 /* NOTE_INSN_MAX is used as the default field for line
1059 if (c
== NOTE_INSN_MAX
)
1060 note_flds
->opt
= create_option (nodot
, "default", "");
1062 note_flds
->opt
= create_option (nodot
, "tag", note_insn_name
[c
]);
1064 note_union_tp
= new_structure ("rtx_def_note_subunion", 1,
1065 &lexer_line
, note_flds
, NULL
);
1067 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1071 sym_flds
= create_field (NULL
, tree_tp
, "rt_tree");
1072 sym_flds
->opt
= create_option (nodot
, "default", "");
1074 sym_flds
= create_field (sym_flds
, constant_tp
, "rt_constant");
1075 sym_flds
->opt
= create_option (nodot
, "tag", "1");
1077 symbol_union_tp
= new_structure ("rtx_def_symbol_subunion", 1,
1078 &lexer_line
, sym_flds
, NULL
);
1080 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1082 pair_p subfields
= NULL
;
1083 size_t aindex
, nmindex
;
1088 for (aindex
= 0; aindex
< strlen (rtx_format
[i
]); aindex
++)
1091 const char *subname
;
1093 switch (rtx_format
[i
][aindex
])
1104 if (i
== MEM
&& aindex
== 1)
1105 t
= mem_attrs_tp
, subname
= "rt_mem";
1106 else if (i
== JUMP_INSN
&& aindex
== 8)
1107 t
= rtx_tp
, subname
= "rt_rtx";
1108 else if (i
== CODE_LABEL
&& aindex
== 4)
1109 t
= scalar_tp
, subname
= "rt_int";
1110 else if (i
== CODE_LABEL
&& aindex
== 5)
1111 t
= rtx_tp
, subname
= "rt_rtx";
1112 else if (i
== LABEL_REF
1113 && (aindex
== 1 || aindex
== 2))
1114 t
= rtx_tp
, subname
= "rt_rtx";
1115 else if (i
== NOTE
&& aindex
== 4)
1116 t
= note_union_tp
, subname
= "";
1117 else if (i
== NOTE
&& aindex
== 5)
1118 t
= scalar_tp
, subname
= "rt_int";
1119 else if (i
== NOTE
&& aindex
>= 7)
1120 t
= scalar_tp
, subname
= "rt_int";
1121 else if (i
== ADDR_DIFF_VEC
&& aindex
== 4)
1122 t
= scalar_tp
, subname
= "rt_int";
1123 else if (i
== VALUE
&& aindex
== 0)
1124 t
= scalar_tp
, subname
= "rt_int";
1125 else if (i
== DEBUG_EXPR
&& aindex
== 0)
1126 t
= tree_tp
, subname
= "rt_tree";
1127 else if (i
== REG
&& aindex
== 1)
1128 t
= scalar_tp
, subname
= "rt_int";
1129 else if (i
== REG
&& aindex
== 2)
1130 t
= reg_attrs_tp
, subname
= "rt_reg";
1131 else if (i
== SCRATCH
&& aindex
== 0)
1132 t
= scalar_tp
, subname
= "rt_int";
1133 else if (i
== SYMBOL_REF
&& aindex
== 1)
1134 t
= scalar_tp
, subname
= "rt_int";
1135 else if (i
== SYMBOL_REF
&& aindex
== 2)
1136 t
= symbol_union_tp
, subname
= "";
1137 else if (i
== BARRIER
&& aindex
>= 3)
1138 t
= scalar_tp
, subname
= "rt_int";
1141 error_at_line (&lexer_line
,
1142 "rtx type `%s' has `0' in position %lu, can't handle",
1143 rtx_name
[i
], (unsigned long) aindex
);
1165 subname
= "rt_rtvec";
1170 subname
= "rt_tree";
1179 error_at_line (&lexer_line
,
1180 "rtx type `%s' has `%c' in position %lu, can't handle",
1181 rtx_name
[i
], rtx_format
[i
][aindex
],
1182 (unsigned long)aindex
);
1188 subfields
= create_field (subfields
, t
,
1189 xasprintf (".fld[%lu].%s",
1190 (unsigned long) aindex
,
1192 subfields
->opt
= nodot
;
1193 if (t
== note_union_tp
)
1194 subfields
->opt
= create_option (subfields
->opt
, "desc",
1196 if (t
== symbol_union_tp
)
1197 subfields
->opt
= create_option (subfields
->opt
, "desc",
1198 "CONSTANT_POOL_ADDRESS_P (&%0)");
1201 if (i
== SYMBOL_REF
)
1203 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds. */
1204 type_p field_tp
= find_structure ("block_symbol", 0);
1206 = create_optional_field (subfields
, field_tp
, "block_sym",
1207 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1210 sname
= xasprintf ("rtx_def_%s", rtx_name
[i
]);
1211 substruct
= new_structure (sname
, 0, &lexer_line
, subfields
, NULL
);
1213 ftag
= xstrdup (rtx_name
[i
]);
1214 for (nmindex
= 0; nmindex
< strlen (ftag
); nmindex
++)
1215 ftag
[nmindex
] = TOUPPER (ftag
[nmindex
]);
1217 flds
= create_field (flds
, substruct
, "");
1218 flds
->opt
= create_option (nodot
, "tag", ftag
);
1221 return new_structure ("rtx_def_subunion", 1, &lexer_line
, flds
, nodot
);
1224 /* Handle `special("tree_exp")'. This is a special case for
1225 field `operands' of struct tree_exp, which although it claims to contain
1226 pointers to trees, actually sometimes contains pointers to RTL too.
1227 Passed T, the old type of the field, and OPT its options. Returns
1228 a new type for the field. */
1231 adjust_field_tree_exp (type_p t
, options_p opt ATTRIBUTE_UNUSED
)
1236 if (t
->kind
!= TYPE_ARRAY
)
1238 error_at_line (&lexer_line
,
1239 "special `tree_exp' must be applied to an array");
1240 return &string_type
;
1243 nodot
= create_option (NULL
, "dot", "");
1245 flds
= create_field (NULL
, t
, "");
1246 flds
->opt
= create_option (nodot
, "length",
1247 "TREE_OPERAND_LENGTH ((tree) &%0)");
1248 flds
->opt
= create_option (flds
->opt
, "default", "");
1250 return new_structure ("tree_exp_subunion", 1, &lexer_line
, flds
, nodot
);
1253 /* Perform any special processing on a type T, about to become the type
1254 of a field. Return the appropriate type for the field.
1256 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1257 - Similarly for arrays of pointer-to-char;
1258 - Converts structures for which a parameter is provided to
1260 - Handles "special" options.
1264 adjust_field_type (type_p t
, options_p opt
)
1267 const int pointer_p
= t
->kind
== TYPE_POINTER
;
1268 type_p params
[NUM_PARAM
];
1272 for (i
= 0; i
< NUM_PARAM
; i
++)
1275 for (; opt
; opt
= opt
->next
)
1276 if (strcmp (opt
->name
, "length") == 0)
1278 else if (strcmp (opt
->name
, "param_is") == 0
1279 || (strncmp (opt
->name
, "param", 5) == 0
1280 && ISDIGIT (opt
->name
[5])
1281 && strcmp (opt
->name
+ 6, "_is") == 0))
1283 int num
= ISDIGIT (opt
->name
[5]) ? opt
->name
[5] - '0' : 0;
1285 if (! UNION_OR_STRUCT_P (t
)
1286 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
1288 error_at_line (&lexer_line
,
1289 "option `%s' may only be applied to structures or structure pointers",
1295 if (params
[num
] != NULL
)
1296 error_at_line (&lexer_line
, "duplicate `%s' option", opt
->name
);
1297 if (! ISDIGIT (opt
->name
[5]))
1298 params
[num
] = create_pointer (CONST_CAST2(type_p
, const char *, opt
->info
));
1300 params
[num
] = CONST_CAST2 (type_p
, const char *, opt
->info
);
1302 else if (strcmp (opt
->name
, "special") == 0)
1304 const char *special_name
= opt
->info
;
1305 if (strcmp (special_name
, "tree_exp") == 0)
1306 t
= adjust_field_tree_exp (t
, opt
);
1307 else if (strcmp (special_name
, "rtx_def") == 0)
1308 t
= adjust_field_rtx_def (t
, opt
);
1310 error_at_line (&lexer_line
, "unknown special `%s'", special_name
);
1319 realt
= find_param_structure (t
, params
);
1320 t
= pointer_p
? create_pointer (realt
) : realt
;
1325 && t
->u
.p
->kind
== TYPE_SCALAR
1326 && t
->u
.p
->u
.scalar_is_char
)
1327 return &string_type
;
1328 if (t
->kind
== TYPE_ARRAY
&& t
->u
.a
.p
->kind
== TYPE_POINTER
1329 && t
->u
.a
.p
->u
.p
->kind
== TYPE_SCALAR
1330 && t
->u
.a
.p
->u
.p
->u
.scalar_is_char
)
1331 return create_array (&string_type
, t
->u
.a
.len
);
1337 static void set_gc_used_type (type_p
, enum gc_used_enum
, type_p
*);
1338 static void set_gc_used (pair_p
);
1340 /* Handle OPT for set_gc_used_type. */
1343 process_gc_options (options_p opt
, enum gc_used_enum level
, int *maybe_undef
,
1344 int *pass_param
, int *length
, int *skip
, type_p
*nested_ptr
)
1347 for (o
= opt
; o
; o
= o
->next
)
1348 if (strcmp (o
->name
, "ptr_alias") == 0 && level
== GC_POINTED_TO
)
1349 set_gc_used_type (CONST_CAST2 (type_p
, const char *, o
->info
),
1350 GC_POINTED_TO
, NULL
);
1351 else if (strcmp (o
->name
, "maybe_undef") == 0)
1353 else if (strcmp (o
->name
, "use_params") == 0)
1355 else if (strcmp (o
->name
, "length") == 0)
1357 else if (strcmp (o
->name
, "skip") == 0)
1359 else if (strcmp (o
->name
, "nested_ptr") == 0)
1360 *nested_ptr
= ((const struct nested_ptr_data
*) o
->info
)->type
;
1363 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1366 set_gc_used_type (type_p t
, enum gc_used_enum level
, type_p param
[NUM_PARAM
])
1368 if (t
->gc_used
>= level
)
1382 process_gc_options (t
->u
.s
.opt
, level
, &dummy
, &dummy
, &dummy
, &dummy
,
1385 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
1387 int maybe_undef
= 0;
1391 type_p nested_ptr
= NULL
;
1392 process_gc_options (f
->opt
, level
, &maybe_undef
, &pass_param
,
1393 &length
, &skip
, &nested_ptr
);
1395 if (nested_ptr
&& f
->type
->kind
== TYPE_POINTER
)
1396 set_gc_used_type (nested_ptr
, GC_POINTED_TO
,
1397 pass_param
? param
: NULL
);
1398 else if (length
&& f
->type
->kind
== TYPE_POINTER
)
1399 set_gc_used_type (f
->type
->u
.p
, GC_USED
, NULL
);
1400 else if (maybe_undef
&& f
->type
->kind
== TYPE_POINTER
)
1401 set_gc_used_type (f
->type
->u
.p
, GC_MAYBE_POINTED_TO
, NULL
);
1402 else if (pass_param
&& f
->type
->kind
== TYPE_POINTER
&& param
)
1403 set_gc_used_type (find_param_structure (f
->type
->u
.p
, param
),
1404 GC_POINTED_TO
, NULL
);
1406 ; /* target type is not used through this field */
1408 set_gc_used_type (f
->type
, GC_USED
, pass_param
? param
: NULL
);
1414 set_gc_used_type (t
->u
.p
, GC_POINTED_TO
, NULL
);
1418 set_gc_used_type (t
->u
.a
.p
, GC_USED
, param
);
1421 case TYPE_LANG_STRUCT
:
1422 for (t
= t
->u
.s
.lang_struct
; t
; t
= t
->next
)
1423 set_gc_used_type (t
, level
, param
);
1426 case TYPE_PARAM_STRUCT
:
1429 for (i
= 0; i
< NUM_PARAM
; i
++)
1430 if (t
->u
.param_struct
.param
[i
] != 0)
1431 set_gc_used_type (t
->u
.param_struct
.param
[i
], GC_USED
, NULL
);
1433 if (t
->u
.param_struct
.stru
->gc_used
== GC_POINTED_TO
)
1434 level
= GC_POINTED_TO
;
1437 t
->u
.param_struct
.stru
->gc_used
= GC_UNUSED
;
1438 set_gc_used_type (t
->u
.param_struct
.stru
, level
,
1439 t
->u
.param_struct
.param
);
1447 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1450 set_gc_used (pair_p variables
)
1453 for (p
= variables
; p
; p
= p
->next
)
1454 set_gc_used_type (p
->type
, GC_USED
, NULL
);
1457 /* File mapping routines. For each input file, there is one output .c file
1458 (but some output files have many input files), and there is one .h file
1459 for the whole build. */
1461 /* Output file handling. */
1463 /* Create and return an outf_p for a new file for NAME, to be called
1467 create_file (const char *name
, const char *oname
)
1469 static const char *const hdr
[] = {
1470 " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n",
1472 "This file is part of GCC.\n",
1474 "GCC is free software; you can redistribute it and/or modify it under\n",
1475 "the terms of the GNU General Public License as published by the Free\n",
1476 "Software Foundation; either version 3, or (at your option) any later\n",
1479 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1480 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1481 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1482 "for more details.\n",
1484 "You should have received a copy of the GNU General Public License\n",
1485 "along with GCC; see the file COPYING3. If not see\n",
1486 "<http://www.gnu.org/licenses/>. */\n",
1488 "/* This file is machine generated. Do not edit. */\n"
1493 gcc_assert (name
!= NULL
);
1494 gcc_assert (oname
!= NULL
);
1495 f
= XCNEW (struct outf
);
1496 f
->next
= output_files
;
1500 oprintf (f
, "/* Type information for %s.\n", name
);
1501 for (i
= 0; i
< ARRAY_SIZE (hdr
); i
++)
1502 oprintf (f
, "%s", hdr
[i
]);
1506 /* Print, like fprintf, to O.
1507 N.B. You might think this could be implemented more efficiently
1508 with vsnprintf(). Unfortunately, there are C libraries that
1509 provide that function but without the C99 semantics for its return
1510 value, making it impossible to know how much space is required. */
1512 oprintf (outf_p o
, const char *format
, ...)
1518 /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1523 va_start (ap
, format
);
1524 slength
= vasprintf (&s
, format
, ap
);
1525 if (s
== NULL
|| (int)slength
< 0)
1526 fatal ("out of memory");
1529 if (o
->bufused
+ slength
> o
->buflength
)
1531 size_t new_len
= o
->buflength
;
1536 } while (o
->bufused
+ slength
>= new_len
);
1537 o
->buf
= XRESIZEVEC (char, o
->buf
, new_len
);
1538 o
->buflength
= new_len
;
1540 memcpy (o
->buf
+ o
->bufused
, s
, slength
);
1541 o
->bufused
+= slength
;
1545 /* Open the global header file and the language-specific header files. */
1548 open_base_files (void)
1552 if (nb_plugin_files
> 0 && plugin_files
)
1555 header_file
= create_file ("GCC", "gtype-desc.h");
1557 base_files
= XNEWVEC (outf_p
, num_lang_dirs
);
1559 for (i
= 0; i
< num_lang_dirs
; i
++)
1560 base_files
[i
] = create_file (lang_dir_names
[i
],
1561 xasprintf ("gtype-%s.h", lang_dir_names
[i
]));
1563 /* gtype-desc.c is a little special, so we create it here. */
1565 /* The order of files here matters very much. */
1566 static const char *const ifiles
[] = {
1567 "config.h", "system.h", "coretypes.h", "tm.h",
1568 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1569 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1570 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1571 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1572 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1573 "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h",
1574 "target.h", "ipa-prop.h", "lto-streamer.h", NULL
1576 const char *const *ifp
;
1577 outf_p gtype_desc_c
;
1579 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1580 for (ifp
= ifiles
; *ifp
; ifp
++)
1581 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1583 /* Make sure we handle "cfun" specially. */
1584 oprintf (gtype_desc_c
, "\n/* See definition in function.h. */\n");
1585 oprintf (gtype_desc_c
, "#undef cfun\n");
1589 /* For F a filename, return the real basename of F, with all the directory
1590 components skipped. */
1593 get_file_realbasename (const char *f
)
1595 const char * lastslash
= strrchr (f
, '/');
1597 return (lastslash
!= NULL
) ? lastslash
+ 1 : f
;
1600 /* For F a filename, return the relative path to F from $(srcdir) if the
1601 latter is a prefix in F, NULL otherwise. */
1604 get_file_srcdir_relative_path (const char *f
)
1606 if (strlen (f
) > srcdir_len
1607 && IS_DIR_SEPARATOR (f
[srcdir_len
])
1608 && memcmp (f
, srcdir
, srcdir_len
) == 0)
1609 return f
+ srcdir_len
+ 1;
1614 /* For F a filename, return the relative path to F from $(srcdir) if the
1615 latter is a prefix in F, or the real basename of F otherwise. */
1618 get_file_basename (const char *f
)
1620 const char * srcdir_path
= get_file_srcdir_relative_path (f
);
1622 return (srcdir_path
!= NULL
) ? srcdir_path
: get_file_realbasename (f
);
1625 /* For F a filename, return the lang_dir_names relative index of the language
1626 directory that is a prefix in F, if any, -1 otherwise. */
1629 get_prefix_langdir_index (const char *f
)
1631 size_t f_len
= strlen (f
);
1634 for (lang_index
= 0; lang_index
< num_lang_dirs
; lang_index
++)
1636 const char * langdir
= lang_dir_names
[lang_index
];
1637 size_t langdir_len
= strlen (langdir
);
1639 if (f_len
> langdir_len
1640 && IS_DIR_SEPARATOR (f
[langdir_len
])
1641 && memcmp (f
, langdir
, langdir_len
) == 0)
1648 /* For F a filename, return the name of language directory where F is located,
1649 if any, NULL otherwise. */
1652 get_file_langdir (const char *f
)
1654 /* Get the relative path to F from $(srcdir) and find the language by
1655 comparing the prefix with language directory names. If F is not even
1656 srcdir relative, no point in looking further. */
1659 const char * srcdir_relative_path
= get_file_srcdir_relative_path (f
);
1662 if (!srcdir_relative_path
)
1665 lang_index
= get_prefix_langdir_index (srcdir_relative_path
);
1667 && strncmp (srcdir_relative_path
, "c-family", 8) == 0)
1669 else if (lang_index
>= 0)
1670 r
= lang_dir_names
[lang_index
];
1677 /* The gt- output file name for F. */
1680 get_file_gtfilename (const char *f
)
1682 /* Cook up an initial version of the gt- file name from the file real
1683 basename and the language name, if any. */
1685 const char *basename
= get_file_realbasename (f
);
1686 const char *langdir
= get_file_langdir (f
);
1689 (langdir
? xasprintf ("gt-%s-%s", langdir
, basename
)
1690 : xasprintf ("gt-%s", basename
));
1692 /* Then replace all non alphanumerics characters by '-' and change the
1693 extension to ".h". We expect the input filename extension was at least
1694 one character long. */
1698 for (; *s
!= '.'; s
++)
1699 if (! ISALNUM (*s
) && *s
!= '-')
1702 memcpy (s
, ".h", sizeof (".h"));
1707 /* An output file, suitable for definitions, that can see declarations
1708 made in INPUT_FILE and is linked into every language that uses
1712 get_output_file_with_visibility (const char *input_file
)
1716 const char *basename
;
1717 const char *for_name
;
1718 const char *output_name
;
1720 /* This can happen when we need a file with visibility on a
1721 structure that we've never seen. We have to just hope that it's
1722 globally visible. */
1723 if (input_file
== NULL
)
1724 input_file
= "system.h";
1726 /* In plugin mode, return NULL unless the input_file is one of the
1731 for (i
= 0; i
< nb_plugin_files
; i
++)
1732 if (strcmp (input_file
, plugin_files
[i
]) == 0)
1733 return plugin_output
;
1738 /* Determine the output file name. */
1739 basename
= get_file_basename (input_file
);
1741 len
= strlen (basename
);
1742 if ((len
> 2 && memcmp (basename
+len
-2, ".c", 2) == 0)
1743 || (len
> 2 && memcmp (basename
+len
-2, ".y", 2) == 0)
1744 || (len
> 3 && memcmp (basename
+len
-3, ".in", 3) == 0))
1746 output_name
= get_file_gtfilename (input_file
);
1747 for_name
= basename
;
1749 /* Some headers get used by more than one front-end; hence, it
1750 would be inappropriate to spew them out to a single gtype-<lang>.h
1751 (and gengtype doesn't know how to direct spewage into multiple
1752 gtype-<lang>.h headers at this time). Instead, we pair up these
1753 headers with source files (and their special purpose gt-*.h headers). */
1754 else if (strncmp (basename
, "c-family", 8) == 0
1755 && IS_DIR_SEPARATOR (basename
[8])
1756 && strcmp (basename
+ 9, "c-common.h") == 0)
1757 output_name
= "gt-c-family-c-common.h", for_name
= "c-family/c-common.c";
1758 else if (strcmp (basename
, "c-lang.h") == 0)
1759 output_name
= "gt-c-decl.h", for_name
= "c-decl.c";
1760 else if (strcmp (basename
, "c-tree.h") == 0)
1761 output_name
= "gt-c-decl.h", for_name
= "c-decl.c";
1762 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1763 && strcmp (basename
+ 3, "cp-tree.h") == 0)
1764 output_name
= "gt-cp-tree.h", for_name
= "cp/tree.c";
1765 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1766 && strcmp (basename
+ 3, "decl.h") == 0)
1767 output_name
= "gt-cp-decl.h", for_name
= "cp/decl.c";
1768 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1769 && strcmp (basename
+ 3, "name-lookup.h") == 0)
1770 output_name
= "gt-cp-name-lookup.h", for_name
= "cp/name-lookup.c";
1771 else if (strncmp (basename
, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename
[4])
1772 && strcmp (basename
+ 5, "objc-act.h") == 0)
1773 output_name
= "gt-objc-objc-act.h", for_name
= "objc/objc-act.c";
1776 int lang_index
= get_prefix_langdir_index (basename
);
1778 if (lang_index
>= 0)
1779 return base_files
[lang_index
];
1781 output_name
= "gtype-desc.c";
1785 /* Look through to see if we've ever seen this output filename before. */
1786 for (r
= output_files
; r
; r
= r
->next
)
1787 if (strcmp (r
->name
, output_name
) == 0)
1790 /* If not, create it. */
1791 r
= create_file (for_name
, output_name
);
1793 gcc_assert (r
&& r
->name
);
1797 /* The name of an output file, suitable for definitions, that can see
1798 declarations made in INPUT_FILE and is linked into every language
1799 that uses INPUT_FILE. */
1802 get_output_file_name (const char *input_file
)
1804 outf_p o
= get_output_file_with_visibility (input_file
);
1810 /* Check if existing file is equal to the in memory buffer. */
1813 is_file_equal (outf_p of
)
1815 FILE *newfile
= fopen (of
->name
, "r");
1818 if (newfile
== NULL
)
1822 for (i
= 0; i
< of
->bufused
; i
++)
1825 ch
= fgetc (newfile
);
1826 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
1836 /* Copy the output to its final destination,
1837 but don't unnecessarily change modification times. */
1840 close_output_files (void)
1844 for (of
= output_files
; of
; of
= of
->next
)
1847 if (!is_file_equal(of
))
1849 FILE *newfile
= fopen (of
->name
, "w");
1850 if (newfile
== NULL
)
1851 fatal ("opening output file %s: %s", of
->name
, xstrerror (errno
));
1852 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
1853 fatal ("writing output file %s: %s", of
->name
, xstrerror (errno
));
1854 if (fclose (newfile
) != 0)
1855 fatal ("closing output file %s: %s", of
->name
, xstrerror (errno
));
1859 of
->bufused
= of
->buflength
= 0;
1870 struct walk_type_data
;
1872 /* For scalars and strings, given the item in 'val'.
1873 For structures, given a pointer to the item in 'val'.
1874 For misc. pointers, given the item in 'val'.
1876 typedef void (*process_field_fn
)
1877 (type_p f
, const struct walk_type_data
*p
);
1878 typedef void (*func_name_fn
)
1879 (type_p s
, const struct walk_type_data
*p
);
1881 /* Parameters for write_types. */
1883 struct write_types_data
1886 const char *param_prefix
;
1887 const char *subfield_marker_routine
;
1888 const char *marker_routine
;
1889 const char *reorder_note_routine
;
1890 const char *comment
;
1891 int skip_hooks
; /* skip hook generation if non zero */
1894 static void output_escaped_param (struct walk_type_data
*d
,
1895 const char *, const char *);
1896 static void output_mangled_typename (outf_p
, const_type_p
);
1897 static void walk_type (type_p t
, struct walk_type_data
*d
);
1898 static void write_func_for_structure (type_p orig_s
, type_p s
, type_p
* param
,
1899 const struct write_types_data
*wtd
);
1900 static void write_types_process_field
1901 (type_p f
, const struct walk_type_data
*d
);
1902 static void write_types (outf_p output_header
,
1904 type_p param_structs
,
1905 const struct write_types_data
*wtd
);
1906 static void write_types_local_process_field
1907 (type_p f
, const struct walk_type_data
*d
);
1908 static void write_local_func_for_structure
1909 (const_type_p orig_s
, type_p s
, type_p
* param
);
1910 static void write_local (outf_p output_header
,
1912 type_p param_structs
);
1913 static void write_enum_defn (type_p structures
, type_p param_structs
);
1914 static int contains_scalar_p (type_p t
);
1915 static void put_mangled_filename (outf_p
, const char *);
1916 static void finish_root_table (struct flist
*flp
, const char *pfx
,
1917 const char *tname
, const char *lastname
,
1919 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
1920 struct fileloc
*, const char *, bool);
1921 static void write_array (outf_p f
, pair_p v
,
1922 const struct write_types_data
*wtd
);
1923 static void write_roots (pair_p
, bool);
1925 /* Parameters for walk_type. */
1927 struct walk_type_data
1929 process_field_fn process_field
;
1934 const char *prev_val
[4];
1937 const struct fileloc
*line
;
1942 const char *reorder_fn
;
1944 bool fn_wants_lvalue
;
1947 /* Print a mangled name representing T to OF. */
1950 output_mangled_typename (outf_p of
, const_type_p t
)
1954 else switch (t
->kind
)
1958 output_mangled_typename (of
, t
->u
.p
);
1968 case TYPE_LANG_STRUCT
:
1969 oprintf (of
, "%lu%s", (unsigned long) strlen (t
->u
.s
.tag
), t
->u
.s
.tag
);
1971 case TYPE_PARAM_STRUCT
:
1974 for (i
= 0; i
< NUM_PARAM
; i
++)
1975 if (t
->u
.param_struct
.param
[i
] != NULL
)
1976 output_mangled_typename (of
, t
->u
.param_struct
.param
[i
]);
1977 output_mangled_typename (of
, t
->u
.param_struct
.stru
);
1985 /* Print PARAM to D->OF processing escapes. D->VAL references the
1986 current object, D->PREV_VAL the object containing the current
1987 object, ONAME is the name of the option and D->LINE is used to
1988 print error messages. */
1991 output_escaped_param (struct walk_type_data
*d
, const char *param
,
1996 for (p
= param
; *p
; p
++)
1998 oprintf (d
->of
, "%c", *p
);
2002 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
2005 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
2008 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
2012 const char *pp
= d
->val
+ strlen (d
->val
);
2013 while (pp
[-1] == ']')
2016 oprintf (d
->of
, "%s", pp
);
2020 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
2025 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2026 which is of type T. Write code to D->OF to constrain execution (at
2027 the point that D->PROCESS_FIELD is called) to the appropriate
2028 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2029 pointers to those objects. D->PREV_VAL lists the objects
2030 containing the current object, D->OPT is a list of options to
2031 apply, D->INDENT is the current indentation level, D->LINE is used
2032 to print error messages, D->BITMAP indicates which languages to
2033 print the structure for, and D->PARAM is the current parameter
2034 (from an enclosing param_is option). */
2037 walk_type (type_p t
, struct walk_type_data
*d
)
2039 const char *length
= NULL
;
2040 const char *desc
= NULL
;
2041 int maybe_undef_p
= 0;
2042 int use_param_num
= -1;
2043 int use_params_p
= 0;
2045 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
2047 d
->needs_cast_p
= false;
2048 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
2049 if (strcmp (oo
->name
, "length") == 0)
2051 else if (strcmp (oo
->name
, "maybe_undef") == 0)
2053 else if (strncmp (oo
->name
, "use_param", 9) == 0
2054 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2055 use_param_num
= oo
->name
[9] == '\0' ? 0 : oo
->name
[9] - '0';
2056 else if (strcmp (oo
->name
, "use_params") == 0)
2058 else if (strcmp (oo
->name
, "desc") == 0)
2060 else if (strcmp (oo
->name
, "mark_hook") == 0)
2062 else if (strcmp (oo
->name
, "nested_ptr") == 0)
2063 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
;
2064 else if (strcmp (oo
->name
, "dot") == 0)
2066 else if (strcmp (oo
->name
, "tag") == 0)
2068 else if (strcmp (oo
->name
, "special") == 0)
2070 else if (strcmp (oo
->name
, "skip") == 0)
2072 else if (strcmp (oo
->name
, "default") == 0)
2074 else if (strcmp (oo
->name
, "descbits") == 0)
2076 else if (strcmp (oo
->name
, "param_is") == 0)
2078 else if (strncmp (oo
->name
, "param", 5) == 0
2079 && ISDIGIT (oo
->name
[5])
2080 && strcmp (oo
->name
+ 6, "_is") == 0)
2082 else if (strcmp (oo
->name
, "chain_next") == 0)
2084 else if (strcmp (oo
->name
, "chain_prev") == 0)
2086 else if (strcmp (oo
->name
, "chain_circular") == 0)
2088 else if (strcmp (oo
->name
, "reorder") == 0)
2090 else if (strcmp (oo
->name
, "variable_size") == 0)
2093 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
2100 int pointer_p
= t
->kind
== TYPE_POINTER
;
2104 if (! UNION_OR_STRUCT_P (t
))
2105 error_at_line (d
->line
, "`use_params' option on unimplemented type");
2107 t
= find_param_structure (t
, d
->param
);
2109 t
= create_pointer (t
);
2112 if (use_param_num
!= -1)
2114 if (d
->param
!= NULL
&& d
->param
[use_param_num
] != NULL
)
2116 type_p nt
= d
->param
[use_param_num
];
2118 if (t
->kind
== TYPE_ARRAY
)
2119 nt
= create_array (nt
, t
->u
.a
.len
);
2120 else if (length
!= NULL
&& t
->kind
== TYPE_POINTER
)
2121 nt
= create_pointer (nt
);
2122 d
->needs_cast_p
= (t
->kind
!= TYPE_POINTER
2123 && (nt
->kind
== TYPE_POINTER
2124 || nt
->kind
== TYPE_STRING
));
2128 error_at_line (d
->line
, "no parameter defined for `%s'",
2133 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
2135 error_at_line (d
->line
,
2136 "field `%s' has invalid option `maybe_undef_p'\n",
2145 d
->process_field (t
, d
);
2151 && t
->u
.p
->u
.s
.line
.file
== NULL
)
2153 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2159 if (! UNION_OR_STRUCT_P (t
->u
.p
)
2160 && t
->u
.p
->kind
!= TYPE_PARAM_STRUCT
)
2162 error_at_line (d
->line
,
2163 "field `%s' is pointer to unimplemented type",
2170 const char *oldprevval2
= d
->prev_val
[2];
2172 if (! UNION_OR_STRUCT_P (nested_ptr_d
->type
))
2174 error_at_line (d
->line
,
2175 "field `%s' has invalid "
2176 "option `nested_ptr'\n",
2181 d
->prev_val
[2] = d
->val
;
2182 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2184 d
->val
= xasprintf ("x%d", d
->counter
++);
2185 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2186 (nested_ptr_d
->type
->kind
== TYPE_UNION
2187 ? "union" : "struct"),
2188 nested_ptr_d
->type
->u
.s
.tag
,
2189 d
->fn_wants_lvalue
? "" : "const ",
2191 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2192 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2194 oprintf (d
->of
, ";\n");
2196 d
->process_field (nested_ptr_d
->type
, d
);
2198 if (d
->fn_wants_lvalue
)
2200 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2202 d
->prev_val
[2] = d
->val
;
2203 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2205 oprintf (d
->of
, ";\n");
2209 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2210 d
->val
= d
->prev_val
[2];
2211 d
->prev_val
[2] = oldprevval2
;
2214 d
->process_field (t
->u
.p
, d
);
2218 int loopcounter
= d
->counter
++;
2219 const char *oldval
= d
->val
;
2220 const char *oldprevval3
= d
->prev_val
[3];
2223 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2225 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2226 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
, "",
2227 loopcounter
, loopcounter
);
2228 output_escaped_param (d
, length
, "length");
2229 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2231 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2233 d
->prev_val
[3] = oldval
;
2234 walk_type (t
->u
.p
, d
);
2237 d
->prev_val
[3] = oldprevval3
;
2240 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2241 d
->process_field(t
, d
);
2243 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2250 int loopcounter
= d
->counter
++;
2251 const char *oldval
= d
->val
;
2254 /* If it's an array of scalars, we optimize by not generating
2256 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2259 /* When walking an array, compute the length and store it in a
2260 local variable before walking the array elements, instead of
2261 recomputing the length expression each time through the loop.
2262 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2263 where the length is stored in the first array element,
2264 because otherwise that operand can get overwritten on the
2266 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2268 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2269 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2270 d
->indent
, "", loopcounter
);
2272 output_escaped_param (d
, length
, "length");
2274 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2275 oprintf (d
->of
, ");\n");
2277 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2279 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2281 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2283 walk_type (t
->u
.a
.p
, d
);
2288 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2290 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2298 const char *oldval
= d
->val
;
2299 const char *oldprevval1
= d
->prev_val
[1];
2300 const char *oldprevval2
= d
->prev_val
[2];
2301 const int union_p
= t
->kind
== TYPE_UNION
;
2302 int seen_default_p
= 0;
2305 if (! t
->u
.s
.line
.file
)
2306 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2308 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2310 error_at_line (d
->line
,
2311 "structure `%s' defined for mismatching languages",
2313 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2316 /* Some things may also be defined in the structure's options. */
2317 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2318 if (! desc
&& strcmp (o
->name
, "desc") == 0)
2321 d
->prev_val
[2] = oldval
;
2322 d
->prev_val
[1] = oldprevval2
;
2327 error_at_line (d
->line
, "missing `desc' option for union `%s'",
2331 oprintf (d
->of
, "%*sswitch (", d
->indent
, "");
2332 output_escaped_param (d
, desc
, "desc");
2333 oprintf (d
->of
, ")\n");
2335 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2337 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
2340 const char *dot
= ".";
2341 const char *tagid
= NULL
;
2344 int use_param_p
= 0;
2347 d
->reorder_fn
= NULL
;
2348 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2349 if (strcmp (oo
->name
, "dot") == 0)
2351 else if (strcmp (oo
->name
, "tag") == 0)
2353 else if (strcmp (oo
->name
, "skip") == 0)
2355 else if (strcmp (oo
->name
, "default") == 0)
2357 else if (strcmp (oo
->name
, "reorder") == 0)
2358 d
->reorder_fn
= oo
->info
;
2359 else if (strncmp (oo
->name
, "use_param", 9) == 0
2360 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2366 if (union_p
&& tagid
)
2368 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
2371 else if (union_p
&& default_p
)
2373 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2377 else if (! union_p
&& (default_p
|| tagid
))
2378 error_at_line (d
->line
,
2379 "can't use `%s' outside a union on field `%s'",
2380 default_p
? "default" : "tag", f
->name
);
2381 else if (union_p
&& ! (default_p
|| tagid
)
2382 && f
->type
->kind
== TYPE_SCALAR
)
2385 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2386 d
->line
->file
, d
->line
->line
, f
->name
);
2389 else if (union_p
&& ! (default_p
|| tagid
))
2390 error_at_line (d
->line
,
2391 "field `%s' is missing `tag' or `default' option",
2395 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
2397 d
->used_length
= false;
2399 if (union_p
&& use_param_p
&& d
->param
== NULL
)
2400 oprintf (d
->of
, "%*sgcc_unreachable ();\n", d
->indent
, "");
2402 walk_type (f
->type
, d
);
2408 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2412 d
->reorder_fn
= NULL
;
2415 d
->prev_val
[1] = oldprevval1
;
2416 d
->prev_val
[2] = oldprevval2
;
2418 if (union_p
&& ! seen_default_p
)
2420 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2421 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
2425 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2431 case TYPE_LANG_STRUCT
:
2434 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
2435 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
2438 error_at_line (d
->line
, "structure `%s' differs between languages",
2445 case TYPE_PARAM_STRUCT
:
2447 type_p
*oldparam
= d
->param
;
2449 d
->param
= t
->u
.param_struct
.param
;
2450 walk_type (t
->u
.param_struct
.stru
, d
);
2451 d
->param
= oldparam
;
2460 /* process_field routine for marking routines. */
2463 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
2465 const struct write_types_data
*wtd
;
2466 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
2467 wtd
= (const struct write_types_data
*) d
->cookie
;
2472 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
2473 wtd
->subfield_marker_routine
, cast
, d
->val
);
2474 if (wtd
->param_prefix
)
2476 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
2479 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
2480 output_mangled_typename (d
->of
, d
->orig_s
);
2483 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
2485 if (f
->u
.p
->kind
== TYPE_PARAM_STRUCT
2486 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2488 oprintf (d
->of
, ", gt_e_");
2489 output_mangled_typename (d
->of
, f
);
2491 else if (UNION_OR_STRUCT_P (f
)
2492 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2494 oprintf (d
->of
, ", gt_ggc_e_");
2495 output_mangled_typename (d
->of
, f
);
2498 oprintf (d
->of
, ", gt_types_enum_last");
2500 oprintf (d
->of
, ");\n");
2501 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2502 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
2503 wtd
->reorder_note_routine
, cast
, d
->val
,
2504 d
->prev_val
[3], d
->reorder_fn
);
2510 case TYPE_LANG_STRUCT
:
2511 case TYPE_PARAM_STRUCT
:
2512 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
2513 output_mangled_typename (d
->of
, f
);
2514 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
2515 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2516 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
2517 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
2529 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2532 output_type_enum (outf_p of
, type_p s
)
2534 if (s
->kind
== TYPE_PARAM_STRUCT
&& s
->u
.s
.line
.file
!= NULL
)
2536 oprintf (of
, ", gt_e_");
2537 output_mangled_typename (of
, s
);
2539 else if (UNION_OR_STRUCT_P (s
) && s
->u
.s
.line
.file
!= NULL
)
2541 oprintf (of
, ", gt_ggc_e_");
2542 output_mangled_typename (of
, s
);
2545 oprintf (of
, ", gt_types_enum_last");
2548 /* Return an output file that is suitable for definitions which can
2549 reference struct S */
2552 get_output_file_for_structure (const_type_p s
, type_p
*param
)
2554 const char * fn
= s
->u
.s
.line
.file
;
2557 /* This is a hack, and not the good kind either. */
2558 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2559 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2560 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2561 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2563 return get_output_file_with_visibility (fn
);
2566 /* For S, a structure that's part of ORIG_S, and using parameters
2567 PARAM, write out a routine that:
2568 - Takes a parameter, a void * but actually of type *S
2569 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2570 field of S or its substructures and (in some cases) things
2571 that are pointed to by S.
2575 write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2576 const struct write_types_data
*wtd
)
2578 const char *chain_next
= NULL
;
2579 const char *chain_prev
= NULL
;
2580 const char *chain_circular
= NULL
;
2581 const char *mark_hook_name
= NULL
;
2583 struct walk_type_data d
;
2585 memset (&d
, 0, sizeof (d
));
2586 d
.of
= get_output_file_for_structure (s
, param
);
2588 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2589 if (strcmp (opt
->name
, "chain_next") == 0)
2590 chain_next
= opt
->info
;
2591 else if (strcmp (opt
->name
, "chain_prev") == 0)
2592 chain_prev
= opt
->info
;
2593 else if (strcmp (opt
->name
, "chain_circular") == 0)
2594 chain_circular
= opt
->info
;
2595 else if (strcmp (opt
->name
, "mark_hook") == 0)
2596 mark_hook_name
= opt
->info
;
2598 if (chain_prev
!= NULL
&& chain_next
== NULL
)
2599 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
2600 if (chain_circular
!= NULL
&& chain_next
!= NULL
)
2601 error_at_line (&s
->u
.s
.line
, "chain_circular with chain_next");
2602 if (chain_circular
!= NULL
)
2603 chain_next
= chain_circular
;
2605 d
.process_field
= write_types_process_field
;
2609 d
.line
= &s
->u
.s
.line
;
2610 d
.bitmap
= s
->u
.s
.bitmap
;
2612 d
.prev_val
[0] = "*x";
2613 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2614 d
.prev_val
[3] = "x";
2617 oprintf (d
.of
, "\n");
2618 oprintf (d
.of
, "void\n");
2620 oprintf (d
.of
, "gt_%sx_%s", wtd
->prefix
, orig_s
->u
.s
.tag
);
2623 oprintf (d
.of
, "gt_%s_", wtd
->prefix
);
2624 output_mangled_typename (d
.of
, orig_s
);
2626 oprintf (d
.of
, " (void *x_p)\n");
2627 oprintf (d
.of
, "{\n");
2628 oprintf (d
.of
, " %s %s * %sx = (%s %s *)x_p;\n",
2629 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2630 chain_next
== NULL
? "const " : "",
2631 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2632 if (chain_next
!= NULL
)
2633 oprintf (d
.of
, " %s %s * xlimit = x;\n",
2634 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2635 if (chain_next
== NULL
)
2637 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
2638 if (wtd
->param_prefix
)
2640 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
2641 output_mangled_typename (d
.of
, orig_s
);
2642 output_type_enum (d
.of
, orig_s
);
2644 oprintf (d
.of
, "))\n");
2648 if (chain_circular
!= NULL
)
2649 oprintf (d
.of
, " if (!%s (xlimit", wtd
->marker_routine
);
2651 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2652 if (wtd
->param_prefix
)
2654 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2655 output_mangled_typename (d
.of
, orig_s
);
2656 output_type_enum (d
.of
, orig_s
);
2658 oprintf (d
.of
, "))\n");
2659 if (chain_circular
!= NULL
)
2660 oprintf (d
.of
, " return;\n do\n");
2661 if (mark_hook_name
&& !wtd
->skip_hooks
)
2663 oprintf (d
.of
, " {\n");
2664 oprintf (d
.of
, " %s (xlimit);\n ", mark_hook_name
);
2666 oprintf (d
.of
, " xlimit = (");
2667 d
.prev_val
[2] = "*xlimit";
2668 output_escaped_param (&d
, chain_next
, "chain_next");
2669 oprintf (d
.of
, ");\n");
2670 if (mark_hook_name
&& !wtd
->skip_hooks
)
2671 oprintf (d
.of
, " }\n");
2672 if (chain_prev
!= NULL
)
2674 oprintf (d
.of
, " if (x != xlimit)\n");
2675 oprintf (d
.of
, " for (;;)\n");
2676 oprintf (d
.of
, " {\n");
2677 oprintf (d
.of
, " %s %s * const xprev = (",
2678 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2680 d
.prev_val
[2] = "*x";
2681 output_escaped_param (&d
, chain_prev
, "chain_prev");
2682 oprintf (d
.of
, ");\n");
2683 oprintf (d
.of
, " if (xprev == NULL) break;\n");
2684 oprintf (d
.of
, " x = xprev;\n");
2685 oprintf (d
.of
, " (void) %s (xprev",
2686 wtd
->marker_routine
);
2687 if (wtd
->param_prefix
)
2689 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
2690 output_mangled_typename (d
.of
, orig_s
);
2691 output_type_enum (d
.of
, orig_s
);
2693 oprintf (d
.of
, ");\n");
2694 oprintf (d
.of
, " }\n");
2696 if (chain_circular
!= NULL
)
2698 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2699 if (wtd
->param_prefix
)
2701 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2702 output_mangled_typename (d
.of
, orig_s
);
2703 output_type_enum (d
.of
, orig_s
);
2705 oprintf (d
.of
, "));\n");
2706 if (mark_hook_name
&& !wtd
->skip_hooks
)
2707 oprintf (d
.of
, " %s (xlimit);\n", mark_hook_name
);
2708 oprintf (d
.of
, " do\n");
2711 oprintf (d
.of
, " while (x != xlimit)\n");
2713 oprintf (d
.of
, " {\n");
2714 if (mark_hook_name
&& chain_next
== NULL
&& !wtd
->skip_hooks
)
2716 oprintf (d
.of
, " %s (x);\n", mark_hook_name
);
2718 d
.prev_val
[2] = "*x";
2722 if (chain_next
!= NULL
)
2724 oprintf (d
.of
, " x = (");
2725 output_escaped_param (&d
, chain_next
, "chain_next");
2726 oprintf (d
.of
, ");\n");
2729 oprintf (d
.of
, " }\n");
2730 if (chain_circular
!= NULL
)
2731 oprintf (d
.of
, " while (x != xlimit);\n");
2732 oprintf (d
.of
, "}\n");
2735 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
2738 write_types (outf_p output_header
, type_p structures
, type_p param_structs
,
2739 const struct write_types_data
*wtd
)
2743 oprintf (output_header
, "\n/* %s*/\n", wtd
->comment
);
2744 /* We first emit the macros and the declarations. Functions' code is
2745 emitted afterwards. This is needed in plugin mode. */
2746 oprintf (output_header
, "/* macros and declarations */\n");
2747 for (s
= structures
; s
; s
= s
->next
)
2748 if (s
->gc_used
== GC_POINTED_TO
2749 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2753 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2754 && s
->u
.s
.line
.file
== NULL
)
2757 oprintf (output_header
, "#define gt_%s_", wtd
->prefix
);
2758 output_mangled_typename (output_header
, s
);
2759 oprintf (output_header
, "(X) do { \\\n");
2760 oprintf (output_header
,
2761 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
2763 oprintf (output_header
,
2766 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2767 if (strcmp (opt
->name
, "ptr_alias") == 0)
2769 const_type_p
const t
= (const_type_p
) opt
->info
;
2770 if (t
->kind
== TYPE_STRUCT
2771 || t
->kind
== TYPE_UNION
2772 || t
->kind
== TYPE_LANG_STRUCT
)
2773 oprintf (output_header
,
2774 "#define gt_%sx_%s gt_%sx_%s\n",
2775 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t
->u
.s
.tag
);
2777 error_at_line (&s
->u
.s
.line
,
2778 "structure alias is not a structure");
2784 /* Declare the marker procedure only once. */
2785 oprintf (output_header
,
2786 "extern void gt_%sx_%s (void *);\n",
2787 wtd
->prefix
, s
->u
.s
.tag
);
2789 if (s
->u
.s
.line
.file
== NULL
)
2791 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2797 for (s
= param_structs
; s
; s
= s
->next
)
2798 if (s
->gc_used
== GC_POINTED_TO
)
2800 type_p stru
= s
->u
.param_struct
.stru
;
2802 /* Declare the marker procedure. */
2803 oprintf (output_header
, "extern void gt_%s_", wtd
->prefix
);
2804 output_mangled_typename (output_header
, s
);
2805 oprintf (output_header
, " (void *);\n");
2807 if (stru
->u
.s
.line
.file
== NULL
)
2809 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2815 /* At last we emit the functions code. */
2816 oprintf (output_header
, "\n/* functions code */\n");
2817 for (s
= structures
; s
; s
= s
->next
)
2818 if (s
->gc_used
== GC_POINTED_TO
2819 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2823 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2824 && s
->u
.s
.line
.file
== NULL
)
2826 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2827 if (strcmp (opt
->name
, "ptr_alias") == 0)
2832 if (s
->kind
== TYPE_LANG_STRUCT
)
2835 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2836 write_func_for_structure (s
, ss
, NULL
, wtd
);
2839 write_func_for_structure (s
, s
, NULL
, wtd
);
2841 for (s
= param_structs
; s
; s
= s
->next
)
2842 if (s
->gc_used
== GC_POINTED_TO
)
2844 type_p
*param
= s
->u
.param_struct
.param
;
2845 type_p stru
= s
->u
.param_struct
.stru
;
2846 if (stru
->u
.s
.line
.file
== NULL
)
2848 if (stru
->kind
== TYPE_LANG_STRUCT
)
2851 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2852 write_func_for_structure (s
, ss
, param
, wtd
);
2855 write_func_for_structure (s
, stru
, param
, wtd
);
2859 static const struct write_types_data ggc_wtd
=
2861 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
2862 "GC marker procedures. ",
2866 static const struct write_types_data pch_wtd
=
2868 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
2869 "gt_pch_note_reorder",
2870 "PCH type-walking procedures. ",
2874 /* Write out the local pointer-walking routines. */
2876 /* process_field routine for local pointer-walking. */
2879 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
2886 case TYPE_LANG_STRUCT
:
2887 case TYPE_PARAM_STRUCT
:
2889 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
2891 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
2902 /* For S, a structure that's part of ORIG_S, and using parameters
2903 PARAM, write out a routine that:
2904 - Is of type gt_note_pointers
2905 - Calls PROCESS_FIELD on each field of S or its substructures.
2909 write_local_func_for_structure (const_type_p orig_s
, type_p s
, type_p
*param
)
2911 struct walk_type_data d
;
2913 memset (&d
, 0, sizeof (d
));
2914 d
.of
= get_output_file_for_structure (s
, param
);
2915 d
.process_field
= write_types_local_process_field
;
2917 d
.line
= &s
->u
.s
.line
;
2918 d
.bitmap
= s
->u
.s
.bitmap
;
2920 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
2921 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2922 d
.prev_val
[3] = "x";
2924 d
.fn_wants_lvalue
= true;
2926 oprintf (d
.of
, "\n");
2927 oprintf (d
.of
, "void\n");
2928 oprintf (d
.of
, "gt_pch_p_");
2929 output_mangled_typename (d
.of
, orig_s
);
2930 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
2932 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2933 "\tATTRIBUTE_UNUSED void *cookie)\n");
2934 oprintf (d
.of
, "{\n");
2935 oprintf (d
.of
, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
2936 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2937 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2940 oprintf (d
.of
, "}\n");
2943 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
2946 write_local (outf_p output_header
, type_p structures
, type_p param_structs
)
2952 oprintf (output_header
, "\n/* Local pointer-walking routines. */\n");
2953 for (s
= structures
; s
; s
= s
->next
)
2954 if (s
->gc_used
== GC_POINTED_TO
2955 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2959 if (s
->u
.s
.line
.file
== NULL
)
2962 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2963 if (strcmp (opt
->name
, "ptr_alias") == 0)
2965 const_type_p
const t
= (const_type_p
) opt
->info
;
2966 if (t
->kind
== TYPE_STRUCT
2967 || t
->kind
== TYPE_UNION
2968 || t
->kind
== TYPE_LANG_STRUCT
)
2970 oprintf (output_header
, "#define gt_pch_p_");
2971 output_mangled_typename (output_header
, s
);
2972 oprintf (output_header
, " gt_pch_p_");
2973 output_mangled_typename (output_header
, t
);
2974 oprintf (output_header
, "\n");
2977 error_at_line (&s
->u
.s
.line
,
2978 "structure alias is not a structure");
2984 /* Declare the marker procedure only once. */
2985 oprintf (output_header
, "extern void gt_pch_p_");
2986 output_mangled_typename (output_header
, s
);
2987 oprintf (output_header
,
2988 "\n (void *, void *, gt_pointer_operator, void *);\n");
2990 if (s
->kind
== TYPE_LANG_STRUCT
)
2993 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2994 write_local_func_for_structure (s
, ss
, NULL
);
2997 write_local_func_for_structure (s
, s
, NULL
);
3000 for (s
= param_structs
; s
; s
= s
->next
)
3001 if (s
->gc_used
== GC_POINTED_TO
)
3003 type_p
* param
= s
->u
.param_struct
.param
;
3004 type_p stru
= s
->u
.param_struct
.stru
;
3006 /* Declare the marker procedure. */
3007 oprintf (output_header
, "extern void gt_pch_p_");
3008 output_mangled_typename (output_header
, s
);
3009 oprintf (output_header
,
3010 "\n (void *, void *, gt_pointer_operator, void *);\n");
3012 if (stru
->u
.s
.line
.file
== NULL
)
3014 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3019 if (stru
->kind
== TYPE_LANG_STRUCT
)
3022 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3023 write_local_func_for_structure (s
, ss
, param
);
3026 write_local_func_for_structure (s
, stru
, param
);
3030 /* Nonzero if S is a type for which typed GC allocators should be output. */
3032 #define USED_BY_TYPED_GC_P(s) \
3033 (((s->kind == TYPE_POINTER) \
3034 && ((s->u.p->gc_used == GC_POINTED_TO) \
3035 || (s->u.p->gc_used == GC_USED))) \
3036 || (UNION_OR_STRUCT_P (s) && \
3037 (((s)->gc_used == GC_POINTED_TO) \
3038 || ((s)->gc_used == GC_MAYBE_POINTED_TO \
3039 && s->u.s.line.file != NULL) \
3040 || ((s)->gc_used == GC_USED \
3041 && strncmp (s->u.s.tag, "anonymous", strlen ("anonymous"))))))
3044 /* Write out the 'enum' definition for gt_types_enum. */
3047 write_enum_defn (type_p structures
, type_p param_structs
)
3053 oprintf (header_file
, "\n/* Enumeration of types known. */\n");
3054 oprintf (header_file
, "enum gt_types_enum {\n");
3055 for (s
= structures
; s
; s
= s
->next
)
3056 if (USED_BY_TYPED_GC_P (s
))
3058 oprintf (header_file
, " gt_ggc_e_");
3059 output_mangled_typename (header_file
, s
);
3060 oprintf (header_file
, ",\n");
3062 for (s
= param_structs
; s
; s
= s
->next
)
3063 if (s
->gc_used
== GC_POINTED_TO
)
3065 oprintf (header_file
, " gt_e_");
3066 output_mangled_typename (header_file
, s
);
3067 oprintf (header_file
, ",\n");
3069 oprintf (header_file
, " gt_types_enum_last\n");
3070 oprintf (header_file
, "};\n");
3073 /* Might T contain any non-pointer elements? */
3076 contains_scalar_p (type_p t
)
3084 return contains_scalar_p (t
->u
.a
.p
);
3086 /* Could also check for structures that have no non-pointer
3087 fields, but there aren't enough of those to worry about. */
3092 /* Mangle FN and print it to F. */
3095 put_mangled_filename (outf_p f
, const char *fn
)
3097 const char *name
= get_output_file_name (fn
);
3100 for (; *name
!= 0; name
++)
3101 if (ISALNUM (*name
))
3102 oprintf (f
, "%c", *name
);
3104 oprintf (f
, "%c", '_');
3107 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
3108 LASTNAME, and NAME are all strings to insert in various places in
3109 the resulting code. */
3112 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
3113 const char *tname
, const char *name
)
3117 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3118 if (fli2
->started_p
)
3120 oprintf (fli2
->f
, " %s\n", lastname
);
3121 oprintf (fli2
->f
, "};\n\n");
3124 for (fli2
= flp
; fli2
&& base_files
; fli2
= fli2
->next
)
3125 if (fli2
->started_p
)
3127 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
3130 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
3133 oprintf (base_files
[fnum
],
3134 "extern const struct %s gt_%s_",
3136 put_mangled_filename (base_files
[fnum
], fli2
->name
);
3137 oprintf (base_files
[fnum
], "[];\n");
3143 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3144 oprintf (base_files
[fnum
],
3145 "EXPORTED_CONST struct %s * const %s[] = {\n",
3150 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3151 if (fli2
->started_p
)
3153 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
3156 fli2
->started_p
= 0;
3158 for (fnum
= 0; base_files
&& bitmap
!= 0; fnum
++, bitmap
>>= 1)
3161 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
3162 put_mangled_filename (base_files
[fnum
], fli2
->name
);
3163 oprintf (base_files
[fnum
], ",\n");
3169 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3171 oprintf (base_files
[fnum
], " NULL\n");
3172 oprintf (base_files
[fnum
], "};\n");
3177 /* Write out to F the table entry and any marker routines needed to
3178 mark NAME as TYPE. The original variable is V, at LINE.
3179 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
3180 is nonzero iff we are building the root table for hash table caches. */
3183 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
3184 struct fileloc
*line
, const char *if_marked
, bool emit_pch
)
3191 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
3194 const char *desc
= NULL
;
3197 for (o
= fld
->opt
; o
; o
= o
->next
)
3198 if (strcmp (o
->name
, "skip") == 0)
3200 else if (strcmp (o
->name
, "desc") == 0)
3202 else if (strcmp (o
->name
, "param_is") == 0)
3205 error_at_line (line
,
3206 "field `%s' of global `%s' has unknown option `%s'",
3207 fld
->name
, name
, o
->name
);
3211 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
3213 pair_p validf
= NULL
;
3216 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
3218 const char *tag
= NULL
;
3221 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
3222 if (strcmp (oo
->name
, "tag") == 0)
3224 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
3227 error_at_line (line
,
3228 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3229 name
, fld
->name
, validf
->name
,
3230 name
, fld
->name
, ufld
->name
,
3237 newname
= xasprintf ("%s.%s.%s",
3238 name
, fld
->name
, validf
->name
);
3239 write_root (f
, v
, validf
->type
, newname
, 0, line
,
3240 if_marked
, emit_pch
);
3245 error_at_line (line
,
3246 "global `%s.%s' has `desc' option but is not union",
3251 newname
= xasprintf ("%s.%s", name
, fld
->name
);
3252 write_root (f
, v
, fld
->type
, newname
, 0, line
, if_marked
,
3263 newname
= xasprintf ("%s[0]", name
);
3264 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, if_marked
,
3274 oprintf (f
, " {\n");
3275 oprintf (f
, " &%s,\n", name
);
3278 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3280 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
3281 else if (ap
== v
->type
)
3282 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
3284 oprintf (f
, " sizeof (%s", v
->name
);
3285 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3287 oprintf (f
, "),\n");
3291 if (! has_length
&& UNION_OR_STRUCT_P (tp
))
3293 oprintf (f
, " >_ggc_mx_%s,\n", tp
->u
.s
.tag
);
3295 oprintf (f
, " >_pch_nx_%s", tp
->u
.s
.tag
);
3297 oprintf (f
, " NULL");
3299 else if (! has_length
&& tp
->kind
== TYPE_PARAM_STRUCT
)
3301 oprintf (f
, " >_ggc_m_");
3302 output_mangled_typename (f
, tp
);
3305 oprintf (f
, ",\n >_pch_n_");
3306 output_mangled_typename (f
, tp
);
3309 oprintf (f
, ",\n NULL");
3312 && (tp
->kind
== TYPE_POINTER
|| UNION_OR_STRUCT_P (tp
)))
3314 oprintf (f
, " >_ggc_ma_%s,\n", name
);
3316 oprintf (f
, " >_pch_na_%s", name
);
3318 oprintf (f
, " NULL");
3322 error_at_line (line
,
3323 "global `%s' is pointer to unimplemented type",
3327 oprintf (f
, ",\n &%s", if_marked
);
3328 oprintf (f
, "\n },\n");
3334 oprintf (f
, " {\n");
3335 oprintf (f
, " &%s,\n", name
);
3336 oprintf (f
, " 1, \n");
3337 oprintf (f
, " sizeof (%s),\n", v
->name
);
3338 oprintf (f
, " (gt_pointer_walker) >_ggc_m_S,\n");
3339 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
3340 oprintf (f
, " },\n");
3348 error_at_line (line
,
3349 "global `%s' is unimplemented type",
3354 /* This generates a routine to walk an array. */
3357 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
3359 struct walk_type_data d
;
3362 memset (&d
, 0, sizeof (d
));
3368 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
3371 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
3373 if (wtd
->param_prefix
)
3375 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
3377 " (void *, void *, gt_pointer_operator, void *);\n");
3378 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3379 wtd
->param_prefix
, v
->name
);
3381 " ATTRIBUTE_UNUSED void *x_p,\n"
3382 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3383 " ATTRIBUTE_UNUSED void * cookie)\n");
3384 oprintf (d
.of
, "{\n");
3385 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3386 d
.process_field
= write_types_local_process_field
;
3387 walk_type (v
->type
, &d
);
3388 oprintf (f
, "}\n\n");
3392 oprintf (f
, "static void gt_%sa_%s (void *);\n",
3393 wtd
->prefix
, v
->name
);
3394 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3395 wtd
->prefix
, v
->name
);
3397 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3398 d
.process_field
= write_types_process_field
;
3399 walk_type (v
->type
, &d
);
3401 oprintf (f
, "}\n\n");
3404 /* Output a table describing the locations and types of VARIABLES. */
3407 write_roots (pair_p variables
, bool emit_pch
)
3410 struct flist
*flp
= NULL
;
3412 for (v
= variables
; v
; v
= v
->next
)
3414 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3416 const char *length
= NULL
;
3417 int deletable_p
= 0;
3420 for (o
= v
->opt
; o
; o
= o
->next
)
3421 if (strcmp (o
->name
, "length") == 0)
3423 else if (strcmp (o
->name
, "deletable") == 0)
3425 else if (strcmp (o
->name
, "param_is") == 0)
3427 else if (strncmp (o
->name
, "param", 5) == 0
3428 && ISDIGIT (o
->name
[5])
3429 && strcmp (o
->name
+ 6, "_is") == 0)
3431 else if (strcmp (o
->name
, "if_marked") == 0)
3434 error_at_line (&v
->line
,
3435 "global `%s' has unknown option `%s'",
3438 for (fli
= flp
; fli
; fli
= fli
->next
)
3439 if (fli
->f
== f
&& f
)
3443 fli
= XNEW (struct flist
);
3447 fli
->name
= v
->line
.file
;
3448 gcc_assert(fli
->name
);
3451 oprintf (f
, "\n/* GC roots. */\n\n");
3456 && v
->type
->kind
== TYPE_POINTER
3457 && (v
->type
->u
.p
->kind
== TYPE_POINTER
3458 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
3460 write_array (f
, v
, &ggc_wtd
);
3461 write_array (f
, v
, &pch_wtd
);
3465 for (v
= variables
; v
; v
= v
->next
)
3467 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3473 for (o
= v
->opt
; o
; o
= o
->next
)
3474 if (strcmp (o
->name
, "length") == 0)
3476 else if (strcmp (o
->name
, "deletable") == 0
3477 || strcmp (o
->name
, "if_marked") == 0)
3483 for (fli
= flp
; fli
; fli
= fli
->next
)
3486 if (! fli
->started_p
)
3490 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3491 put_mangled_filename (f
, v
->line
.file
);
3492 oprintf (f
, "[] = {\n");
3495 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
, emit_pch
);
3498 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3501 for (v
= variables
; v
; v
= v
->next
)
3503 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3508 for (o
= v
->opt
; o
; o
= o
->next
)
3509 if (strcmp (o
->name
, "deletable") == 0)
3511 else if (strcmp (o
->name
, "if_marked") == 0)
3517 for (fli
= flp
; fli
; fli
= fli
->next
)
3520 if (! fli
->started_p
)
3524 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3525 put_mangled_filename (f
, v
->line
.file
);
3526 oprintf (f
, "[] = {\n");
3529 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3533 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3534 "gt_ggc_deletable_rtab");
3536 for (v
= variables
; v
; v
= v
->next
)
3538 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3540 const char *if_marked
= NULL
;
3544 for (o
= v
->opt
; o
; o
= o
->next
)
3545 if (strcmp (o
->name
, "length") == 0)
3547 else if (strcmp (o
->name
, "if_marked") == 0)
3548 if_marked
= o
->info
;
3550 if (if_marked
== NULL
)
3553 if (v
->type
->kind
!= TYPE_POINTER
3554 || v
->type
->u
.p
->kind
!= TYPE_PARAM_STRUCT
3555 || v
->type
->u
.p
->u
.param_struct
.stru
!= find_structure ("htab", 0))
3557 error_at_line (&v
->line
, "if_marked option used but not hash table");
3561 for (fli
= flp
; fli
; fli
= fli
->next
)
3564 if (! fli
->started_p
)
3568 oprintf (f
, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
3569 put_mangled_filename (f
, v
->line
.file
);
3570 oprintf (f
, "[] = {\n");
3573 write_root (f
, v
, v
->type
->u
.p
->u
.param_struct
.param
[0],
3574 v
->name
, length_p
, &v
->line
, if_marked
, emit_pch
);
3577 finish_root_table (flp
, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
3578 "gt_ggc_cache_rtab");
3583 for (v
= variables
; v
; v
= v
->next
)
3585 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3588 int if_marked_p
= 0;
3591 for (o
= v
->opt
; o
; o
= o
->next
)
3592 if (strcmp (o
->name
, "length") == 0)
3594 else if (strcmp (o
->name
, "if_marked") == 0)
3600 for (fli
= flp
; fli
; fli
= fli
->next
)
3603 if (! fli
->started_p
)
3607 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
3608 put_mangled_filename (f
, v
->line
.file
);
3609 oprintf (f
, "[] = {\n");
3612 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
, emit_pch
);
3615 finish_root_table (flp
, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3616 "gt_pch_cache_rtab");
3618 for (v
= variables
; v
; v
= v
->next
)
3620 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3625 for (o
= v
->opt
; o
; o
= o
->next
)
3626 if (strcmp (o
->name
, "deletable") == 0
3627 || strcmp (o
->name
, "if_marked") == 0)
3633 if (! contains_scalar_p (v
->type
))
3636 for (fli
= flp
; fli
; fli
= fli
->next
)
3639 if (! fli
->started_p
)
3643 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
3644 put_mangled_filename (f
, v
->line
.file
);
3645 oprintf (f
, "[] = {\n");
3648 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3652 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3653 "gt_pch_scalar_rtab");
3656 /* Record the definition of a generic VEC structure, as if we had expanded
3657 the macros in vec.h:
3659 typedef struct VEC_<type>_base GTY(()) {
3662 <type> GTY((length ("%h.num"))) vec[1];
3665 where the GTY(()) tags are only present if is_scalar is _false_. */
3668 note_def_vec (const char *type_name
, bool is_scalar
, struct fileloc
*pos
)
3673 type_p len_ty
= create_scalar_type ("unsigned");
3674 const char *name
= concat ("VEC_", type_name
, "_base", (char *)0);
3678 t
= create_scalar_type (type_name
);
3683 t
= resolve_typedef (type_name
, pos
);
3684 o
= create_option (0, "length", "%h.num");
3687 /* We assemble the field list in reverse order. */
3688 fields
= create_field_at (0, create_array (t
, "1"), "vec", o
, pos
);
3689 fields
= create_field_at (fields
, len_ty
, "alloc", 0, pos
);
3690 fields
= create_field_at (fields
, len_ty
, "num", 0, pos
);
3692 do_typedef (name
, new_structure (name
, 0, pos
, fields
, 0), pos
);
3695 /* Record the definition of an allocation-specific VEC structure, as if
3696 we had expanded the macros in vec.h:
3698 typedef struct VEC_<type>_<astrat> {
3699 VEC_<type>_base base;
3700 } VEC_<type>_<astrat>;
3703 note_def_vec_alloc (const char *type
, const char *astrat
, struct fileloc
*pos
)
3705 const char *astratname
= concat ("VEC_", type
, "_", astrat
, (char *)0);
3706 const char *basename
= concat ("VEC_", type
, "_base", (char *)0);
3708 pair_p field
= create_field_at (0, resolve_typedef (basename
, pos
),
3711 do_typedef (astratname
, new_structure (astratname
, 0, pos
, field
, 0), pos
);
3714 /* Returns the specifier keyword for a string or union type S, empty string
3718 get_type_specifier (const type_p s
)
3720 if (s
->kind
== TYPE_STRUCT
|| s
->kind
== TYPE_LANG_STRUCT
)
3722 if (s
->kind
== TYPE_UNION
)
3727 /* TRUE if type S has the GTY variable_size annotation. */
3730 variable_size_p (const type_p s
)
3733 for (o
= s
->u
.s
.opt
; o
; o
= o
->next
)
3734 if (strcmp (o
->name
, "variable_size") == 0)
3739 enum alloc_quantity
{ single
, vector
};
3740 enum alloc_zone
{ any_zone
, specific_zone
};
3742 /* Writes one typed allocator definition for type identifier TYPE_NAME with
3743 optional type specifier TYPE_SPECIFIER. The allocator name will contain
3744 ALLOCATOR_TYPE. If VARIABLE_SIZE is true, the allocator will have an extra
3745 parameter specifying number of bytes to allocate. If QUANTITY is set to
3746 VECTOR, a vector allocator will be output, if ZONE is set to SPECIFIC_ZONE,
3747 the allocator will be zone-specific. */
3750 write_typed_alloc_def (bool variable_size
, const char * type_specifier
,
3751 const char * type_name
, const char * allocator_type
,
3752 enum alloc_quantity quantity
, enum alloc_zone zone
)
3754 bool two_args
= variable_size
&& (quantity
== vector
);
3755 bool third_arg
= ((zone
== specific_zone
)
3756 && (variable_size
|| (quantity
== vector
)));
3758 oprintf (header_file
, "#define ggc_alloc_%s%s",allocator_type
, type_name
);
3759 oprintf (header_file
, "(%s%s%s%s%s) ",
3760 (variable_size
? "SIZE" : ""),
3761 (two_args
? ", " : ""),
3762 (quantity
== vector
) ? "n" : "",
3763 (third_arg
? ", " : ""), (zone
== specific_zone
) ? "z" : "");
3764 oprintf (header_file
, "((%s%s *)", type_specifier
, type_name
);
3765 oprintf (header_file
, "(ggc_internal_%salloc_stat (", allocator_type
);
3766 if (zone
== specific_zone
)
3767 oprintf (header_file
, "z, ");
3769 oprintf (header_file
, "SIZE");
3771 oprintf (header_file
, "sizeof (%s%s)", type_specifier
, type_name
);
3772 if (quantity
== vector
)
3773 oprintf (header_file
, ", n");
3774 oprintf (header_file
, " MEM_STAT_INFO)))\n");
3777 /* Writes a typed allocator definition for a struct or union S. */
3780 write_typed_struct_alloc_def (const type_p s
, const char * allocator_type
,
3781 enum alloc_quantity quantity
,
3782 enum alloc_zone zone
)
3784 write_typed_alloc_def (variable_size_p (s
), get_type_specifier (s
),
3785 s
->u
.s
.tag
, allocator_type
, quantity
, zone
);
3788 /* Writes a typed allocator definition for a typedef P. */
3791 write_typed_typedef_alloc_def (const pair_p p
, const char * allocator_type
,
3792 enum alloc_quantity quantity
,
3793 enum alloc_zone zone
)
3795 write_typed_alloc_def (variable_size_p (p
->type
), "", p
->name
,
3796 allocator_type
, quantity
, zone
);
3799 /* Writes typed allocator definitions for the types in STRUCTURES and
3800 TYPEDEFS that are used by GC. */
3803 write_typed_alloc_defns (const type_p structures
, const pair_p typedefs
)
3808 oprintf (header_file
,
3809 "\n/* Allocators for known structs and unions. */\n\n");
3810 for (s
= structures
; s
; s
= s
->next
)
3812 if (!USED_BY_TYPED_GC_P (s
))
3814 write_typed_struct_alloc_def (s
, "", single
, any_zone
);
3815 write_typed_struct_alloc_def (s
, "cleared_", single
, any_zone
);
3816 write_typed_struct_alloc_def (s
, "vec_", vector
, any_zone
);
3817 write_typed_struct_alloc_def (s
, "cleared_vec_", vector
, any_zone
);
3818 write_typed_struct_alloc_def (s
, "zone_", single
, specific_zone
);
3819 write_typed_struct_alloc_def (s
, "zone_cleared_", single
,
3821 write_typed_struct_alloc_def (s
, "zone_vec_", vector
, specific_zone
);
3822 write_typed_struct_alloc_def (s
, "zone_cleared_vec_", vector
,
3826 oprintf (header_file
, "\n/* Allocators for known typedefs. */\n");
3827 for (p
= typedefs
; p
; p
= p
->next
)
3830 if (!USED_BY_TYPED_GC_P (s
) || (strcmp (p
->name
, s
->u
.s
.tag
) == 0))
3832 write_typed_typedef_alloc_def (p
, "", single
, any_zone
);
3833 write_typed_typedef_alloc_def (p
, "cleared_", single
, any_zone
);
3834 write_typed_typedef_alloc_def (p
, "vec_", vector
, any_zone
);
3835 write_typed_typedef_alloc_def (p
, "cleared_vec_", vector
, any_zone
);
3836 write_typed_typedef_alloc_def (p
, "zone_", single
, specific_zone
);
3837 write_typed_typedef_alloc_def (p
, "zone_cleared_", single
,
3839 write_typed_typedef_alloc_def (p
, "zone_cleared_vec_", vector
,
3844 /* Prints not-as-ugly version of a typename of T to OF. Trades the uniquness
3845 guaranteee for somewhat increased readability. If name conflicts do happen,
3846 this funcion will have to be adjusted to be more like
3847 output_mangled_typename. */
3850 output_typename (outf_p of
, const_type_p t
)
3855 oprintf (of
, "str");
3858 oprintf (of
, "scalar");
3861 output_typename (of
, t
->u
.p
);
3865 case TYPE_LANG_STRUCT
:
3866 oprintf (of
, "%s", t
->u
.s
.tag
);
3868 case TYPE_PARAM_STRUCT
:
3871 for (i
= 0; i
< NUM_PARAM
; i
++)
3872 if (t
->u
.param_struct
.param
[i
] != NULL
) {
3873 output_typename (of
, t
->u
.param_struct
.param
[i
]);
3876 output_typename (of
, t
->u
.param_struct
.stru
);
3884 /* Writes a typed GC allocator for type S that is suitable as a callback for
3885 the splay tree implementation in libiberty. */
3888 write_splay_tree_allocator_def (const_type_p s
)
3890 outf_p of
= get_output_file_for_structure(s
, NULL
);
3891 oprintf (of
, "void * ggc_alloc_splay_tree_");
3892 output_typename (of
, s
);
3893 oprintf (of
, " (int sz, void * nl)\n");
3894 oprintf (of
, "{\n");
3895 oprintf (of
, " return ggc_splay_alloc (");
3896 oprintf (of
, "gt_e_");
3897 output_mangled_typename (of
, s
);
3898 oprintf (of
, ", sz, nl);\n");
3899 oprintf (of
, "}\n\n");
3902 /* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks
3903 for the splay tree implementation in libiberty. */
3906 write_splay_tree_allocators (const_type_p param_structs
)
3910 oprintf (header_file
, "\n/* Splay tree callback allocators. */\n");
3911 for (s
= param_structs
; s
; s
= s
->next
)
3912 if (s
->gc_used
== GC_POINTED_TO
)
3914 oprintf (header_file
, "extern void * ggc_alloc_splay_tree_");
3915 output_typename (header_file
, s
);
3916 oprintf (header_file
, " (int, void *);\n");
3917 write_splay_tree_allocator_def (s
);
3921 static void dump_pair (int indent
, pair_p p
);
3922 static void dump_type (int indent
, type_p p
);
3923 static void dump_type_list (int indent
, type_p p
);
3927 /* Dumps the value of typekind KIND. */
3930 dump_typekind (int indent
, enum typekind kind
)
3932 printf ("%*ckind = ", indent
, ' ');
3935 case TYPE_SCALAR
: printf ("TYPE_SCALAR"); break;
3936 case TYPE_STRING
: printf ("TYPE_STRING"); break;
3937 case TYPE_STRUCT
: printf ("TYPE_STRUCT"); break;
3938 case TYPE_UNION
: printf ("TYPE_UNION"); break;
3939 case TYPE_POINTER
: printf ("TYPE_POINTER"); break;
3940 case TYPE_ARRAY
: printf ("TYPE_ARRAY"); break;
3941 case TYPE_LANG_STRUCT
: printf ("TYPE_LANG_STRUCT"); break;
3942 case TYPE_PARAM_STRUCT
: printf ("TYPE_PARAM_STRUCT"); break;
3943 default: gcc_unreachable ();
3948 /* Dumps the value of GC_USED flag. */
3951 dump_gc_used (int indent
, enum gc_used_enum gc_used
)
3953 printf ("%*cgc_used = ", indent
, ' ');
3956 case GC_UNUSED
: printf ("GC_UNUSED"); break;
3957 case GC_USED
: printf ("GC_USED"); break;
3958 case GC_MAYBE_POINTED_TO
: printf ("GC_MAYBE_POINTED_TO"); break;
3959 case GC_POINTED_TO
: printf ("GC_POINTED_TO"); break;
3960 default: gcc_unreachable ();
3965 /* Dumps the type options OPT. */
3968 dump_options (int indent
, options_p opt
)
3971 printf ("%*coptions = ", indent
, ' ');
3975 printf ("%s:%s ", o
->name
, o
->info
);
3981 /* Dumps the source file location in LINE. */
3984 dump_fileloc (int indent
, struct fileloc line
)
3986 printf ("%*cfileloc: file = %s, line = %d\n", indent
, ' ', line
.file
,
3990 /* Recursively dumps the struct, union, or a language-specific
3994 dump_type_u_s (int indent
, type_p t
)
3998 gcc_assert (t
->kind
== TYPE_STRUCT
|| t
->kind
== TYPE_UNION
3999 || t
->kind
== TYPE_LANG_STRUCT
);
4000 printf ("%*cu.s.tag = %s\n", indent
, ' ', t
->u
.s
.tag
);
4001 dump_fileloc (indent
, t
->u
.s
.line
);
4002 printf ("%*cu.s.fields =\n", indent
, ' ');
4003 fields
= t
->u
.s
.fields
;
4006 dump_pair (indent
+ INDENT
, fields
);
4007 fields
= fields
->next
;
4009 printf ("%*cend of fields of type %p\n", indent
, ' ', (void *) t
);
4010 dump_options (indent
, t
->u
.s
.opt
);
4011 printf ("%*cu.s.bitmap = %X\n", indent
, ' ', t
->u
.s
.bitmap
);
4012 if (t
->kind
== TYPE_LANG_STRUCT
)
4014 printf ("%*cu.s.lang_struct:\n", indent
, ' ');
4015 dump_type_list (indent
+ INDENT
, t
->u
.s
.lang_struct
);
4019 /* Recursively dumps the array T. */
4022 dump_type_u_a (int indent
, type_p t
)
4024 gcc_assert (t
->kind
== TYPE_ARRAY
);
4025 printf ("%*clen = %s, u.a.p:\n", indent
, ' ', t
->u
.a
.len
);
4026 dump_type_list (indent
+ INDENT
, t
->u
.a
.p
);
4029 /* Recursively dumps the parameterized struct T. */
4032 dump_type_u_param_struct (int indent
, type_p t
)
4035 gcc_assert (t
->kind
== TYPE_PARAM_STRUCT
);
4036 printf ("%*cu.param_struct.stru:\n", indent
, ' ');
4037 dump_type_list (indent
, t
->u
.param_struct
.stru
);
4038 dump_fileloc (indent
, t
->u
.param_struct
.line
);
4039 for (i
= 0; i
< NUM_PARAM
; i
++)
4041 if (t
->u
.param_struct
.param
[i
] == NULL
)
4043 printf ("%*cu.param_struct.param[%d]:\n", indent
, ' ', i
);
4044 dump_type (indent
+ INDENT
, t
->u
.param_struct
.param
[i
]);
4048 /* Recursively dumps the type list T. */
4051 dump_type_list (int indent
, type_p t
)
4056 dump_type (indent
, p
);
4061 static htab_t seen_types
;
4063 /* Recursively dumps the type T if it was not dumped previously. */
4066 dump_type (int indent
, type_p t
)
4070 printf ("%*cType at %p: ", indent
, ' ', (void *)t
);
4071 slot
= htab_find_slot (seen_types
, t
, INSERT
);
4074 printf ("already seen.\n");
4080 dump_typekind (indent
, t
->kind
);
4081 printf ("%*cpointer_to = %p\n", indent
+ INDENT
, ' ',
4082 (void *)t
->pointer_to
);
4083 dump_gc_used (indent
+ INDENT
, t
->gc_used
);
4087 printf ("%*cscalar_is_char = %s\n", indent
+ INDENT
, ' ',
4088 t
->u
.scalar_is_char
? "true" : "false");
4094 case TYPE_LANG_STRUCT
:
4095 dump_type_u_s (indent
+ INDENT
, t
);
4098 printf ("%*cp:\n", indent
+ INDENT
, ' ');
4099 dump_type (indent
+ INDENT
, t
->u
.p
);
4102 dump_type_u_a (indent
+ INDENT
, t
);
4104 case TYPE_PARAM_STRUCT
:
4105 dump_type_u_param_struct (indent
+ INDENT
, t
);
4110 printf ("%*cEnd of type at %p\n", indent
, ' ', (void *)t
);
4113 /* Dumps the pair P. */
4116 dump_pair (int indent
, pair_p p
)
4118 printf ("%*cpair: name = %s\n", indent
, ' ', p
->name
);
4119 dump_type (indent
, p
->type
);
4120 dump_fileloc (indent
, p
->line
);
4121 dump_options (indent
, p
->opt
);
4122 printf ("%*cEnd of pair %s\n", indent
, ' ', p
->name
);
4125 /* Dumps the list of pairs PP. */
4128 dump_pair_list (const char * name
, pair_p pp
)
4131 printf ("%s:\n", name
);
4132 for (p
= pp
; p
!= NULL
; p
= p
->next
)
4134 printf ("End of %s\n\n", name
);
4137 /* Dumps the STRUCTURES. */
4140 dump_structures (const char * name
, type_p structures
)
4142 printf ("%s:\n", name
);
4143 dump_type_list (0, structures
);
4144 printf ("End of %s\n\n", name
);
4147 /* Dumps the internal structures of gengtype. */
4150 dump_everything (void)
4152 seen_types
= htab_create (100, htab_hash_pointer
, htab_eq_pointer
, NULL
);
4153 dump_pair_list ("typedefs", typedefs
);
4154 dump_structures ("structures", structures
);
4155 dump_structures ("param_structs", param_structs
);
4156 dump_pair_list ("variables", variables
);
4157 htab_delete (seen_types
);
4162 main (int argc
, char **argv
)
4165 static struct fileloc pos
= { this_file
, 0 };
4166 char* inputlist
= 0;
4168 outf_p output_header
;
4169 char* plugin_output_filename
= NULL
;
4170 /* fatal uses this */
4171 progname
= "gengtype";
4173 if (argc
>= 2 && !strcmp (argv
[1], "-d"))
4180 if (argc
>= 6 && !strcmp (argv
[1], "-P"))
4182 plugin_output_filename
= argv
[2];
4183 plugin_output
= create_file ("GCC", plugin_output_filename
);
4185 inputlist
= argv
[4];
4186 nb_plugin_files
= argc
- 5;
4187 plugin_files
= XCNEWVEC (char *, nb_plugin_files
);
4188 for (i
= 0; i
< nb_plugin_files
; i
++)
4190 /* Place an all zero lang_bitmap before the plugin file
4192 char *name
= argv
[i
+ 5];
4193 int len
= strlen(name
) + 1 + sizeof (lang_bitmap
);
4194 plugin_files
[i
] = XCNEWVEC (char, len
) + sizeof (lang_bitmap
);
4195 strcpy (plugin_files
[i
], name
);
4201 inputlist
= argv
[2];
4204 fatal ("usage: gengtype [-d] [-P pluginout.h] srcdir input-list "
4205 "[file1 file2 ... fileN]");
4207 srcdir_len
= strlen (srcdir
);
4209 read_input_list (inputlist
);
4213 scalar_char
.u
.scalar_is_char
= true;
4214 scalar_nonchar
.u
.scalar_is_char
= false;
4217 /* These types are set up with #define or else outside of where
4219 pos
.line
= __LINE__
+ 1;
4220 do_scalar_typedef ("CUMULATIVE_ARGS", &pos
); pos
.line
++;
4221 do_scalar_typedef ("REAL_VALUE_TYPE", &pos
); pos
.line
++;
4222 do_scalar_typedef ("FIXED_VALUE_TYPE", &pos
); pos
.line
++;
4223 do_scalar_typedef ("double_int", &pos
); pos
.line
++;
4224 do_scalar_typedef ("uint64_t", &pos
); pos
.line
++;
4225 do_scalar_typedef ("uint8", &pos
); pos
.line
++;
4226 do_scalar_typedef ("jword", &pos
); pos
.line
++;
4227 do_scalar_typedef ("JCF_u2", &pos
); pos
.line
++;
4228 do_scalar_typedef ("void", &pos
); pos
.line
++;
4229 do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos
)), &pos
);
4231 for (i
= 0; i
< num_gt_files
; i
++)
4232 parse_file (gt_files
[i
]);
4237 set_gc_used (variables
);
4240 write_enum_defn (structures
, param_structs
);
4241 write_typed_alloc_defns (structures
, typedefs
);
4242 output_header
= plugin_output
? plugin_output
: header_file
;
4243 write_types (output_header
, structures
, param_structs
, &ggc_wtd
);
4244 if (plugin_files
== NULL
)
4246 write_types (header_file
, structures
, param_structs
, &pch_wtd
);
4247 write_local (header_file
, structures
, param_structs
);
4249 write_splay_tree_allocators (param_structs
);
4250 write_roots (variables
, plugin_files
== NULL
);
4252 close_output_files ();
4259 for (i
= 0; i
< nb_plugin_files
; i
++)
4260 free (plugin_files
[i
] - sizeof (lang_bitmap
));
4261 free (plugin_files
);