1 /* Process source files and output type information.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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/>. */
23 #include "errors.h" /* for fatal */
25 #include "double-int.h"
26 #include "version.h" /* for version_string & pkgversion_string. */
32 /* Data types, macros, etc. used only in this file. */
35 /* The list of output files. */
38 /* The output header file that is included into pretty much every
43 /* The name of the file containing the list of input files. */
44 static char *inputlist
;
46 /* The plugin input files and their number; in that case only
47 a single file is produced. */
48 static input_file
**plugin_files
;
49 static size_t nb_plugin_files
;
51 /* The generated plugin output file and name. */
52 static outf_p plugin_output
;
53 static char *plugin_output_filename
;
55 /* Our source directory and its length. */
59 /* Variables used for reading and writing the state. */
60 const char *read_state_filename
;
61 const char *write_state_filename
;
63 /* Variables to help debugging. */
67 /* Level for verbose messages. */
70 /* We have a type count and use it to set the state_number of newly
71 allocated types to some unique negative number. */
72 static int type_count
;
74 /* The backup directory should be in the same file system as the
75 generated files, otherwise the rename(2) system call would fail.
76 If NULL, no backup is made when overwriting a generated file. */
77 static const char* backup_dir
; /* (-B) program option. */
80 static outf_p
create_file (const char *, const char *);
82 static const char *get_file_basename (const input_file
*);
83 static const char *get_file_realbasename (const input_file
*);
85 static int get_prefix_langdir_index (const char *);
86 static const char *get_file_langdir (const input_file
*);
89 /* Nonzero iff an error has occurred. */
90 bool hit_error
= false;
92 static void gen_rtx_next (void);
93 static void write_rtx_next (void);
94 static void open_base_files (void);
95 static void close_output_files (void);
97 /* Report an error at POS, printing MSG. */
100 error_at_line (const struct fileloc
*pos
, const char *msg
, ...)
104 gcc_assert (pos
!= NULL
&& pos
->file
!= NULL
);
107 fprintf (stderr
, "%s:%d: ", get_input_file_name (pos
->file
), pos
->line
);
108 vfprintf (stderr
, msg
, ap
);
109 fputc ('\n', stderr
);
115 /* asprintf, but produces fatal message on out-of-memory. */
117 xasprintf (const char *format
, ...)
123 va_start (ap
, format
);
124 n
= vasprintf (&result
, format
, ap
);
125 if (result
== NULL
|| n
< 0)
126 fatal ("out of memory");
132 /* Input file handling. */
134 /* Table of all input files. */
135 const input_file
**gt_files
;
138 /* A number of places use the name of this "gengtype.c" file for a
139 location for things that we can't rely on the source to define.
140 Make sure we can still use pointer comparison on filenames. */
141 input_file
* this_file
;
142 /* The "system.h" file is likewise specially useful. */
143 input_file
* system_h_file
;
145 /* Vector of per-language directories. */
146 const char **lang_dir_names
;
147 size_t num_lang_dirs
;
149 /* An array of output files suitable for definitions. There is one
150 BASE_FILES entry for each language. */
151 static outf_p
*base_files
;
156 /* Utility debugging function, printing the various type counts within
157 a list of types. Called thru the DBGPRINT_COUNT_TYPE macro. */
159 dbgprint_count_type_at (const char *fil
, int lin
, const char *msg
, type_p t
)
161 int nb_types
= 0, nb_scalar
= 0, nb_string
= 0;
162 int nb_struct
= 0, nb_union
= 0, nb_array
= 0, nb_pointer
= 0;
163 int nb_lang_struct
= 0, nb_param_struct
= 0;
165 for (p
= t
; p
; p
= p
->next
)
188 case TYPE_LANG_STRUCT
:
191 case TYPE_PARAM_STRUCT
:
198 fprintf (stderr
, "\n" "%s:%d: %s: @@%%@@ %d types ::\n",
199 lbasename (fil
), lin
, msg
, nb_types
);
200 if (nb_scalar
> 0 || nb_string
> 0)
201 fprintf (stderr
, "@@%%@@ %d scalars, %d strings\n", nb_scalar
, nb_string
);
202 if (nb_struct
> 0 || nb_union
> 0)
203 fprintf (stderr
, "@@%%@@ %d structs, %d unions\n", nb_struct
, nb_union
);
204 if (nb_pointer
> 0 || nb_array
> 0)
205 fprintf (stderr
, "@@%%@@ %d pointers, %d arrays\n", nb_pointer
, nb_array
);
206 if (nb_lang_struct
> 0 || nb_param_struct
> 0)
207 fprintf (stderr
, "@@%%@@ %d lang_structs, %d param_structs\n",
208 nb_lang_struct
, nb_param_struct
);
209 fprintf (stderr
, "\n");
211 #endif /* ENABLE_CHECKING */
213 /* Scan the input file, LIST, and determine how much space we need to
214 store strings in. Also, count the number of language directories
215 and files. The numbers returned are overestimates as they does not
216 consider repeated files. */
218 measure_input_list (FILE *list
)
224 num_gt_files
= plugin_files
? nb_plugin_files
: 0;
225 while ((c
= getc (list
)) != EOF
)
234 /* Add space for a lang_bitmap before the input file name. */
235 n
+= sizeof (lang_bitmap
);
249 /* Read one input line from LIST to HEREP (which is updated). A
250 pointer to the string is returned via LINEP. If it was a language
251 subdirectory in square brackets, strip off the square brackets and
252 return true. Otherwise, leave space before the string for a
253 lang_bitmap, and return false. At EOF, returns false, does not
254 touch *HEREP, and sets *LINEP to NULL. POS is used for
257 read_input_line (FILE *list
, char **herep
, char **linep
, struct fileloc
*pos
)
263 /* Read over whitespace. */
264 while (c
== '\n' || c
== ' ')
274 /* No space for a lang_bitmap is necessary. Discard the '['. */
277 while (c
!= ']' && c
!= '\n' && c
!= EOF
)
286 c
= getc (list
); /* eat what should be a newline */
287 if (c
!= '\n' && c
!= EOF
)
288 error_at_line (pos
, "junk on line after language tag [%s]", line
);
291 error_at_line (pos
, "missing close bracket for language tag [%s",
300 /* Leave space for a lang_bitmap. */
301 memset (here
, 0, sizeof (lang_bitmap
));
302 here
+= sizeof (lang_bitmap
);
309 while (c
!= EOF
&& c
!= '\n');
317 /* Read the list of input files from LIST and compute all of the
318 relevant tables. There is one file per line of the list. At
319 first, all the files on the list are language-generic, but
320 eventually a line will appear which is the name of a language
321 subdirectory in square brackets, like this: [cp]. All subsequent
322 files are specific to that language, until another language
323 subdirectory tag appears. Files can appear more than once, if
324 they apply to more than one language. */
326 read_input_list (const char *listname
)
328 FILE *list
= fopen (listname
, "r");
330 fatal ("cannot open %s: %s", listname
, xstrerror (errno
));
334 size_t bufsz
= measure_input_list (list
);
335 char *buf
= XNEWVEC (char, bufsz
);
337 char *committed
= buf
;
338 char *limit
= buf
+ bufsz
;
343 lang_bitmap curlangs
= (1 << num_lang_dirs
) - 1;
345 epos
.file
= input_file_by_name (listname
);
348 lang_dir_names
= XNEWVEC (const char *, num_lang_dirs
);
349 gt_files
= XNEWVEC (const input_file
*, num_gt_files
);
356 is_language
= read_input_line (list
, &here
, &line
, &epos
);
357 gcc_assert (here
<= limit
);
360 else if (is_language
)
363 gcc_assert (langno
<= num_lang_dirs
);
364 for (i
= 0; i
< langno
; i
++)
365 if (strcmp (lang_dir_names
[i
], line
) == 0)
367 error_at_line (&epos
, "duplicate language tag [%s]",
374 curlangs
= 1 << langno
;
375 lang_dir_names
[langno
++] = line
;
380 input_file
*inpf
= input_file_by_name (line
);
381 gcc_assert (nfiles
<= num_gt_files
);
382 for (i
= 0; i
< nfiles
; i
++)
383 /* Since the input_file-s are uniquely hash-consed, we
384 can just compare pointers! */
385 if (gt_files
[i
] == inpf
)
387 /* Throw away the string we just read, and add the
388 current language to the existing string's bitmap. */
389 lang_bitmap bmap
= get_lang_bitmap (inpf
);
391 error_at_line (&epos
,
392 "file %s specified more than once "
393 "for language %s", line
,
395 0 ? "(all)" : lang_dir_names
[langno
-
399 set_lang_bitmap (inpf
, bmap
);
404 set_lang_bitmap (inpf
, curlangs
);
405 gt_files
[nfiles
++] = inpf
;
408 /* Update the global counts now that we know accurately how many
409 things there are. (We do not bother resizing the arrays down.) */
410 num_lang_dirs
= langno
;
411 /* Add the plugin files if provided. */
415 for (i
= 0; i
< nb_plugin_files
; i
++)
416 gt_files
[nfiles
++] = plugin_files
[i
];
418 num_gt_files
= nfiles
;
421 /* Sanity check: any file that resides in a language subdirectory
422 (e.g. 'cp') ought to belong to the corresponding language.
423 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
424 (Can you even do that? Should you be allowed to?) */
427 for (f
= 0; f
< num_gt_files
; f
++)
429 lang_bitmap bitmap
= get_lang_bitmap (gt_files
[f
]);
430 const char *basename
= get_file_basename (gt_files
[f
]);
431 const char *slashpos
= strchr (basename
, '/');
436 for (l
= 0; l
< num_lang_dirs
; l
++)
437 if ((size_t) (slashpos
- basename
) == strlen (lang_dir_names
[l
])
438 && memcmp (basename
, lang_dir_names
[l
],
439 strlen (lang_dir_names
[l
])) == 0)
441 if (!(bitmap
& (1 << l
)))
442 error ("%s is in language directory '%s' but is not "
443 "tagged for that language",
444 basename
, lang_dir_names
[l
]);
452 fatal ("error reading %s: %s", listname
, xstrerror (errno
));
459 /* The one and only TYPE_STRING. */
461 struct type string_type
= {
462 TYPE_STRING
, 0, 0, 0, GC_USED
, {0}
465 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
466 set early in main. */
468 struct type scalar_nonchar
= {
469 TYPE_SCALAR
, 0, 0, 0, GC_USED
, {0}
472 struct type scalar_char
= {
473 TYPE_SCALAR
, 0, 0, 0, GC_USED
, {0}
476 /* Lists of various things. */
480 type_p param_structs
;
483 static type_p
find_param_structure (type_p t
, type_p param
[NUM_PARAM
]);
484 static type_p
adjust_field_tree_exp (type_p t
, options_p opt
);
485 static type_p
adjust_field_rtx_def (type_p t
, options_p opt
);
487 /* Define S as a typedef to T at POS. */
490 do_typedef (const char *s
, type_p t
, struct fileloc
*pos
)
494 /* temporary kludge - gengtype doesn't handle conditionals or
495 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
496 is coming from this file (main() sets them up with safe dummy
498 if (!strcmp (s
, "CUMULATIVE_ARGS") && pos
->file
!= this_file
)
501 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
502 if (strcmp (p
->name
, s
) == 0)
506 error_at_line (pos
, "type `%s' previously defined", s
);
507 error_at_line (&p
->line
, "previously defined here");
512 p
= XNEW (struct pair
);
521 /* Define S as a typename of a scalar. Cannot be used to define
522 typedefs of 'char'. Note: is also used for pointer-to-function
523 typedefs (which are therefore not treated as pointers). */
526 do_scalar_typedef (const char *s
, struct fileloc
*pos
)
528 do_typedef (s
, &scalar_nonchar
, pos
);
531 /* Return the type previously defined for S. Use POS to report errors. */
534 resolve_typedef (const char *s
, struct fileloc
*pos
)
537 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
538 if (strcmp (p
->name
, s
) == 0)
540 error_at_line (pos
, "unidentified type `%s'", s
);
541 return &scalar_nonchar
; /* treat as "int" */
544 /* Create and return a new structure with tag NAME (or a union iff
545 ISUNION is nonzero), at POS with fields FIELDS and options O. */
548 new_structure (const char *name
, int isunion
, struct fileloc
*pos
,
549 pair_p fields
, options_p o
)
553 lang_bitmap bitmap
= get_lang_bitmap (pos
->file
);
555 for (si
= structures
; si
!= NULL
; si
= si
->next
)
556 if (strcmp (name
, si
->u
.s
.tag
) == 0 && UNION_P (si
) == isunion
)
559 if (si
->kind
== TYPE_LANG_STRUCT
)
563 for (si
= ls
->u
.s
.lang_struct
; si
!= NULL
; si
= si
->next
)
564 if (si
->u
.s
.bitmap
== bitmap
)
567 else if (si
->u
.s
.line
.file
!= NULL
&& si
->u
.s
.bitmap
!= bitmap
)
571 si
= XCNEW (struct type
);
572 memcpy (si
, ls
, sizeof (struct type
));
573 ls
->kind
= TYPE_LANG_STRUCT
;
574 ls
->u
.s
.lang_struct
= si
;
575 ls
->u
.s
.fields
= NULL
;
577 si
->state_number
= -type_count
;
578 si
->pointer_to
= NULL
;
579 si
->u
.s
.lang_struct
= ls
;
584 if (ls
!= NULL
&& s
== NULL
)
587 s
= XCNEW (struct type
);
588 s
->state_number
= -type_count
;
589 s
->next
= ls
->u
.s
.lang_struct
;
590 ls
->u
.s
.lang_struct
= s
;
591 s
->u
.s
.lang_struct
= ls
;
599 s
= XCNEW (struct type
);
600 s
->state_number
= -type_count
;
601 s
->next
= structures
;
605 if (s
->u
.s
.line
.file
!= NULL
606 || (s
->u
.s
.lang_struct
&& (s
->u
.s
.lang_struct
->u
.s
.bitmap
& bitmap
)))
608 error_at_line (pos
, "duplicate definition of '%s %s'",
609 isunion
? "union" : "struct", s
->u
.s
.tag
);
610 error_at_line (&s
->u
.s
.line
, "previous definition here");
613 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
616 s
->u
.s
.fields
= fields
;
618 s
->u
.s
.bitmap
= bitmap
;
619 if (s
->u
.s
.lang_struct
)
620 s
->u
.s
.lang_struct
->u
.s
.bitmap
|= bitmap
;
625 /* Return the previously-defined structure with tag NAME (or a union
626 iff ISUNION is nonzero), or a new empty structure or union if none
627 was defined previously. */
630 find_structure (const char *name
, int isunion
)
634 for (s
= structures
; s
!= NULL
; s
= s
->next
)
635 if (strcmp (name
, s
->u
.s
.tag
) == 0 && UNION_P (s
) == isunion
)
639 s
= XCNEW (struct type
);
640 s
->next
= structures
;
641 s
->state_number
= -type_count
;
643 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
649 /* Return the previously-defined parameterized structure for structure
650 T and parameters PARAM, or a new parameterized empty structure or
651 union if none was defined previously. */
654 find_param_structure (type_p t
, type_p param
[NUM_PARAM
])
658 for (res
= param_structs
; res
; res
= res
->next
)
659 if (res
->u
.param_struct
.stru
== t
660 && memcmp (res
->u
.param_struct
.param
, param
,
661 sizeof (type_p
) * NUM_PARAM
) == 0)
666 res
= XCNEW (struct type
);
667 res
->kind
= TYPE_PARAM_STRUCT
;
668 res
->next
= param_structs
;
669 res
->state_number
= -type_count
;
671 res
->u
.param_struct
.stru
= t
;
672 memcpy (res
->u
.param_struct
.param
, param
, sizeof (type_p
) * NUM_PARAM
);
677 /* Return a scalar type with name NAME. */
680 create_scalar_type (const char *name
)
682 if (!strcmp (name
, "char") || !strcmp (name
, "unsigned char"))
685 return &scalar_nonchar
;
688 /* Return a pointer to T. */
691 create_pointer (type_p t
)
695 type_p r
= XCNEW (struct type
);
697 r
->state_number
= -type_count
;
698 r
->kind
= TYPE_POINTER
;
702 return t
->pointer_to
;
705 /* Return an array of length LEN. */
708 create_array (type_p t
, const char *len
)
713 v
= XCNEW (struct type
);
714 v
->kind
= TYPE_ARRAY
;
715 v
->state_number
= -type_count
;
721 /* Return a string options structure with name NAME and info INFO.
722 NEXT is the next option in the chain. */
724 create_string_option (options_p next
, const char *name
, const char *info
)
726 options_p o
= XNEW (struct options
);
727 o
->kind
= OPTION_STRING
;
730 o
->info
.string
= info
;
734 /* Create a type options structure with name NAME and info INFO. NEXT
735 is the next option in the chain. */
737 create_type_option (options_p next
, const char* name
, type_p info
)
739 options_p o
= XNEW (struct options
);
742 o
->kind
= OPTION_TYPE
;
747 /* Create a nested pointer options structure with name NAME and info
748 INFO. NEXT is the next option in the chain. */
750 create_nested_option (options_p next
, const char* name
,
751 struct nested_ptr_data
* info
)
754 o
= XNEW (struct options
);
757 o
->kind
= OPTION_NESTED
;
758 o
->info
.nested
= info
;
762 /* Return an options structure for a "nested_ptr" option. */
764 create_nested_ptr_option (options_p next
, type_p t
,
765 const char *to
, const char *from
)
767 struct nested_ptr_data
*d
= XNEW (struct nested_ptr_data
);
769 d
->type
= adjust_field_type (t
, 0);
771 d
->convert_from
= from
;
772 return create_nested_option (next
, "nested_ptr", d
);
775 /* Add a variable named S of type T with options O defined at POS,
778 note_variable (const char *s
, type_p t
, options_p o
, struct fileloc
*pos
)
781 n
= XNEW (struct pair
);
790 /* Most-general structure field creator. */
792 create_field_all (pair_p next
, type_p type
, const char *name
, options_p opt
,
793 const input_file
*inpf
, int line
)
797 field
= XNEW (struct pair
);
802 field
->line
.file
= inpf
;
803 field
->line
.line
= line
;
807 /* Create a field that came from the source code we are scanning,
808 i.e. we have a 'struct fileloc', and possibly options; also,
809 adjust_field_type should be called. */
811 create_field_at (pair_p next
, type_p type
, const char *name
, options_p opt
,
814 return create_field_all (next
, adjust_field_type (type
, opt
),
815 name
, opt
, pos
->file
, pos
->line
);
818 /* Create a fake field with the given type and name. NEXT is the next
819 field in the chain. */
820 #define create_field(next,type,name) \
821 create_field_all(next,type,name, 0, this_file, __LINE__)
823 /* Like create_field, but the field is only valid when condition COND
827 create_optional_field_ (pair_p next
, type_p type
, const char *name
,
828 const char *cond
, int line
)
834 /* Create a fake union type with a single nameless field of type TYPE.
835 The field has a tag of "1". This allows us to make the presence
836 of a field of type TYPE depend on some boolean "desc" being true. */
837 union_fields
= create_field (NULL
, type
, "");
839 create_string_option (union_fields
->opt
, "dot", "");
841 create_string_option (union_fields
->opt
, "tag", "1");
843 new_structure (xasprintf ("%s_%d", "fake_union", id
++), 1,
844 &lexer_line
, union_fields
, NULL
);
846 /* Create the field and give it the new fake union type. Add a "desc"
847 tag that specifies the condition under which the field is valid. */
848 return create_field_all (next
, union_type
, name
,
849 create_string_option (0, "desc", cond
),
853 #define create_optional_field(next,type,name,cond) \
854 create_optional_field_(next,type,name,cond,__LINE__)
856 /* Reverse a linked list of 'struct pair's in place. */
858 nreverse_pairs (pair_p list
)
860 pair_p prev
= 0, p
, next
;
861 for (p
= list
; p
; p
= next
)
871 /* We don't care how long a CONST_DOUBLE is. */
872 #define CONST_DOUBLE_FORMAT "ww"
873 /* We don't want to see codes that are only for generator files. */
874 #undef GENERATOR_FILE
878 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
884 static const char *const rtx_name
[NUM_RTX_CODE
] = {
885 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
890 static const char *const rtx_format
[NUM_RTX_CODE
] = {
891 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
896 static int rtx_next_new
[NUM_RTX_CODE
];
898 /* We also need codes and names for insn notes (not register notes).
899 Note that we do *not* bias the note values here. */
902 #define DEF_INSN_NOTE(NAME) NAME,
903 #include "insn-notes.def"
909 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
910 default field for line number notes. */
911 static const char *const note_insn_name
[NOTE_INSN_MAX
+ 1] = {
912 #define DEF_INSN_NOTE(NAME) #NAME,
913 #include "insn-notes.def"
917 #undef CONST_DOUBLE_FORMAT
918 #define GENERATOR_FILE
920 /* Generate the contents of the rtx_next array. This really doesn't belong
921 in gengtype at all, but it's needed for adjust_field_rtx_def. */
927 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
931 rtx_next_new
[i
] = -1;
932 if (strncmp (rtx_format
[i
], "iuu", 3) == 0)
934 else if (i
== COND_EXEC
|| i
== SET
|| i
== EXPR_LIST
|| i
== INSN_LIST
)
937 for (k
= strlen (rtx_format
[i
]) - 1; k
>= 0; k
--)
938 if (rtx_format
[i
][k
] == 'e' || rtx_format
[i
][k
] == 'u')
943 /* Write out the contents of the rtx_next array. */
945 write_rtx_next (void)
947 outf_p f
= get_output_file_with_visibility (NULL
);
952 oprintf (f
, "\n/* Used to implement the RTX_NEXT macro. */\n");
953 oprintf (f
, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
954 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
955 if (rtx_next_new
[i
] == -1)
956 oprintf (f
, " 0,\n");
959 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n", rtx_next_new
[i
]);
963 /* Handle `special("rtx_def")'. This is a special case for field
964 `fld' of struct rtx_def, which is an array of unions whose values
965 are based in a complex way on the type of RTL. */
968 adjust_field_rtx_def (type_p t
, options_p
ARG_UNUSED (opt
))
973 type_p rtx_tp
, rtvec_tp
, tree_tp
, mem_attrs_tp
, note_union_tp
, scalar_tp
;
974 type_p basic_block_tp
, reg_attrs_tp
, constant_tp
, symbol_union_tp
;
976 if (t
->kind
!= TYPE_UNION
)
978 error_at_line (&lexer_line
,
979 "special `rtx_def' must be applied to a union");
983 nodot
= create_string_option (NULL
, "dot", "");
985 rtx_tp
= create_pointer (find_structure ("rtx_def", 0));
986 rtvec_tp
= create_pointer (find_structure ("rtvec_def", 0));
987 tree_tp
= create_pointer (find_structure ("tree_node", 1));
988 mem_attrs_tp
= create_pointer (find_structure ("mem_attrs", 0));
990 create_pointer (find_structure ("reg_attrs", 0));
992 create_pointer (find_structure ("basic_block_def", 0));
994 create_pointer (find_structure ("constant_descriptor_rtx", 0));
995 scalar_tp
= &scalar_nonchar
; /* rtunion int */
998 pair_p note_flds
= NULL
;
1001 for (c
= 0; c
<= NOTE_INSN_MAX
; c
++)
1006 case NOTE_INSN_DELETED_LABEL
:
1007 note_flds
= create_field (note_flds
, &string_type
, "rt_str");
1010 case NOTE_INSN_BLOCK_BEG
:
1011 case NOTE_INSN_BLOCK_END
:
1012 note_flds
= create_field (note_flds
, tree_tp
, "rt_tree");
1015 case NOTE_INSN_VAR_LOCATION
:
1016 case NOTE_INSN_CALL_ARG_LOCATION
:
1017 note_flds
= create_field (note_flds
, rtx_tp
, "rt_rtx");
1021 note_flds
= create_field (note_flds
, scalar_tp
, "rt_int");
1024 /* NOTE_INSN_MAX is used as the default field for line
1026 if (c
== NOTE_INSN_MAX
)
1028 create_string_option (nodot
, "default", "");
1031 create_string_option (nodot
, "tag", note_insn_name
[c
]);
1033 note_union_tp
= new_structure ("rtx_def_note_subunion", 1,
1034 &lexer_line
, note_flds
, NULL
);
1036 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1039 sym_flds
= create_field (NULL
, tree_tp
, "rt_tree");
1040 sym_flds
->opt
= create_string_option (nodot
, "default", "");
1041 sym_flds
= create_field (sym_flds
, constant_tp
, "rt_constant");
1042 sym_flds
->opt
= create_string_option (nodot
, "tag", "1");
1043 symbol_union_tp
= new_structure ("rtx_def_symbol_subunion", 1,
1044 &lexer_line
, sym_flds
, NULL
);
1046 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1048 pair_p subfields
= NULL
;
1049 size_t aindex
, nmindex
;
1054 for (aindex
= 0; aindex
< strlen (rtx_format
[i
]); aindex
++)
1057 const char *subname
;
1059 switch (rtx_format
[i
][aindex
])
1070 if (i
== MEM
&& aindex
== 1)
1071 t
= mem_attrs_tp
, subname
= "rt_mem";
1072 else if (i
== JUMP_INSN
&& aindex
== 8)
1073 t
= rtx_tp
, subname
= "rt_rtx";
1074 else if (i
== CODE_LABEL
&& aindex
== 5)
1075 t
= scalar_tp
, subname
= "rt_int";
1076 else if (i
== CODE_LABEL
&& aindex
== 4)
1077 t
= rtx_tp
, subname
= "rt_rtx";
1078 else if (i
== LABEL_REF
&& (aindex
== 1 || aindex
== 2))
1079 t
= rtx_tp
, subname
= "rt_rtx";
1080 else if (i
== NOTE
&& aindex
== 4)
1081 t
= note_union_tp
, subname
= "";
1082 else if (i
== NOTE
&& aindex
== 5)
1083 t
= scalar_tp
, subname
= "rt_int";
1084 else if (i
== NOTE
&& aindex
>= 7)
1085 t
= scalar_tp
, subname
= "rt_int";
1086 else if (i
== ADDR_DIFF_VEC
&& aindex
== 4)
1087 t
= scalar_tp
, subname
= "rt_int";
1088 else if (i
== VALUE
&& aindex
== 0)
1089 t
= scalar_tp
, subname
= "rt_int";
1090 else if (i
== DEBUG_EXPR
&& aindex
== 0)
1091 t
= tree_tp
, subname
= "rt_tree";
1092 else if (i
== REG
&& aindex
== 1)
1093 t
= scalar_tp
, subname
= "rt_int";
1094 else if (i
== REG
&& aindex
== 2)
1095 t
= reg_attrs_tp
, subname
= "rt_reg";
1096 else if (i
== SCRATCH
&& aindex
== 0)
1097 t
= scalar_tp
, subname
= "rt_int";
1098 else if (i
== SYMBOL_REF
&& aindex
== 1)
1099 t
= scalar_tp
, subname
= "rt_int";
1100 else if (i
== SYMBOL_REF
&& aindex
== 2)
1101 t
= symbol_union_tp
, subname
= "";
1102 else if (i
== BARRIER
&& aindex
>= 3)
1103 t
= scalar_tp
, subname
= "rt_int";
1108 "rtx type `%s' has `0' in position %lu, can't handle",
1109 rtx_name
[i
], (unsigned long) aindex
);
1131 subname
= "rt_rtvec";
1136 subname
= "rt_tree";
1147 "rtx type `%s' has `%c' in position %lu, can't handle",
1148 rtx_name
[i
], rtx_format
[i
][aindex
],
1149 (unsigned long) aindex
);
1155 subfields
= create_field (subfields
, t
,
1156 xasprintf (".fld[%lu].%s",
1157 (unsigned long) aindex
,
1159 subfields
->opt
= nodot
;
1160 if (t
== note_union_tp
)
1162 create_string_option (subfields
->opt
, "desc",
1164 if (t
== symbol_union_tp
)
1166 create_string_option (subfields
->opt
, "desc",
1167 "CONSTANT_POOL_ADDRESS_P (&%0)");
1170 if (i
== SYMBOL_REF
)
1172 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P
1174 type_p field_tp
= find_structure ("block_symbol", 0);
1176 = create_optional_field (subfields
, field_tp
, "block_sym",
1177 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1180 sname
= xasprintf ("rtx_def_%s", rtx_name
[i
]);
1181 substruct
= new_structure (sname
, 0, &lexer_line
, subfields
, NULL
);
1183 ftag
= xstrdup (rtx_name
[i
]);
1184 for (nmindex
= 0; nmindex
< strlen (ftag
); nmindex
++)
1185 ftag
[nmindex
] = TOUPPER (ftag
[nmindex
]);
1186 flds
= create_field (flds
, substruct
, "");
1187 flds
->opt
= create_string_option (nodot
, "tag", ftag
);
1189 return new_structure ("rtx_def_subunion", 1, &lexer_line
, flds
, nodot
);
1192 /* Handle `special("tree_exp")'. This is a special case for
1193 field `operands' of struct tree_exp, which although it claims to contain
1194 pointers to trees, actually sometimes contains pointers to RTL too.
1195 Passed T, the old type of the field, and OPT its options. Returns
1196 a new type for the field. */
1199 adjust_field_tree_exp (type_p t
, options_p opt ATTRIBUTE_UNUSED
)
1204 if (t
->kind
!= TYPE_ARRAY
)
1206 error_at_line (&lexer_line
,
1207 "special `tree_exp' must be applied to an array");
1208 return &string_type
;
1211 nodot
= create_string_option (NULL
, "dot", "");
1213 flds
= create_field (NULL
, t
, "");
1214 flds
->opt
= create_string_option (nodot
, "length",
1215 "TREE_OPERAND_LENGTH ((tree) &%0)");
1216 flds
->opt
= create_string_option (flds
->opt
, "default", "");
1218 return new_structure ("tree_exp_subunion", 1, &lexer_line
, flds
, nodot
);
1221 /* Perform any special processing on a type T, about to become the type
1222 of a field. Return the appropriate type for the field.
1224 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1225 - Similarly for arrays of pointer-to-char;
1226 - Converts structures for which a parameter is provided to
1228 - Handles "special" options.
1232 adjust_field_type (type_p t
, options_p opt
)
1235 const int pointer_p
= t
->kind
== TYPE_POINTER
;
1236 type_p params
[NUM_PARAM
];
1240 for (i
= 0; i
< NUM_PARAM
; i
++)
1243 for (; opt
; opt
= opt
->next
)
1244 if (strcmp (opt
->name
, "length") == 0)
1246 else if ((strcmp (opt
->name
, "param_is") == 0
1247 || (strncmp (opt
->name
, "param", 5) == 0
1248 && ISDIGIT (opt
->name
[5])
1249 && strcmp (opt
->name
+ 6, "_is") == 0))
1250 && opt
->kind
== OPTION_TYPE
)
1252 int num
= ISDIGIT (opt
->name
[5]) ? opt
->name
[5] - '0' : 0;
1254 if (!UNION_OR_STRUCT_P (t
)
1255 && (t
->kind
!= TYPE_POINTER
|| !UNION_OR_STRUCT_P (t
->u
.p
)))
1257 error_at_line (&lexer_line
,
1258 "option `%s' may only be applied to structures or structure pointers",
1264 if (params
[num
] != NULL
)
1265 error_at_line (&lexer_line
, "duplicate `%s' option", opt
->name
);
1266 if (!ISDIGIT (opt
->name
[5]))
1267 params
[num
] = create_pointer (opt
->info
.type
);
1269 params
[num
] = opt
->info
.type
;
1271 else if (strcmp (opt
->name
, "special") == 0
1272 && opt
->kind
== OPTION_STRING
)
1274 const char *special_name
= opt
->info
.string
;
1275 if (strcmp (special_name
, "tree_exp") == 0)
1276 t
= adjust_field_tree_exp (t
, opt
);
1277 else if (strcmp (special_name
, "rtx_def") == 0)
1278 t
= adjust_field_rtx_def (t
, opt
);
1280 error_at_line (&lexer_line
, "unknown special `%s'", special_name
);
1289 realt
= find_param_structure (t
, params
);
1290 t
= pointer_p
? create_pointer (realt
) : realt
;
1294 && pointer_p
&& t
->u
.p
->kind
== TYPE_SCALAR
&& t
->u
.p
->u
.scalar_is_char
)
1295 return &string_type
;
1296 if (t
->kind
== TYPE_ARRAY
&& t
->u
.a
.p
->kind
== TYPE_POINTER
1297 && t
->u
.a
.p
->u
.p
->kind
== TYPE_SCALAR
1298 && t
->u
.a
.p
->u
.p
->u
.scalar_is_char
)
1299 return create_array (&string_type
, t
->u
.a
.len
);
1305 static void set_gc_used_type (type_p
, enum gc_used_enum
, type_p
*);
1306 static void set_gc_used (pair_p
);
1308 /* Handle OPT for set_gc_used_type. */
1311 process_gc_options (options_p opt
, enum gc_used_enum level
, int *maybe_undef
,
1312 int *pass_param
, int *length
, int *skip
,
1316 for (o
= opt
; o
; o
= o
->next
)
1317 if (strcmp (o
->name
, "ptr_alias") == 0 && level
== GC_POINTED_TO
1318 && o
->kind
== OPTION_TYPE
)
1319 set_gc_used_type (o
->info
.type
,
1320 GC_POINTED_TO
, NULL
);
1321 else if (strcmp (o
->name
, "maybe_undef") == 0)
1323 else if (strcmp (o
->name
, "use_params") == 0)
1325 else if (strcmp (o
->name
, "length") == 0)
1327 else if (strcmp (o
->name
, "skip") == 0)
1329 else if (strcmp (o
->name
, "nested_ptr") == 0
1330 && o
->kind
== OPTION_NESTED
)
1331 *nested_ptr
= ((const struct nested_ptr_data
*) o
->info
.nested
)->type
;
1335 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1337 set_gc_used_type (type_p t
, enum gc_used_enum level
, type_p param
[NUM_PARAM
])
1339 if (t
->gc_used
>= level
)
1353 process_gc_options (t
->u
.s
.opt
, level
, &dummy
, &dummy
, &dummy
, &dummy
,
1356 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
1358 int maybe_undef
= 0;
1362 type_p nested_ptr
= NULL
;
1363 process_gc_options (f
->opt
, level
, &maybe_undef
, &pass_param
,
1364 &length
, &skip
, &nested_ptr
);
1366 if (nested_ptr
&& f
->type
->kind
== TYPE_POINTER
)
1367 set_gc_used_type (nested_ptr
, GC_POINTED_TO
,
1368 pass_param
? param
: NULL
);
1369 else if (length
&& f
->type
->kind
== TYPE_POINTER
)
1370 set_gc_used_type (f
->type
->u
.p
, GC_USED
, NULL
);
1371 else if (maybe_undef
&& f
->type
->kind
== TYPE_POINTER
)
1372 set_gc_used_type (f
->type
->u
.p
, GC_MAYBE_POINTED_TO
, NULL
);
1373 else if (pass_param
&& f
->type
->kind
== TYPE_POINTER
&& param
)
1374 set_gc_used_type (find_param_structure (f
->type
->u
.p
, param
),
1375 GC_POINTED_TO
, NULL
);
1377 ; /* target type is not used through this field */
1379 set_gc_used_type (f
->type
, GC_USED
, pass_param
? param
: NULL
);
1385 set_gc_used_type (t
->u
.p
, GC_POINTED_TO
, NULL
);
1389 set_gc_used_type (t
->u
.a
.p
, GC_USED
, param
);
1392 case TYPE_LANG_STRUCT
:
1393 for (t
= t
->u
.s
.lang_struct
; t
; t
= t
->next
)
1394 set_gc_used_type (t
, level
, param
);
1397 case TYPE_PARAM_STRUCT
:
1400 for (i
= 0; i
< NUM_PARAM
; i
++)
1401 if (t
->u
.param_struct
.param
[i
] != 0)
1402 set_gc_used_type (t
->u
.param_struct
.param
[i
], GC_USED
, NULL
);
1404 if (t
->u
.param_struct
.stru
->gc_used
== GC_POINTED_TO
)
1405 level
= GC_POINTED_TO
;
1408 t
->u
.param_struct
.stru
->gc_used
= GC_UNUSED
;
1409 set_gc_used_type (t
->u
.param_struct
.stru
, level
,
1410 t
->u
.param_struct
.param
);
1418 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1421 set_gc_used (pair_p variables
)
1425 for (p
= variables
; p
; p
= p
->next
)
1427 set_gc_used_type (p
->type
, GC_USED
, NULL
);
1430 if (verbosity_level
>= 2)
1431 printf ("%s used %d GTY-ed variables\n", progname
, nbvars
);
1434 /* File mapping routines. For each input file, there is one output .c file
1435 (but some output files have many input files), and there is one .h file
1436 for the whole build. */
1438 /* Output file handling. */
1440 /* Create and return an outf_p for a new file for NAME, to be called
1444 create_file (const char *name
, const char *oname
)
1446 static const char *const hdr
[] = {
1447 " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n",
1449 "This file is part of GCC.\n",
1451 "GCC is free software; you can redistribute it and/or modify it under\n",
1452 "the terms of the GNU General Public License as published by the Free\n",
1453 "Software Foundation; either version 3, or (at your option) any later\n",
1456 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1457 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1458 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1459 "for more details.\n",
1461 "You should have received a copy of the GNU General Public License\n",
1462 "along with GCC; see the file COPYING3. If not see\n",
1463 "<http://www.gnu.org/licenses/>. */\n",
1465 "/* This file is machine generated. Do not edit. */\n"
1470 gcc_assert (name
!= NULL
);
1471 gcc_assert (oname
!= NULL
);
1472 f
= XCNEW (struct outf
);
1473 f
->next
= output_files
;
1477 oprintf (f
, "/* Type information for %s.\n", name
);
1478 for (i
= 0; i
< ARRAY_SIZE (hdr
); i
++)
1479 oprintf (f
, "%s", hdr
[i
]);
1483 /* Print, like fprintf, to O.
1484 N.B. You might think this could be implemented more efficiently
1485 with vsnprintf(). Unfortunately, there are C libraries that
1486 provide that function but without the C99 semantics for its return
1487 value, making it impossible to know how much space is required. */
1489 oprintf (outf_p o
, const char *format
, ...)
1495 /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1500 va_start (ap
, format
);
1501 slength
= vasprintf (&s
, format
, ap
);
1502 if (s
== NULL
|| (int) slength
< 0)
1503 fatal ("out of memory");
1506 if (o
->bufused
+ slength
> o
->buflength
)
1508 size_t new_len
= o
->buflength
;
1515 while (o
->bufused
+ slength
>= new_len
);
1516 o
->buf
= XRESIZEVEC (char, o
->buf
, new_len
);
1517 o
->buflength
= new_len
;
1519 memcpy (o
->buf
+ o
->bufused
, s
, slength
);
1520 o
->bufused
+= slength
;
1524 /* Open the global header file and the language-specific header files. */
1527 open_base_files (void)
1531 if (nb_plugin_files
> 0 && plugin_files
)
1534 header_file
= create_file ("GCC", "gtype-desc.h");
1536 base_files
= XNEWVEC (outf_p
, num_lang_dirs
);
1538 for (i
= 0; i
< num_lang_dirs
; i
++)
1539 base_files
[i
] = create_file (lang_dir_names
[i
],
1540 xasprintf ("gtype-%s.h", lang_dir_names
[i
]));
1542 /* gtype-desc.c is a little special, so we create it here. */
1544 /* The order of files here matters very much. */
1545 static const char *const ifiles
[] = {
1546 "config.h", "system.h", "coretypes.h", "tm.h",
1547 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1548 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1549 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1550 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1551 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1552 "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h",
1553 "target.h", "ipa-prop.h", "lto-streamer.h", "target-globals.h", NULL
1555 const char *const *ifp
;
1556 outf_p gtype_desc_c
;
1558 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1559 for (ifp
= ifiles
; *ifp
; ifp
++)
1560 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1562 /* Make sure we handle "cfun" specially. */
1563 oprintf (gtype_desc_c
, "\n/* See definition in function.h. */\n");
1564 oprintf (gtype_desc_c
, "#undef cfun\n");
1568 /* For INPF an input file, return the real basename of INPF, with all
1569 the directory components skipped. */
1572 get_file_realbasename (const input_file
*inpf
)
1574 const char *f
= get_input_file_name (inpf
);
1575 const char *lastslash
= strrchr (f
, '/');
1577 return (lastslash
!= NULL
) ? lastslash
+ 1 : f
;
1580 /* For INPF a filename, return the relative path to INPF from
1581 $(srcdir) if the latter is a prefix in INPF, NULL otherwise. */
1584 get_file_srcdir_relative_path (const input_file
*inpf
)
1586 const char *f
= get_input_file_name (inpf
);
1587 if (strlen (f
) > srcdir_len
1588 && IS_DIR_SEPARATOR (f
[srcdir_len
])
1589 && strncmp (f
, srcdir
, srcdir_len
) == 0)
1590 return f
+ srcdir_len
+ 1;
1595 /* For INPF an input_file, return the relative path to INPF from
1596 $(srcdir) if the latter is a prefix in INPF, or the real basename
1597 of INPF otherwise. */
1600 get_file_basename (const input_file
*inpf
)
1602 const char *srcdir_path
= get_file_srcdir_relative_path (inpf
);
1604 return (srcdir_path
!= NULL
) ? srcdir_path
: get_file_realbasename (inpf
);
1607 /* For F a filename, return the lang_dir_names relative index of the language
1608 directory that is a prefix in F, if any, -1 otherwise. */
1611 get_prefix_langdir_index (const char *f
)
1613 size_t f_len
= strlen (f
);
1616 for (lang_index
= 0; lang_index
< num_lang_dirs
; lang_index
++)
1618 const char *langdir
= lang_dir_names
[lang_index
];
1619 size_t langdir_len
= strlen (langdir
);
1621 if (f_len
> langdir_len
1622 && IS_DIR_SEPARATOR (f
[langdir_len
])
1623 && memcmp (f
, langdir
, langdir_len
) == 0)
1630 /* For INPF an input file, return the name of language directory where
1631 F is located, if any, NULL otherwise. */
1634 get_file_langdir (const input_file
*inpf
)
1636 /* Get the relative path to INPF from $(srcdir) and find the
1637 language by comparing the prefix with language directory names.
1638 If INPF is not even srcdir relative, no point in looking
1642 const char *srcdir_relative_path
= get_file_srcdir_relative_path (inpf
);
1645 if (!srcdir_relative_path
)
1648 lang_index
= get_prefix_langdir_index (srcdir_relative_path
);
1649 if (lang_index
< 0 && strncmp (srcdir_relative_path
, "c-family", 8) == 0)
1651 else if (lang_index
>= 0)
1652 r
= lang_dir_names
[lang_index
];
1659 /* The gt- output file name for INPF. */
1662 get_file_gtfilename (const input_file
*inpf
)
1664 /* Cook up an initial version of the gt- file name from the file real
1665 basename and the language name, if any. */
1667 const char *basename
= get_file_realbasename (inpf
);
1668 const char *langdir
= get_file_langdir (inpf
);
1671 (langdir
? xasprintf ("gt-%s-%s", langdir
, basename
)
1672 : xasprintf ("gt-%s", basename
));
1674 /* Then replace all non alphanumerics characters by '-' and change the
1675 extension to ".h". We expect the input filename extension was at least
1676 one character long. */
1680 for (; *s
!= '.'; s
++)
1681 if (!ISALNUM (*s
) && *s
!= '-')
1684 memcpy (s
, ".h", sizeof (".h"));
1689 /* Each input_file has its associated output file outf_p. The
1690 association is computed by the function
1691 get_output_file_with_visibility. The associated file is cached
1692 inside input_file in its inpoutf field, so is really computed only
1693 once. Associated output file paths (i.e. output_name-s) are
1694 computed by a rule based regexp machinery, using the files_rules
1695 array of struct file_rule_st. A for_name is also computed, giving
1696 the source file name for which the output_file is generated; it is
1697 often the last component of the input_file path. */
1701 Regexpr machinery to compute the output_name and for_name-s of each
1702 input_file. We have a sequence of file rules which gives the POSIX
1703 extended regular expression to match an input file path, and two
1704 transformed strings for the corresponding output_name and the
1705 corresponding for_name. The transformed string contain dollars: $0
1706 is replaced by the entire match, $1 is replaced by the substring
1707 matching the first parenthesis in the regexp, etc. And $$ is replaced
1708 by a single verbatim dollar. The rule order is important. The
1709 general case is last, and the particular cases should come before.
1710 An action routine can, when needed, update the out_name & for_name
1711 and/or return the appropriate output file. It is invoked only when a
1712 rule is triggered. When a rule is triggered, the output_name and
1713 for_name are computed using their transform string in while $$, $0,
1714 $1, ... are suitably replaced. If there is an action, it is called.
1715 In some few cases, the action can directly return the outf_p, but
1716 usually it just updates the output_name and for_name so should free
1717 them before replacing them. The get_output_file_with_visibility
1718 function creates an outf_p only once per each output_name, so it
1719 scans the output_files list for previously seen output file names.
1722 /* Signature of actions in file rules. */
1723 typedef outf_p (frul_actionrout_t
) (input_file
*, char**, char**);
1726 struct file_rule_st
{
1727 const char* frul_srcexpr
; /* Source string for regexp. */
1728 int frul_rflags
; /* Flags passed to regcomp, usually
1730 regex_t
* frul_re
; /* Compiled regular expression
1731 obtained by regcomp. */
1732 const char* frul_tr_out
; /* Transformation string for making
1733 * the output_name, with $1 ... $9 for
1734 * subpatterns and $0 for the whole
1735 * matched filename. */
1736 const char* frul_tr_for
; /* Tranformation string for making the
1738 frul_actionrout_t
* frul_action
; /* The action, if non null, is
1739 * called once the rule matches, on
1740 * the transformed out_name &
1741 * for_name. It could change them
1742 * and/or give the output file. */
1745 /* File rule action handling *.h files. */
1746 static outf_p
header_dot_h_frul (input_file
*, char**, char**);
1748 /* File rule action handling *.c files. */
1749 static outf_p
source_dot_c_frul (input_file
*, char**, char**);
1751 #define NULL_REGEX (regex_t*)0
1753 /* The prefix in our regexp-s matching the directory. */
1754 #define DIR_PREFIX_REGEX "^(([^/]*/)*)"
1756 #define NULL_FRULACT (frul_actionrout_t*)0
1758 /* The array of our rules governing file name generation. Rules order
1759 matters, so change with extreme care! */
1761 struct file_rule_st files_rules
[] = {
1762 /* the c-family/ source directory is special. */
1763 { DIR_PREFIX_REGEX
"c-family/([[:alnum:]_-]*)\\.c$",
1764 REG_EXTENDED
, NULL_REGEX
,
1765 "gt-c-family-$3.h", "c-family/$3.c", NULL_FRULACT
},
1767 { DIR_PREFIX_REGEX
"c-family/([[:alnum:]_-]*)\\.h$",
1768 REG_EXTENDED
, NULL_REGEX
,
1769 "gt-c-family-$3.h", "c-family/$3.h", NULL_FRULACT
},
1771 /* Both c-lang.h & c-tree.h gives gt-c-decl.h for c-decl.c ! */
1772 { DIR_PREFIX_REGEX
"c-lang\\.h$",
1773 REG_EXTENDED
, NULL_REGEX
, "gt-c-decl.h", "c-decl.c", NULL_FRULACT
},
1775 { DIR_PREFIX_REGEX
"c-tree\\.h$",
1776 REG_EXTENDED
, NULL_REGEX
, "gt-c-decl.h", "c-decl.c", NULL_FRULACT
},
1778 /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.c ! */
1779 { DIR_PREFIX_REGEX
"cp/cp-tree\\.h$",
1780 REG_EXTENDED
, NULL_REGEX
,
1781 "gt-cp-tree.h", "cp/tree.c", NULL_FRULACT
},
1783 /* cp/decl.h & cp/decl.c gives gt-cp-decl.h for cp/decl.c ! */
1784 { DIR_PREFIX_REGEX
"cp/decl\\.[ch]$",
1785 REG_EXTENDED
, NULL_REGEX
,
1786 "gt-cp-decl.h", "cp/decl.c", NULL_FRULACT
},
1788 /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.c ! */
1789 { DIR_PREFIX_REGEX
"cp/name-lookup\\.h$",
1790 REG_EXTENDED
, NULL_REGEX
,
1791 "gt-cp-name-lookup.h", "cp/name-lookup.c", NULL_FRULACT
},
1793 /* objc/objc-act.h fives gt-objc-objc-act.h for objc/objc-act.c ! */
1794 { DIR_PREFIX_REGEX
"objc/objc-act\\.h$",
1795 REG_EXTENDED
, NULL_REGEX
,
1796 "gt-objc-objc-act.h", "objc/objc-act.c", NULL_FRULACT
},
1798 /* General cases. For header *.h and source *.c files, we need
1799 * special actions to handle the language. */
1801 /* Source *.c files are using get_file_gtfilename to compute their
1802 output_name and get_file_basename to compute their for_name
1803 thru the source_dot_c_frul action. */
1804 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.c$",
1805 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.c", source_dot_c_frul
},
1806 /* Common header files get "gtype-desc.c" as their output_name,
1807 * while language specific header files are handled specially. So
1808 * we need the header_dot_h_frul action. */
1809 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.h$",
1810 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.h", header_dot_h_frul
},
1812 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.in$",
1813 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.in", NULL_FRULACT
},
1815 /* Mandatory null last entry signaling end of rules. */
1816 {NULL
, 0, NULL_REGEX
, NULL
, NULL
, NULL_FRULACT
}
1819 /* Special file rules action for handling *.h header files. It gives
1820 "gtype-desc.c" for common headers and corresponding output
1821 files for language-specific header files. */
1823 header_dot_h_frul (input_file
* inpf
, char**poutname
,
1824 char**pforname ATTRIBUTE_UNUSED
)
1826 const char *basename
= 0;
1828 DBGPRINTF ("inpf %p inpname %s outname %s forname %s",
1829 (void*) inpf
, get_input_file_name (inpf
),
1830 *poutname
, *pforname
);
1831 basename
= get_file_basename (inpf
);
1832 lang_index
= get_prefix_langdir_index (basename
);
1833 DBGPRINTF ("basename %s lang_index %d", basename
, lang_index
);
1835 if (lang_index
>= 0)
1837 /* The header is language specific. Given output_name &
1838 for_name remains unchanged. The base_files array gives the
1840 DBGPRINTF ("header_dot_h found language specific @ %p '%s'",
1841 (void*) base_files
[lang_index
],
1842 (base_files
[lang_index
])->name
);
1843 return base_files
[lang_index
];
1847 /* The header is common to all front-end languages. So
1848 output_name is "gtype-desc.c" file. The calling function
1849 get_output_file_with_visibility will find its outf_p. */
1851 *poutname
= xstrdup ("gtype-desc.c");
1852 DBGPRINTF ("special 'gtype-desc.c' for inpname %s",
1853 get_input_file_name (inpf
));
1859 /* Special file rules action for handling *.c source files using
1860 * get_file_gtfilename to compute their output_name and
1861 * get_file_basename to compute their for_name. The output_name is
1862 * gt-<LANG>-<BASE>.h for language specific source files, and
1863 * gt-<BASE>.h for common source files. */
1865 source_dot_c_frul (input_file
* inpf
, char**poutname
, char**pforname
)
1867 char *newbasename
= CONST_CAST (char*, get_file_basename (inpf
));
1868 char *newoutname
= CONST_CAST (char*, get_file_gtfilename (inpf
));
1869 DBGPRINTF ("inpf %p inpname %s original outname %s forname %s",
1870 (void*) inpf
, get_input_file_name (inpf
),
1871 *poutname
, *pforname
);
1872 DBGPRINTF ("newoutname %s", newoutname
);
1873 DBGPRINTF ("newbasename %s", newbasename
);
1876 *poutname
= newoutname
;
1877 *pforname
= newbasename
;
1881 /* Utility function for get_output_file_with_visibility which returns
1882 * a malloc-ed substituted string using TRS on matching of the FILNAM
1883 * file name, using the PMATCH array. */
1885 matching_file_name_substitute (const char *filnam
, regmatch_t pmatch
[10],
1888 struct obstack str_obstack
;
1890 char *rawstr
= NULL
;
1891 const char *pt
= NULL
;
1892 DBGPRINTF ("filnam %s", filnam
);
1893 obstack_init (&str_obstack
);
1894 for (pt
= trs
; *pt
; pt
++) {
1900 /* A double dollar $$ is substituted by a single verbatim
1901 dollar, but who really uses dollar signs in file
1903 obstack_1grow (&str_obstack
, '$');
1905 else if (ISDIGIT (pt
[1]))
1907 /* Handle $0 $1 ... $9 by appropriate substitution. */
1908 int dolnum
= pt
[1] - '0';
1909 int so
= pmatch
[dolnum
].rm_so
;
1910 int eo
= pmatch
[dolnum
].rm_eo
;
1911 DBGPRINTF ("so=%d eo=%d dolnum=%d", so
, eo
, dolnum
);
1912 if (so
>=0 && eo
>=so
)
1913 obstack_grow (&str_obstack
, filnam
+ so
, eo
- so
);
1917 /* This can happen only when files_rules is buggy! */
1920 /* Always skip the character after the dollar. */
1924 obstack_1grow (&str_obstack
, c
);
1926 obstack_1grow (&str_obstack
, '\0');
1927 rawstr
= XOBFINISH (&str_obstack
, char *);
1928 str
= xstrdup (rawstr
);
1929 obstack_free (&str_obstack
, rawstr
);
1930 DBGPRINTF ("matched replacement %s", str
);
1936 /* An output file, suitable for definitions, that can see declarations
1937 made in INPF and is linked into every language that uses INPF.
1938 Since the the result is cached inside INPF, that argument cannot be
1939 declared constant, but is "almost" constant. */
1942 get_output_file_with_visibility (input_file
*inpf
)
1945 char *for_name
= NULL
;
1946 char *output_name
= NULL
;
1947 const char* inpfname
;
1949 /* This can happen when we need a file with visibility on a
1950 structure that we've never seen. We have to just hope that it's
1951 globally visible. */
1953 inpf
= system_h_file
;
1955 /* The result is cached in INPF, so return it if already known. */
1957 return inpf
->inpoutf
;
1959 /* In plugin mode, return NULL unless the input_file is one of the
1964 for (i
= 0; i
< nb_plugin_files
; i
++)
1965 if (inpf
== plugin_files
[i
])
1967 inpf
->inpoutf
= plugin_output
;
1968 return plugin_output
;
1974 inpfname
= get_input_file_name (inpf
);
1976 /* Try each rule in sequence in files_rules until one is triggered. */
1979 DBGPRINTF ("passing input file @ %p named %s thru the files_rules",
1980 (void*) inpf
, inpfname
);
1982 for (; files_rules
[rulix
].frul_srcexpr
!= NULL
; rulix
++)
1984 DBGPRINTF ("rulix#%d srcexpr %s",
1985 rulix
, files_rules
[rulix
].frul_srcexpr
);
1987 if (!files_rules
[rulix
].frul_re
)
1989 /* Compile the regexpr lazily. */
1991 files_rules
[rulix
].frul_re
= XCNEW (regex_t
);
1992 err
= regcomp (files_rules
[rulix
].frul_re
,
1993 files_rules
[rulix
].frul_srcexpr
,
1994 files_rules
[rulix
].frul_rflags
);
1997 /* The regular expression compilation fails only when
1998 file_rules is buggy. */
2006 /* Match the regexpr and trigger the rule if matched. */
2008 /* We have exactly ten pmatch-s, one for each $0, $1, $2,
2010 regmatch_t pmatch
[10];
2011 memset (pmatch
, 0, sizeof (pmatch
));
2012 if (!regexec (files_rules
[rulix
].frul_re
,
2013 inpfname
, 10, pmatch
, 0))
2015 DBGPRINTF ("input @ %p filename %s matched rulix#%d pattern %s",
2016 (void*) inpf
, inpfname
, rulix
,
2017 files_rules
[rulix
].frul_srcexpr
);
2019 matching_file_name_substitute (inpfname
, pmatch
,
2020 files_rules
[rulix
].frul_tr_for
);
2021 DBGPRINTF ("for_name %s", for_name
);
2023 matching_file_name_substitute (inpfname
, pmatch
,
2024 files_rules
[rulix
].frul_tr_out
);
2025 DBGPRINTF ("output_name %s", output_name
);
2026 if (files_rules
[rulix
].frul_action
)
2028 /* Invoke our action routine. */
2030 DBGPRINTF ("before action rulix#%d output_name %s for_name %s",
2031 rulix
, output_name
, for_name
);
2033 (files_rules
[rulix
].frul_action
) (inpf
,
2034 &output_name
, &for_name
);
2035 DBGPRINTF ("after action rulix#%d of=%p output_name %s for_name %s",
2036 rulix
, (void*)of
, output_name
, for_name
);
2037 /* If the action routine returned something, give it back
2038 immediately and cache it in inpf. */
2045 /* The rule matched, and had no action, or that action did
2046 not return any output file but could have changed the
2047 output_name or for_name. We break out of the loop on the
2053 /* The regexpr did not match. */
2054 DBGPRINTF ("rulix#%d did not match %s pattern %s",
2055 rulix
, inpfname
, files_rules
[rulix
].frul_srcexpr
);
2061 if (!output_name
|| !for_name
)
2063 /* This is impossible, and could only happen if the files_rules is
2064 incomplete or buggy. */
2068 /* Look through to see if we've ever seen this output filename
2069 before. If found, cache the result in inpf. */
2070 for (r
= output_files
; r
; r
= r
->next
)
2071 if (strcmp (r
->name
, output_name
) == 0)
2074 DBGPRINTF ("found r @ %p for output_name %s for_name %s", (void*)r
,
2075 output_name
, for_name
);
2079 /* If not found, create it, and cache it in inpf. */
2080 r
= create_file (for_name
, output_name
);
2082 gcc_assert (r
&& r
->name
);
2083 DBGPRINTF ("created r @ %p for output_name %s for_name %s", (void*) r
,
2084 output_name
, for_name
);
2091 /* The name of an output file, suitable for definitions, that can see
2092 declarations made in INPF and is linked into every language that
2096 get_output_file_name (input_file
* inpf
)
2098 outf_p o
= get_output_file_with_visibility (inpf
);
2104 /* Check if existing file is equal to the in memory buffer. */
2107 is_file_equal (outf_p of
)
2109 FILE *newfile
= fopen (of
->name
, "r");
2112 if (newfile
== NULL
)
2116 for (i
= 0; i
< of
->bufused
; i
++)
2119 ch
= fgetc (newfile
);
2120 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
2130 /* Copy the output to its final destination,
2131 but don't unnecessarily change modification times. */
2134 close_output_files (void)
2136 int nbwrittenfiles
= 0;
2139 for (of
= output_files
; of
; of
= of
->next
)
2142 if (!is_file_equal (of
))
2144 FILE *newfile
= NULL
;
2145 char *backupname
= NULL
;
2146 /* Back up the old version of the output file gt-FOO.c as
2147 BACKUPDIR/gt-FOO.c~ if we have a backup directory. */
2150 backupname
= concat (backup_dir
, "/",
2151 lbasename (of
->name
), "~", NULL
);
2152 if (!access (of
->name
, F_OK
) && rename (of
->name
, backupname
))
2153 fatal ("failed to back up %s as %s: %s",
2154 of
->name
, backupname
, xstrerror (errno
));
2157 newfile
= fopen (of
->name
, "w");
2158 if (newfile
== NULL
)
2159 fatal ("opening output file %s: %s", of
->name
, xstrerror (errno
));
2160 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
2161 fatal ("writing output file %s: %s", of
->name
, xstrerror (errno
));
2162 if (fclose (newfile
) != 0)
2163 fatal ("closing output file %s: %s", of
->name
, xstrerror (errno
));
2165 if (verbosity_level
>= 2 && backupname
)
2166 printf ("%s wrote #%-3d %s backed-up in %s\n",
2167 progname
, nbwrittenfiles
, of
->name
, backupname
);
2168 else if (verbosity_level
>= 1)
2169 printf ("%s write #%-3d %s\n", progname
, nbwrittenfiles
, of
->name
);
2174 /* output file remains unchanged. */
2175 if (verbosity_level
>= 2)
2176 printf ("%s keep %s\n", progname
, of
->name
);
2180 of
->bufused
= of
->buflength
= 0;
2182 if (verbosity_level
>= 1)
2183 printf ("%s wrote %d files.\n", progname
, nbwrittenfiles
);
2190 const input_file
* file
;
2194 struct walk_type_data
;
2196 /* For scalars and strings, given the item in 'val'.
2197 For structures, given a pointer to the item in 'val'.
2198 For misc. pointers, given the item in 'val'.
2200 typedef void (*process_field_fn
) (type_p f
, const struct walk_type_data
* p
);
2201 typedef void (*func_name_fn
) (type_p s
, const struct walk_type_data
* p
);
2203 /* Parameters for write_types. */
2205 struct write_types_data
2208 const char *param_prefix
;
2209 const char *subfield_marker_routine
;
2210 const char *marker_routine
;
2211 const char *reorder_note_routine
;
2212 const char *comment
;
2213 int skip_hooks
; /* skip hook generation if non zero */
2216 static void output_escaped_param (struct walk_type_data
*d
,
2217 const char *, const char *);
2218 static void output_mangled_typename (outf_p
, const_type_p
);
2219 static void walk_type (type_p t
, struct walk_type_data
*d
);
2220 static void write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2221 const struct write_types_data
*wtd
);
2222 static void write_types_process_field
2223 (type_p f
, const struct walk_type_data
*d
);
2224 static void write_types (outf_p output_header
,
2226 type_p param_structs
,
2227 const struct write_types_data
*wtd
);
2228 static void write_types_local_process_field
2229 (type_p f
, const struct walk_type_data
*d
);
2230 static void write_local_func_for_structure
2231 (const_type_p orig_s
, type_p s
, type_p
*param
);
2232 static void write_local (outf_p output_header
,
2233 type_p structures
, type_p param_structs
);
2234 static void write_enum_defn (type_p structures
, type_p param_structs
);
2235 static int contains_scalar_p (type_p t
);
2236 static void put_mangled_filename (outf_p
, const input_file
*);
2237 static void finish_root_table (struct flist
*flp
, const char *pfx
,
2238 const char *tname
, const char *lastname
,
2240 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
2241 struct fileloc
*, const char *, bool);
2242 static void write_array (outf_p f
, pair_p v
,
2243 const struct write_types_data
*wtd
);
2244 static void write_roots (pair_p
, bool);
2246 /* Parameters for walk_type. */
2248 struct walk_type_data
2250 process_field_fn process_field
;
2255 const char *prev_val
[4];
2258 const struct fileloc
*line
;
2263 const char *reorder_fn
;
2265 bool fn_wants_lvalue
;
2268 /* Print a mangled name representing T to OF. */
2271 output_mangled_typename (outf_p of
, const_type_p t
)
2283 output_mangled_typename (of
, t
->u
.p
);
2293 case TYPE_LANG_STRUCT
:
2294 oprintf (of
, "%lu%s", (unsigned long) strlen (t
->u
.s
.tag
),
2297 case TYPE_PARAM_STRUCT
:
2300 for (i
= 0; i
< NUM_PARAM
; i
++)
2301 if (t
->u
.param_struct
.param
[i
] != NULL
)
2302 output_mangled_typename (of
, t
->u
.param_struct
.param
[i
]);
2303 output_mangled_typename (of
, t
->u
.param_struct
.stru
);
2311 /* Print PARAM to D->OF processing escapes. D->VAL references the
2312 current object, D->PREV_VAL the object containing the current
2313 object, ONAME is the name of the option and D->LINE is used to
2314 print error messages. */
2317 output_escaped_param (struct walk_type_data
*d
, const char *param
,
2322 for (p
= param
; *p
; p
++)
2324 oprintf (d
->of
, "%c", *p
);
2329 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
2332 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
2335 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
2339 const char *pp
= d
->val
+ strlen (d
->val
);
2340 while (pp
[-1] == ']')
2343 oprintf (d
->of
, "%s", pp
);
2347 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
2352 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2353 which is of type T. Write code to D->OF to constrain execution (at
2354 the point that D->PROCESS_FIELD is called) to the appropriate
2355 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2356 pointers to those objects. D->PREV_VAL lists the objects
2357 containing the current object, D->OPT is a list of options to
2358 apply, D->INDENT is the current indentation level, D->LINE is used
2359 to print error messages, D->BITMAP indicates which languages to
2360 print the structure for, and D->PARAM is the current parameter
2361 (from an enclosing param_is option). */
2364 walk_type (type_p t
, struct walk_type_data
*d
)
2366 const char *length
= NULL
;
2367 const char *desc
= NULL
;
2368 int maybe_undef_p
= 0;
2369 int use_param_num
= -1;
2370 int use_params_p
= 0;
2372 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
2374 d
->needs_cast_p
= false;
2375 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
2376 if (strcmp (oo
->name
, "length") == 0 && oo
->kind
== OPTION_STRING
)
2377 length
= oo
->info
.string
;
2378 else if (strcmp (oo
->name
, "maybe_undef") == 0)
2380 else if (strncmp (oo
->name
, "use_param", 9) == 0
2381 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2382 use_param_num
= oo
->name
[9] == '\0' ? 0 : oo
->name
[9] - '0';
2383 else if (strcmp (oo
->name
, "use_params") == 0)
2385 else if (strcmp (oo
->name
, "desc") == 0 && oo
->kind
== OPTION_STRING
)
2386 desc
= oo
->info
.string
;
2387 else if (strcmp (oo
->name
, "mark_hook") == 0)
2389 else if (strcmp (oo
->name
, "nested_ptr") == 0
2390 && oo
->kind
== OPTION_NESTED
)
2391 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
.nested
;
2392 else if (strcmp (oo
->name
, "dot") == 0)
2394 else if (strcmp (oo
->name
, "tag") == 0)
2396 else if (strcmp (oo
->name
, "special") == 0)
2398 else if (strcmp (oo
->name
, "skip") == 0)
2400 else if (strcmp (oo
->name
, "default") == 0)
2402 else if (strcmp (oo
->name
, "param_is") == 0)
2404 else if (strncmp (oo
->name
, "param", 5) == 0
2405 && ISDIGIT (oo
->name
[5]) && strcmp (oo
->name
+ 6, "_is") == 0)
2407 else if (strcmp (oo
->name
, "chain_next") == 0)
2409 else if (strcmp (oo
->name
, "chain_prev") == 0)
2411 else if (strcmp (oo
->name
, "chain_circular") == 0)
2413 else if (strcmp (oo
->name
, "reorder") == 0)
2415 else if (strcmp (oo
->name
, "variable_size") == 0)
2418 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
2425 int pointer_p
= t
->kind
== TYPE_POINTER
;
2429 if (!UNION_OR_STRUCT_P (t
))
2430 error_at_line (d
->line
, "`use_params' option on unimplemented type");
2432 t
= find_param_structure (t
, d
->param
);
2434 t
= create_pointer (t
);
2437 if (use_param_num
!= -1)
2439 if (d
->param
!= NULL
&& d
->param
[use_param_num
] != NULL
)
2441 type_p nt
= d
->param
[use_param_num
];
2443 if (t
->kind
== TYPE_ARRAY
)
2444 nt
= create_array (nt
, t
->u
.a
.len
);
2445 else if (length
!= NULL
&& t
->kind
== TYPE_POINTER
)
2446 nt
= create_pointer (nt
);
2447 d
->needs_cast_p
= (t
->kind
!= TYPE_POINTER
2448 && (nt
->kind
== TYPE_POINTER
2449 || nt
->kind
== TYPE_STRING
));
2453 error_at_line (d
->line
, "no parameter defined for `%s'", d
->val
);
2457 && (t
->kind
!= TYPE_POINTER
|| !UNION_OR_STRUCT_P (t
->u
.p
)))
2459 error_at_line (d
->line
,
2460 "field `%s' has invalid option `maybe_undef_p'\n",
2469 d
->process_field (t
, d
);
2474 if (maybe_undef_p
&& t
->u
.p
->u
.s
.line
.file
== NULL
)
2476 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2482 if (!UNION_OR_STRUCT_P (t
->u
.p
)
2483 && t
->u
.p
->kind
!= TYPE_PARAM_STRUCT
)
2485 error_at_line (d
->line
,
2486 "field `%s' is pointer to unimplemented type",
2493 const char *oldprevval2
= d
->prev_val
[2];
2495 if (!UNION_OR_STRUCT_P (nested_ptr_d
->type
))
2497 error_at_line (d
->line
,
2498 "field `%s' has invalid "
2499 "option `nested_ptr'\n", d
->val
);
2503 d
->prev_val
[2] = d
->val
;
2504 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2506 d
->val
= xasprintf ("x%d", d
->counter
++);
2507 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2508 (nested_ptr_d
->type
->kind
== TYPE_UNION
2509 ? "union" : "struct"),
2510 nested_ptr_d
->type
->u
.s
.tag
,
2511 d
->fn_wants_lvalue
? "" : "const ", d
->val
);
2512 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2513 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2515 oprintf (d
->of
, ";\n");
2517 d
->process_field (nested_ptr_d
->type
, d
);
2519 if (d
->fn_wants_lvalue
)
2521 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2523 d
->prev_val
[2] = d
->val
;
2524 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2526 oprintf (d
->of
, ";\n");
2530 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2531 d
->val
= d
->prev_val
[2];
2532 d
->prev_val
[2] = oldprevval2
;
2535 d
->process_field (t
->u
.p
, d
);
2539 int loopcounter
= d
->counter
++;
2540 const char *oldval
= d
->val
;
2541 const char *oldprevval3
= d
->prev_val
[3];
2544 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2546 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2547 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
,
2548 "", loopcounter
, loopcounter
);
2549 output_escaped_param (d
, length
, "length");
2550 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2552 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2554 d
->prev_val
[3] = oldval
;
2555 walk_type (t
->u
.p
, d
);
2558 d
->prev_val
[3] = oldprevval3
;
2561 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2562 d
->process_field (t
, d
);
2564 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2571 int loopcounter
= d
->counter
++;
2572 const char *oldval
= d
->val
;
2575 /* If it's an array of scalars, we optimize by not generating
2577 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2580 /* When walking an array, compute the length and store it in a
2581 local variable before walking the array elements, instead of
2582 recomputing the length expression each time through the loop.
2583 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2584 where the length is stored in the first array element,
2585 because otherwise that operand can get overwritten on the
2587 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2589 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2590 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2591 d
->indent
, "", loopcounter
);
2593 output_escaped_param (d
, length
, "length");
2595 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2596 oprintf (d
->of
, ");\n");
2598 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2600 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2602 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2604 walk_type (t
->u
.a
.p
, d
);
2609 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2611 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2619 const char *oldval
= d
->val
;
2620 const char *oldprevval1
= d
->prev_val
[1];
2621 const char *oldprevval2
= d
->prev_val
[2];
2622 const int union_p
= t
->kind
== TYPE_UNION
;
2623 int seen_default_p
= 0;
2626 if (!t
->u
.s
.line
.file
)
2627 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2629 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2631 error_at_line (d
->line
,
2632 "structure `%s' defined for mismatching languages",
2634 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2637 /* Some things may also be defined in the structure's options. */
2638 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2639 if (!desc
&& strcmp (o
->name
, "desc") == 0
2640 && o
->kind
== OPTION_STRING
)
2641 desc
= o
->info
.string
;
2643 d
->prev_val
[2] = oldval
;
2644 d
->prev_val
[1] = oldprevval2
;
2649 error_at_line (d
->line
,
2650 "missing `desc' option for union `%s'",
2654 oprintf (d
->of
, "%*sswitch (", d
->indent
, "");
2655 output_escaped_param (d
, desc
, "desc");
2656 oprintf (d
->of
, ")\n");
2658 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2660 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
2663 const char *dot
= ".";
2664 const char *tagid
= NULL
;
2667 int use_param_p
= 0;
2670 d
->reorder_fn
= NULL
;
2671 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2672 if (strcmp (oo
->name
, "dot") == 0
2673 && oo
->kind
== OPTION_STRING
)
2674 dot
= oo
->info
.string
;
2675 else if (strcmp (oo
->name
, "tag") == 0
2676 && oo
->kind
== OPTION_STRING
)
2677 tagid
= oo
->info
.string
;
2678 else if (strcmp (oo
->name
, "skip") == 0)
2680 else if (strcmp (oo
->name
, "default") == 0)
2682 else if (strcmp (oo
->name
, "reorder") == 0
2683 && oo
->kind
== OPTION_STRING
)
2684 d
->reorder_fn
= oo
->info
.string
;
2685 else if (strncmp (oo
->name
, "use_param", 9) == 0
2686 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2692 if (union_p
&& tagid
)
2694 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
2697 else if (union_p
&& default_p
)
2699 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2703 else if (!union_p
&& (default_p
|| tagid
))
2704 error_at_line (d
->line
,
2705 "can't use `%s' outside a union on field `%s'",
2706 default_p
? "default" : "tag", f
->name
);
2707 else if (union_p
&& !(default_p
|| tagid
)
2708 && f
->type
->kind
== TYPE_SCALAR
)
2711 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2712 get_input_file_name (d
->line
->file
), d
->line
->line
,
2716 else if (union_p
&& !(default_p
|| tagid
))
2717 error_at_line (d
->line
,
2718 "field `%s' is missing `tag' or `default' option",
2722 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
2724 d
->used_length
= false;
2726 if (union_p
&& use_param_p
&& d
->param
== NULL
)
2727 oprintf (d
->of
, "%*sgcc_unreachable ();\n", d
->indent
, "");
2729 walk_type (f
->type
, d
);
2735 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2739 d
->reorder_fn
= NULL
;
2742 d
->prev_val
[1] = oldprevval1
;
2743 d
->prev_val
[2] = oldprevval2
;
2745 if (union_p
&& !seen_default_p
)
2747 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2748 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
2752 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2758 case TYPE_LANG_STRUCT
:
2761 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
2762 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
2765 error_at_line (d
->line
, "structure `%s' differs between languages",
2772 case TYPE_PARAM_STRUCT
:
2774 type_p
*oldparam
= d
->param
;
2776 d
->param
= t
->u
.param_struct
.param
;
2777 walk_type (t
->u
.param_struct
.stru
, d
);
2778 d
->param
= oldparam
;
2787 /* process_field routine for marking routines. */
2790 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
2792 const struct write_types_data
*wtd
;
2793 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
2794 wtd
= (const struct write_types_data
*) d
->cookie
;
2801 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
2802 wtd
->subfield_marker_routine
, cast
, d
->val
);
2803 if (wtd
->param_prefix
)
2805 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
2808 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
2809 output_mangled_typename (d
->of
, d
->orig_s
);
2812 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
2814 if (f
->u
.p
->kind
== TYPE_PARAM_STRUCT
2815 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2817 oprintf (d
->of
, ", gt_e_");
2818 output_mangled_typename (d
->of
, f
);
2820 else if (UNION_OR_STRUCT_P (f
) && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2822 oprintf (d
->of
, ", gt_ggc_e_");
2823 output_mangled_typename (d
->of
, f
);
2826 oprintf (d
->of
, ", gt_types_enum_last");
2828 oprintf (d
->of
, ");\n");
2829 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2830 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
2831 wtd
->reorder_note_routine
, cast
, d
->val
,
2832 d
->prev_val
[3], d
->reorder_fn
);
2838 case TYPE_LANG_STRUCT
:
2839 case TYPE_PARAM_STRUCT
:
2840 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
2841 output_mangled_typename (d
->of
, f
);
2842 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
2843 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2844 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
2845 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
2857 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2860 output_type_enum (outf_p of
, type_p s
)
2862 if (s
->kind
== TYPE_PARAM_STRUCT
&& s
->u
.param_struct
.line
.file
!= NULL
)
2864 oprintf (of
, ", gt_e_");
2865 output_mangled_typename (of
, s
);
2867 else if (UNION_OR_STRUCT_P (s
) && s
->u
.s
.line
.file
!= NULL
)
2869 oprintf (of
, ", gt_ggc_e_");
2870 output_mangled_typename (of
, s
);
2873 oprintf (of
, ", gt_types_enum_last");
2876 /* Return an output file that is suitable for definitions which can
2877 reference struct S */
2880 get_output_file_for_structure (const_type_p s
, type_p
*param
)
2882 const input_file
*fn
;
2885 gcc_assert (UNION_OR_STRUCT_P (s
));
2886 fn
= s
->u
.s
.line
.file
;
2888 /* This is a hack, and not the good kind either. */
2889 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2890 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2891 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2892 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2894 /* The call to get_output_file_with_visibility may update fn by
2895 caching its result inside, so we need the CONST_CAST. */
2896 return get_output_file_with_visibility (CONST_CAST (input_file
*, fn
));
2899 /* For S, a structure that's part of ORIG_S, and using parameters
2900 PARAM, write out a routine that:
2901 - Takes a parameter, a void * but actually of type *S
2902 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2903 field of S or its substructures and (in some cases) things
2904 that are pointed to by S.
2908 write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2909 const struct write_types_data
*wtd
)
2911 const char *chain_next
= NULL
;
2912 const char *chain_prev
= NULL
;
2913 const char *chain_circular
= NULL
;
2914 const char *mark_hook_name
= NULL
;
2916 struct walk_type_data d
;
2918 memset (&d
, 0, sizeof (d
));
2919 d
.of
= get_output_file_for_structure (s
, param
);
2920 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2921 if (strcmp (opt
->name
, "chain_next") == 0
2922 && opt
->kind
== OPTION_STRING
)
2923 chain_next
= opt
->info
.string
;
2924 else if (strcmp (opt
->name
, "chain_prev") == 0
2925 && opt
->kind
== OPTION_STRING
)
2926 chain_prev
= opt
->info
.string
;
2927 else if (strcmp (opt
->name
, "chain_circular") == 0
2928 && opt
->kind
== OPTION_STRING
)
2929 chain_circular
= opt
->info
.string
;
2930 else if (strcmp (opt
->name
, "mark_hook") == 0
2931 && opt
->kind
== OPTION_STRING
)
2932 mark_hook_name
= opt
->info
.string
;
2933 if (chain_prev
!= NULL
&& chain_next
== NULL
)
2934 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
2935 if (chain_circular
!= NULL
&& chain_next
!= NULL
)
2936 error_at_line (&s
->u
.s
.line
, "chain_circular with chain_next");
2937 if (chain_circular
!= NULL
)
2938 chain_next
= chain_circular
;
2940 d
.process_field
= write_types_process_field
;
2944 d
.line
= &s
->u
.s
.line
;
2945 d
.bitmap
= s
->u
.s
.bitmap
;
2947 d
.prev_val
[0] = "*x";
2948 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2949 d
.prev_val
[3] = "x";
2952 oprintf (d
.of
, "\n");
2953 oprintf (d
.of
, "void\n");
2955 oprintf (d
.of
, "gt_%sx_%s", wtd
->prefix
, orig_s
->u
.s
.tag
);
2958 oprintf (d
.of
, "gt_%s_", wtd
->prefix
);
2959 output_mangled_typename (d
.of
, orig_s
);
2961 oprintf (d
.of
, " (void *x_p)\n");
2962 oprintf (d
.of
, "{\n");
2963 oprintf (d
.of
, " %s %s * %sx = (%s %s *)x_p;\n",
2964 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2965 chain_next
== NULL
? "const " : "",
2966 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2967 if (chain_next
!= NULL
)
2968 oprintf (d
.of
, " %s %s * xlimit = x;\n",
2969 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2970 if (chain_next
== NULL
)
2972 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
2973 if (wtd
->param_prefix
)
2975 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
2976 output_mangled_typename (d
.of
, orig_s
);
2977 output_type_enum (d
.of
, orig_s
);
2979 oprintf (d
.of
, "))\n");
2983 if (chain_circular
!= NULL
)
2984 oprintf (d
.of
, " if (!%s (xlimit", wtd
->marker_routine
);
2986 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2987 if (wtd
->param_prefix
)
2989 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2990 output_mangled_typename (d
.of
, orig_s
);
2991 output_type_enum (d
.of
, orig_s
);
2993 oprintf (d
.of
, "))\n");
2994 if (chain_circular
!= NULL
)
2995 oprintf (d
.of
, " return;\n do\n");
2996 if (mark_hook_name
&& !wtd
->skip_hooks
)
2998 oprintf (d
.of
, " {\n");
2999 oprintf (d
.of
, " %s (xlimit);\n ", mark_hook_name
);
3001 oprintf (d
.of
, " xlimit = (");
3002 d
.prev_val
[2] = "*xlimit";
3003 output_escaped_param (&d
, chain_next
, "chain_next");
3004 oprintf (d
.of
, ");\n");
3005 if (mark_hook_name
&& !wtd
->skip_hooks
)
3006 oprintf (d
.of
, " }\n");
3007 if (chain_prev
!= NULL
)
3009 oprintf (d
.of
, " if (x != xlimit)\n");
3010 oprintf (d
.of
, " for (;;)\n");
3011 oprintf (d
.of
, " {\n");
3012 oprintf (d
.of
, " %s %s * const xprev = (",
3013 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
3015 d
.prev_val
[2] = "*x";
3016 output_escaped_param (&d
, chain_prev
, "chain_prev");
3017 oprintf (d
.of
, ");\n");
3018 oprintf (d
.of
, " if (xprev == NULL) break;\n");
3019 oprintf (d
.of
, " x = xprev;\n");
3020 oprintf (d
.of
, " (void) %s (xprev", wtd
->marker_routine
);
3021 if (wtd
->param_prefix
)
3023 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
3024 output_mangled_typename (d
.of
, orig_s
);
3025 output_type_enum (d
.of
, orig_s
);
3027 oprintf (d
.of
, ");\n");
3028 oprintf (d
.of
, " }\n");
3030 if (chain_circular
!= NULL
)
3032 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
3033 if (wtd
->param_prefix
)
3035 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
3036 output_mangled_typename (d
.of
, orig_s
);
3037 output_type_enum (d
.of
, orig_s
);
3039 oprintf (d
.of
, "));\n");
3040 if (mark_hook_name
&& !wtd
->skip_hooks
)
3041 oprintf (d
.of
, " %s (xlimit);\n", mark_hook_name
);
3042 oprintf (d
.of
, " do\n");
3045 oprintf (d
.of
, " while (x != xlimit)\n");
3047 oprintf (d
.of
, " {\n");
3048 if (mark_hook_name
&& chain_next
== NULL
&& !wtd
->skip_hooks
)
3050 oprintf (d
.of
, " %s (x);\n", mark_hook_name
);
3052 d
.prev_val
[2] = "*x";
3056 if (chain_next
!= NULL
)
3058 oprintf (d
.of
, " x = (");
3059 output_escaped_param (&d
, chain_next
, "chain_next");
3060 oprintf (d
.of
, ");\n");
3063 oprintf (d
.of
, " }\n");
3064 if (chain_circular
!= NULL
)
3065 oprintf (d
.of
, " while (x != xlimit);\n");
3066 oprintf (d
.of
, "}\n");
3069 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
3072 write_types (outf_p output_header
, type_p structures
, type_p param_structs
,
3073 const struct write_types_data
*wtd
)
3075 int nbfun
= 0; /* Count the emitted functions. */
3078 oprintf (output_header
, "\n/* %s*/\n", wtd
->comment
);
3079 /* We first emit the macros and the declarations. Functions' code is
3080 emitted afterwards. This is needed in plugin mode. */
3081 oprintf (output_header
, "/* macros and declarations */\n");
3082 for (s
= structures
; s
; s
= s
->next
)
3083 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3087 if (s
->gc_used
== GC_MAYBE_POINTED_TO
&& s
->u
.s
.line
.file
== NULL
)
3090 oprintf (output_header
, "#define gt_%s_", wtd
->prefix
);
3091 output_mangled_typename (output_header
, s
);
3092 oprintf (output_header
, "(X) do { \\\n");
3093 oprintf (output_header
,
3094 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
3096 oprintf (output_header
, " } while (0)\n");
3098 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3099 if (strcmp (opt
->name
, "ptr_alias") == 0
3100 && opt
->kind
== OPTION_TYPE
)
3102 const_type_p
const t
= (const_type_p
) opt
->info
.type
;
3103 if (t
->kind
== TYPE_STRUCT
3104 || t
->kind
== TYPE_UNION
|| t
->kind
== TYPE_LANG_STRUCT
)
3105 oprintf (output_header
,
3106 "#define gt_%sx_%s gt_%sx_%s\n",
3107 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t
->u
.s
.tag
);
3109 error_at_line (&s
->u
.s
.line
,
3110 "structure alias is not a structure");
3116 /* Declare the marker procedure only once. */
3117 oprintf (output_header
,
3118 "extern void gt_%sx_%s (void *);\n",
3119 wtd
->prefix
, s
->u
.s
.tag
);
3121 if (s
->u
.s
.line
.file
== NULL
)
3123 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3129 for (s
= param_structs
; s
; s
= s
->next
)
3130 if (s
->gc_used
== GC_POINTED_TO
)
3132 type_p stru
= s
->u
.param_struct
.stru
;
3134 /* Declare the marker procedure. */
3135 oprintf (output_header
, "extern void gt_%s_", wtd
->prefix
);
3136 output_mangled_typename (output_header
, s
);
3137 oprintf (output_header
, " (void *);\n");
3139 if (stru
->u
.s
.line
.file
== NULL
)
3141 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3147 /* At last we emit the functions code. */
3148 oprintf (output_header
, "\n/* functions code */\n");
3149 for (s
= structures
; s
; s
= s
->next
)
3150 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3154 if (s
->gc_used
== GC_MAYBE_POINTED_TO
&& s
->u
.s
.line
.file
== NULL
)
3156 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3157 if (strcmp (opt
->name
, "ptr_alias") == 0)
3162 if (s
->kind
== TYPE_LANG_STRUCT
)
3165 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3168 DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'",
3169 nbfun
, (void*) ss
, ss
->u
.s
.tag
);
3170 write_func_for_structure (s
, ss
, NULL
, wtd
);
3176 DBGPRINTF ("writing func #%d struct s @ %p '%s'",
3177 nbfun
, (void*) s
, s
->u
.s
.tag
);
3178 write_func_for_structure (s
, s
, NULL
, wtd
);
3183 /* Structure s is not possibly pointed to, so can be ignored. */
3184 DBGPRINTF ("ignored s @ %p '%s' gc_used#%d",
3185 (void*)s
, s
->u
.s
.tag
,
3189 for (s
= param_structs
; s
; s
= s
->next
)
3190 if (s
->gc_used
== GC_POINTED_TO
)
3192 type_p
*param
= s
->u
.param_struct
.param
;
3193 type_p stru
= s
->u
.param_struct
.stru
;
3194 if (stru
->u
.s
.line
.file
== NULL
)
3196 if (stru
->kind
== TYPE_LANG_STRUCT
)
3199 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3202 DBGPRINTF ("writing func #%d param lang_struct ss @ %p '%s'",
3203 nbfun
, (void*) ss
, ss
->u
.s
.tag
);
3204 write_func_for_structure (s
, ss
, param
, wtd
);
3210 DBGPRINTF ("writing func #%d param struct s @ %p stru @ %p '%s'",
3212 (void*) stru
, stru
->u
.s
.tag
);
3213 write_func_for_structure (s
, stru
, param
, wtd
);
3218 /* Param structure s is not pointed to, so should be ignored. */
3219 DBGPRINTF ("ignored s @ %p", (void*)s
);
3221 if (verbosity_level
>= 2)
3222 printf ("%s emitted %d routines for %s\n",
3223 progname
, nbfun
, wtd
->comment
);
3226 static const struct write_types_data ggc_wtd
= {
3227 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
3228 "GC marker procedures. ",
3232 static const struct write_types_data pch_wtd
= {
3233 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
3234 "gt_pch_note_reorder",
3235 "PCH type-walking procedures. ",
3239 /* Write out the local pointer-walking routines. */
3241 /* process_field routine for local pointer-walking. */
3244 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
3251 case TYPE_LANG_STRUCT
:
3252 case TYPE_PARAM_STRUCT
:
3254 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
3256 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
3267 /* For S, a structure that's part of ORIG_S, and using parameters
3268 PARAM, write out a routine that:
3269 - Is of type gt_note_pointers
3270 - Calls PROCESS_FIELD on each field of S or its substructures.
3274 write_local_func_for_structure (const_type_p orig_s
, type_p s
, type_p
*param
)
3276 struct walk_type_data d
;
3278 memset (&d
, 0, sizeof (d
));
3279 d
.of
= get_output_file_for_structure (s
, param
);
3280 d
.process_field
= write_types_local_process_field
;
3282 d
.line
= &s
->u
.s
.line
;
3283 d
.bitmap
= s
->u
.s
.bitmap
;
3285 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
3286 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
3287 d
.prev_val
[3] = "x";
3289 d
.fn_wants_lvalue
= true;
3291 oprintf (d
.of
, "\n");
3292 oprintf (d
.of
, "void\n");
3293 oprintf (d
.of
, "gt_pch_p_");
3294 output_mangled_typename (d
.of
, orig_s
);
3295 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
3297 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3298 "\tATTRIBUTE_UNUSED void *cookie)\n");
3299 oprintf (d
.of
, "{\n");
3300 oprintf (d
.of
, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
3301 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
3302 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
3305 oprintf (d
.of
, "}\n");
3308 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
3311 write_local (outf_p output_header
, type_p structures
, type_p param_structs
)
3317 oprintf (output_header
, "\n/* Local pointer-walking routines. */\n");
3318 for (s
= structures
; s
; s
= s
->next
)
3319 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3323 if (s
->u
.s
.line
.file
== NULL
)
3325 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3326 if (strcmp (opt
->name
, "ptr_alias") == 0
3327 && opt
->kind
== OPTION_TYPE
)
3329 const_type_p
const t
= (const_type_p
) opt
->info
.type
;
3330 if (t
->kind
== TYPE_STRUCT
3331 || t
->kind
== TYPE_UNION
|| t
->kind
== TYPE_LANG_STRUCT
)
3333 oprintf (output_header
, "#define gt_pch_p_");
3334 output_mangled_typename (output_header
, s
);
3335 oprintf (output_header
, " gt_pch_p_");
3336 output_mangled_typename (output_header
, t
);
3337 oprintf (output_header
, "\n");
3340 error_at_line (&s
->u
.s
.line
,
3341 "structure alias is not a structure");
3347 /* Declare the marker procedure only once. */
3348 oprintf (output_header
, "extern void gt_pch_p_");
3349 output_mangled_typename (output_header
, s
);
3350 oprintf (output_header
,
3351 "\n (void *, void *, gt_pointer_operator, void *);\n");
3353 if (s
->kind
== TYPE_LANG_STRUCT
)
3356 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3357 write_local_func_for_structure (s
, ss
, NULL
);
3360 write_local_func_for_structure (s
, s
, NULL
);
3363 for (s
= param_structs
; s
; s
= s
->next
)
3364 if (s
->gc_used
== GC_POINTED_TO
)
3366 type_p
*param
= s
->u
.param_struct
.param
;
3367 type_p stru
= s
->u
.param_struct
.stru
;
3369 /* Declare the marker procedure. */
3370 oprintf (output_header
, "extern void gt_pch_p_");
3371 output_mangled_typename (output_header
, s
);
3372 oprintf (output_header
,
3373 "\n (void *, void *, gt_pointer_operator, void *);\n");
3375 if (stru
->u
.s
.line
.file
== NULL
)
3377 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3382 if (stru
->kind
== TYPE_LANG_STRUCT
)
3385 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3386 write_local_func_for_structure (s
, ss
, param
);
3389 write_local_func_for_structure (s
, stru
, param
);
3393 /* Nonzero if S is a type for which typed GC allocators should be output. */
3395 #define USED_BY_TYPED_GC_P(s) \
3396 (((s->kind == TYPE_POINTER) \
3397 && ((s->u.p->gc_used == GC_POINTED_TO) \
3398 || (s->u.p->gc_used == GC_USED))) \
3399 || (UNION_OR_STRUCT_P (s) && \
3400 (((s)->gc_used == GC_POINTED_TO) \
3401 || ((s)->gc_used == GC_MAYBE_POINTED_TO \
3402 && s->u.s.line.file != NULL) \
3403 || ((s)->gc_used == GC_USED \
3404 && strncmp (s->u.s.tag, "anonymous", strlen ("anonymous"))))))
3407 /* Write out the 'enum' definition for gt_types_enum. */
3410 write_enum_defn (type_p structures
, type_p param_structs
)
3414 int nbparamstruct
= 0;
3418 oprintf (header_file
, "\n/* Enumeration of types known. */\n");
3419 oprintf (header_file
, "enum gt_types_enum {\n");
3420 for (s
= structures
; s
; s
= s
->next
)
3421 if (USED_BY_TYPED_GC_P (s
))
3424 DBGPRINTF ("write_enum_defn s @ %p nbstruct %d",
3425 (void*) s
, nbstruct
);
3426 if (UNION_OR_STRUCT_P (s
))
3427 DBGPRINTF ("write_enum_defn s %p #%d is unionorstruct tagged %s",
3428 (void*) s
, nbstruct
, s
->u
.s
.tag
);
3429 oprintf (header_file
, " gt_ggc_e_");
3430 output_mangled_typename (header_file
, s
);
3431 oprintf (header_file
, ",\n");
3433 for (s
= param_structs
; s
; s
= s
->next
)
3434 if (s
->gc_used
== GC_POINTED_TO
)
3437 DBGPRINTF ("write_enum_defn s %p nbparamstruct %d",
3438 (void*) s
, nbparamstruct
);
3439 oprintf (header_file
, " gt_e_");
3440 output_mangled_typename (header_file
, s
);
3441 oprintf (header_file
, ",\n");
3443 oprintf (header_file
, " gt_types_enum_last\n");
3444 oprintf (header_file
, "};\n");
3445 if (verbosity_level
>= 2)
3446 printf ("%s handled %d GTY-ed structures & %d parameterized structures.\n",
3447 progname
, nbstruct
, nbparamstruct
);
3451 /* Might T contain any non-pointer elements? */
3454 contains_scalar_p (type_p t
)
3462 return contains_scalar_p (t
->u
.a
.p
);
3464 /* Could also check for structures that have no non-pointer
3465 fields, but there aren't enough of those to worry about. */
3470 /* Mangle INPF and print it to F. */
3473 put_mangled_filename (outf_p f
, const input_file
*inpf
)
3475 /* The call to get_output_file_name may indirectly update fn since
3476 get_output_file_with_visibility caches its result inside, so we
3477 need the CONST_CAST. */
3478 const char *name
= get_output_file_name (CONST_CAST (input_file
*, inpf
));
3481 for (; *name
!= 0; name
++)
3482 if (ISALNUM (*name
))
3483 oprintf (f
, "%c", *name
);
3485 oprintf (f
, "%c", '_');
3488 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
3489 LASTNAME, and NAME are all strings to insert in various places in
3490 the resulting code. */
3493 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
3494 const char *tname
, const char *name
)
3498 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3499 if (fli2
->started_p
)
3501 oprintf (fli2
->f
, " %s\n", lastname
);
3502 oprintf (fli2
->f
, "};\n\n");
3505 for (fli2
= flp
; fli2
&& base_files
; fli2
= fli2
->next
)
3506 if (fli2
->started_p
)
3508 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
3511 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
3514 oprintf (base_files
[fnum
],
3515 "extern const struct %s gt_%s_", tname
, pfx
);
3516 put_mangled_filename (base_files
[fnum
], fli2
->file
);
3517 oprintf (base_files
[fnum
], "[];\n");
3523 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3524 oprintf (base_files
[fnum
],
3525 "EXPORTED_CONST struct %s * const %s[] = {\n", tname
, name
);
3529 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3530 if (fli2
->started_p
)
3532 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
3535 fli2
->started_p
= 0;
3537 for (fnum
= 0; base_files
&& bitmap
!= 0; fnum
++, bitmap
>>= 1)
3540 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
3541 put_mangled_filename (base_files
[fnum
], fli2
->file
);
3542 oprintf (base_files
[fnum
], ",\n");
3548 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3550 oprintf (base_files
[fnum
], " NULL\n");
3551 oprintf (base_files
[fnum
], "};\n");
3556 /* Write the first three fields (pointer, count and stride) for
3557 root NAME to F. V and LINE are as for write_root.
3559 Return true if the entry could be written; return false on error. */
3562 start_root_entry (outf_p f
, pair_p v
, const char *name
, struct fileloc
*line
)
3568 error_at_line (line
, "`%s' is too complex to be a root", name
);
3572 oprintf (f
, " {\n");
3573 oprintf (f
, " &%s,\n", name
);
3576 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3578 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
3579 else if (ap
== v
->type
)
3580 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
3582 oprintf (f
, " sizeof (%s", v
->name
);
3583 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3585 oprintf (f
, "),\n");
3589 /* A subroutine of write_root for writing the roots for field FIELD_NAME,
3590 which has type FIELD_TYPE. Parameters F to EMIT_PCH are the parameters
3594 write_field_root (outf_p f
, pair_p v
, type_p type
, const char *name
,
3595 int has_length
, struct fileloc
*line
, const char *if_marked
,
3596 bool emit_pch
, type_p field_type
, const char *field_name
)
3598 /* If the field reference is relative to V, rather than to some
3599 subcomponent of V, we can mark any subarrays with a single stride.
3600 We're effectively treating the field as a global variable in its
3602 if (v
&& type
== v
->type
)
3607 newv
.type
= field_type
;
3608 newv
.name
= ACONCAT ((v
->name
, ".", field_name
, NULL
));
3611 /* Otherwise, any arrays nested in the structure are too complex to
3613 else if (field_type
->kind
== TYPE_ARRAY
)
3615 write_root (f
, v
, field_type
, ACONCAT ((name
, ".", field_name
, NULL
)),
3616 has_length
, line
, if_marked
, emit_pch
);
3619 /* Write out to F the table entry and any marker routines needed to
3620 mark NAME as TYPE. V can be one of three values:
3622 - null, if NAME is too complex to represent using a single
3623 count and stride. In this case, it is an error for NAME to
3624 contain any gc-ed data.
3626 - the outermost array that contains NAME, if NAME is part of an array.
3628 - the C variable that contains NAME, if NAME is not part of an array.
3630 LINE is the line of the C source that declares the root variable.
3631 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
3632 is nonzero iff we are building the root table for hash table caches. */
3635 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
3636 struct fileloc
*line
, const char *if_marked
, bool emit_pch
)
3643 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
3646 const char *desc
= NULL
;
3649 for (o
= fld
->opt
; o
; o
= o
->next
)
3650 if (strcmp (o
->name
, "skip") == 0)
3652 else if (strcmp (o
->name
, "desc") == 0
3653 && o
->kind
== OPTION_STRING
)
3654 desc
= o
->info
.string
;
3655 else if (strcmp (o
->name
, "param_is") == 0)
3658 error_at_line (line
,
3659 "field `%s' of global `%s' has unknown option `%s'",
3660 fld
->name
, name
, o
->name
);
3664 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
3666 pair_p validf
= NULL
;
3669 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
3671 const char *tag
= NULL
;
3673 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
3674 if (strcmp (oo
->name
, "tag") == 0
3675 && oo
->kind
== OPTION_STRING
)
3676 tag
= oo
->info
.string
;
3677 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
3680 error_at_line (line
,
3681 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3682 name
, fld
->name
, validf
->name
,
3683 name
, fld
->name
, ufld
->name
, tag
);
3687 write_field_root (f
, v
, type
, name
, 0, line
, if_marked
,
3688 emit_pch
, validf
->type
,
3689 ACONCAT ((fld
->name
, ".",
3690 validf
->name
, NULL
)));
3693 error_at_line (line
,
3694 "global `%s.%s' has `desc' option but is not union",
3697 write_field_root (f
, v
, type
, name
, 0, line
, if_marked
,
3698 emit_pch
, fld
->type
, fld
->name
);
3706 newname
= xasprintf ("%s[0]", name
);
3707 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, if_marked
,
3717 if (!start_root_entry (f
, v
, name
, line
))
3722 if (!has_length
&& UNION_OR_STRUCT_P (tp
))
3724 oprintf (f
, " >_ggc_mx_%s,\n", tp
->u
.s
.tag
);
3726 oprintf (f
, " >_pch_nx_%s", tp
->u
.s
.tag
);
3728 oprintf (f
, " NULL");
3730 else if (!has_length
&& tp
->kind
== TYPE_PARAM_STRUCT
)
3732 oprintf (f
, " >_ggc_m_");
3733 output_mangled_typename (f
, tp
);
3736 oprintf (f
, ",\n >_pch_n_");
3737 output_mangled_typename (f
, tp
);
3740 oprintf (f
, ",\n NULL");
3743 && (tp
->kind
== TYPE_POINTER
|| UNION_OR_STRUCT_P (tp
)))
3745 oprintf (f
, " >_ggc_ma_%s,\n", name
);
3747 oprintf (f
, " >_pch_na_%s", name
);
3749 oprintf (f
, " NULL");
3753 error_at_line (line
,
3754 "global `%s' is pointer to unimplemented type",
3758 oprintf (f
, ",\n &%s", if_marked
);
3759 oprintf (f
, "\n },\n");
3765 if (!start_root_entry (f
, v
, name
, line
))
3768 oprintf (f
, " (gt_pointer_walker) >_ggc_m_S,\n");
3769 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
3770 oprintf (f
, " },\n");
3778 error_at_line (line
, "global `%s' is unimplemented type", name
);
3782 /* This generates a routine to walk an array. */
3785 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
3787 struct walk_type_data d
;
3790 memset (&d
, 0, sizeof (d
));
3796 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
3799 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
3801 if (wtd
->param_prefix
)
3803 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
3804 oprintf (f
, " (void *, void *, gt_pointer_operator, void *);\n");
3805 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3806 wtd
->param_prefix
, v
->name
);
3808 " ATTRIBUTE_UNUSED void *x_p,\n"
3809 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3810 " ATTRIBUTE_UNUSED void * cookie)\n");
3811 oprintf (d
.of
, "{\n");
3812 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3813 d
.process_field
= write_types_local_process_field
;
3814 walk_type (v
->type
, &d
);
3815 oprintf (f
, "}\n\n");
3819 oprintf (f
, "static void gt_%sa_%s (void *);\n", wtd
->prefix
, v
->name
);
3820 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3821 wtd
->prefix
, v
->name
);
3823 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3824 d
.process_field
= write_types_process_field
;
3825 walk_type (v
->type
, &d
);
3827 oprintf (f
, "}\n\n");
3830 /* Output a table describing the locations and types of VARIABLES. */
3833 write_roots (pair_p variables
, bool emit_pch
)
3836 struct flist
*flp
= NULL
;
3838 for (v
= variables
; v
; v
= v
->next
)
3841 get_output_file_with_visibility (CONST_CAST (input_file
*,
3844 const char *length
= NULL
;
3845 int deletable_p
= 0;
3847 for (o
= v
->opt
; o
; o
= o
->next
)
3848 if (strcmp (o
->name
, "length") == 0
3849 && o
->kind
== OPTION_STRING
)
3850 length
= o
->info
.string
;
3851 else if (strcmp (o
->name
, "deletable") == 0)
3853 else if (strcmp (o
->name
, "param_is") == 0)
3855 else if (strncmp (o
->name
, "param", 5) == 0
3856 && ISDIGIT (o
->name
[5]) && strcmp (o
->name
+ 6, "_is") == 0)
3858 else if (strcmp (o
->name
, "if_marked") == 0)
3861 error_at_line (&v
->line
,
3862 "global `%s' has unknown option `%s'",
3865 for (fli
= flp
; fli
; fli
= fli
->next
)
3866 if (fli
->f
== f
&& f
)
3870 fli
= XNEW (struct flist
);
3874 fli
->file
= v
->line
.file
;
3875 gcc_assert (fli
->file
);
3878 oprintf (f
, "\n/* GC roots. */\n\n");
3883 && v
->type
->kind
== TYPE_POINTER
3884 && (v
->type
->u
.p
->kind
== TYPE_POINTER
3885 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
3887 write_array (f
, v
, &ggc_wtd
);
3888 write_array (f
, v
, &pch_wtd
);
3892 for (v
= variables
; v
; v
= v
->next
)
3894 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
3901 for (o
= v
->opt
; o
; o
= o
->next
)
3902 if (strcmp (o
->name
, "length") == 0)
3904 else if (strcmp (o
->name
, "deletable") == 0
3905 || strcmp (o
->name
, "if_marked") == 0)
3911 for (fli
= flp
; fli
; fli
= fli
->next
)
3914 if (!fli
->started_p
)
3918 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3919 put_mangled_filename (f
, v
->line
.file
);
3920 oprintf (f
, "[] = {\n");
3923 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
, emit_pch
);
3926 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3929 for (v
= variables
; v
; v
= v
->next
)
3931 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
3937 for (o
= v
->opt
; o
; o
= o
->next
)
3938 if (strcmp (o
->name
, "deletable") == 0)
3940 else if (strcmp (o
->name
, "if_marked") == 0)
3946 for (fli
= flp
; fli
; fli
= fli
->next
)
3949 if (!fli
->started_p
)
3953 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3954 put_mangled_filename (f
, v
->line
.file
);
3955 oprintf (f
, "[] = {\n");
3958 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3962 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3963 "gt_ggc_deletable_rtab");
3965 for (v
= variables
; v
; v
= v
->next
)
3967 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
3970 const char *if_marked
= NULL
;
3974 for (o
= v
->opt
; o
; o
= o
->next
)
3975 if (strcmp (o
->name
, "length") == 0)
3977 else if (strcmp (o
->name
, "if_marked") == 0
3978 && o
->kind
== OPTION_STRING
)
3979 if_marked
= o
->info
.string
;
3980 if (if_marked
== NULL
)
3982 if (v
->type
->kind
!= TYPE_POINTER
3983 || v
->type
->u
.p
->kind
!= TYPE_PARAM_STRUCT
3984 || v
->type
->u
.p
->u
.param_struct
.stru
!= find_structure ("htab", 0))
3986 error_at_line (&v
->line
,
3987 "if_marked option used but not hash table");
3991 for (fli
= flp
; fli
; fli
= fli
->next
)
3994 if (!fli
->started_p
)
3998 oprintf (f
, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
3999 put_mangled_filename (f
, v
->line
.file
);
4000 oprintf (f
, "[] = {\n");
4003 write_root (f
, v
, v
->type
->u
.p
->u
.param_struct
.param
[0],
4004 v
->name
, length_p
, &v
->line
, if_marked
, emit_pch
);
4007 finish_root_table (flp
, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
4008 "gt_ggc_cache_rtab");
4013 for (v
= variables
; v
; v
= v
->next
)
4015 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4019 int if_marked_p
= 0;
4022 for (o
= v
->opt
; o
; o
= o
->next
)
4023 if (strcmp (o
->name
, "length") == 0)
4025 else if (strcmp (o
->name
, "if_marked") == 0)
4031 for (fli
= flp
; fli
; fli
= fli
->next
)
4034 if (!fli
->started_p
)
4038 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
4039 put_mangled_filename (f
, v
->line
.file
);
4040 oprintf (f
, "[] = {\n");
4043 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
, emit_pch
);
4046 finish_root_table (flp
, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4047 "gt_pch_cache_rtab");
4049 for (v
= variables
; v
; v
= v
->next
)
4051 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4057 for (o
= v
->opt
; o
; o
= o
->next
)
4058 if (strcmp (o
->name
, "deletable") == 0
4059 || strcmp (o
->name
, "if_marked") == 0)
4065 if (!contains_scalar_p (v
->type
))
4068 for (fli
= flp
; fli
; fli
= fli
->next
)
4071 if (!fli
->started_p
)
4075 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
4076 put_mangled_filename (f
, v
->line
.file
);
4077 oprintf (f
, "[] = {\n");
4080 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
4084 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4085 "gt_pch_scalar_rtab");
4088 /* Record the definition of a generic VEC structure, as if we had expanded
4089 the macros in vec.h:
4091 typedef struct VEC_<type>_base GTY(()) {
4094 <type> GTY((length ("%h.num"))) vec[1];
4097 where the GTY(()) tags are only present if is_scalar is _false_. */
4100 note_def_vec (const char *type_name
, bool is_scalar
, struct fileloc
*pos
)
4105 type_p len_ty
= create_scalar_type ("unsigned");
4106 const char *name
= concat ("VEC_", type_name
, "_base", (char *) 0);
4110 t
= create_scalar_type (type_name
);
4115 t
= resolve_typedef (type_name
, pos
);
4116 o
= create_string_option (0, "length", "%h.num");
4118 /* We assemble the field list in reverse order. */
4119 fields
= create_field_at (0, create_array (t
, "1"), "vec", o
, pos
);
4120 fields
= create_field_at (fields
, len_ty
, "alloc", 0, pos
);
4121 fields
= create_field_at (fields
, len_ty
, "num", 0, pos
);
4123 do_typedef (name
, new_structure (name
, 0, pos
, fields
, 0), pos
);
4126 /* Record the definition of an allocation-specific VEC structure, as if
4127 we had expanded the macros in vec.h:
4129 typedef struct VEC_<type>_<astrat> {
4130 VEC_<type>_base base;
4131 } VEC_<type>_<astrat>;
4134 note_def_vec_alloc (const char *type
, const char *astrat
, struct fileloc
*pos
)
4136 const char *astratname
= concat ("VEC_", type
, "_", astrat
, (char *) 0);
4137 const char *basename
= concat ("VEC_", type
, "_base", (char *) 0);
4139 pair_p field
= create_field_at (0, resolve_typedef (basename
, pos
),
4142 do_typedef (astratname
, new_structure (astratname
, 0, pos
, field
, 0), pos
);
4145 /* Returns the specifier keyword for a string or union type S, empty string
4149 get_type_specifier (const type_p s
)
4151 if (s
->kind
== TYPE_STRUCT
|| s
->kind
== TYPE_LANG_STRUCT
)
4153 if (s
->kind
== TYPE_UNION
)
4158 /* TRUE if type S has the GTY variable_size annotation. */
4161 variable_size_p (const type_p s
)
4164 for (o
= s
->u
.s
.opt
; o
; o
= o
->next
)
4165 if (strcmp (o
->name
, "variable_size") == 0)
4173 { any_zone
, specific_zone
};
4175 /* Writes one typed allocator definition for type identifier TYPE_NAME with
4176 optional type specifier TYPE_SPECIFIER. The allocator name will contain
4177 ALLOCATOR_TYPE. If VARIABLE_SIZE is true, the allocator will have an extra
4178 parameter specifying number of bytes to allocate. If QUANTITY is set to
4179 VECTOR, a vector allocator will be output, if ZONE is set to SPECIFIC_ZONE,
4180 the allocator will be zone-specific. */
4183 write_typed_alloc_def (bool variable_size
, const char *type_specifier
,
4184 const char *type_name
, const char *allocator_type
,
4185 enum alloc_quantity quantity
, enum alloc_zone zone
)
4187 bool two_args
= variable_size
&& (quantity
== vector
);
4188 bool third_arg
= ((zone
== specific_zone
)
4189 && (variable_size
|| (quantity
== vector
)));
4191 oprintf (header_file
, "#define ggc_alloc_%s%s", allocator_type
, type_name
);
4192 oprintf (header_file
, "(%s%s%s%s%s) ",
4193 (variable_size
? "SIZE" : ""),
4194 (two_args
? ", " : ""),
4195 (quantity
== vector
) ? "n" : "",
4196 (third_arg
? ", " : ""), (zone
== specific_zone
) ? "z" : "");
4197 oprintf (header_file
, "((%s%s *)", type_specifier
, type_name
);
4198 oprintf (header_file
, "(ggc_internal_%salloc_stat (", allocator_type
);
4199 if (zone
== specific_zone
)
4200 oprintf (header_file
, "z, ");
4202 oprintf (header_file
, "SIZE");
4204 oprintf (header_file
, "sizeof (%s%s)", type_specifier
, type_name
);
4205 if (quantity
== vector
)
4206 oprintf (header_file
, ", n");
4207 oprintf (header_file
, " MEM_STAT_INFO)))\n");
4210 /* Writes a typed allocator definition for a struct or union S. */
4213 write_typed_struct_alloc_def (const type_p s
, const char *allocator_type
,
4214 enum alloc_quantity quantity
,
4215 enum alloc_zone zone
)
4217 write_typed_alloc_def (variable_size_p (s
), get_type_specifier (s
),
4218 s
->u
.s
.tag
, allocator_type
, quantity
, zone
);
4221 /* Writes a typed allocator definition for a typedef P. */
4224 write_typed_typedef_alloc_def (const pair_p p
, const char *allocator_type
,
4225 enum alloc_quantity quantity
,
4226 enum alloc_zone zone
)
4228 write_typed_alloc_def (variable_size_p (p
->type
), "", p
->name
,
4229 allocator_type
, quantity
, zone
);
4232 /* Writes typed allocator definitions for the types in STRUCTURES and
4233 TYPEDEFS that are used by GC. */
4236 write_typed_alloc_defns (const type_p structures
, const pair_p typedefs
)
4241 oprintf (header_file
,
4242 "\n/* Allocators for known structs and unions. */\n\n");
4243 for (s
= structures
; s
; s
= s
->next
)
4245 if (!USED_BY_TYPED_GC_P (s
))
4247 write_typed_struct_alloc_def (s
, "", single
, any_zone
);
4248 write_typed_struct_alloc_def (s
, "cleared_", single
, any_zone
);
4249 write_typed_struct_alloc_def (s
, "vec_", vector
, any_zone
);
4250 write_typed_struct_alloc_def (s
, "cleared_vec_", vector
, any_zone
);
4251 write_typed_struct_alloc_def (s
, "zone_", single
, specific_zone
);
4252 write_typed_struct_alloc_def (s
, "zone_cleared_", single
,
4254 write_typed_struct_alloc_def (s
, "zone_vec_", vector
, specific_zone
);
4255 write_typed_struct_alloc_def (s
, "zone_cleared_vec_", vector
,
4259 oprintf (header_file
, "\n/* Allocators for known typedefs. */\n");
4260 for (p
= typedefs
; p
; p
= p
->next
)
4263 if (!USED_BY_TYPED_GC_P (s
) || (strcmp (p
->name
, s
->u
.s
.tag
) == 0))
4265 write_typed_typedef_alloc_def (p
, "", single
, any_zone
);
4266 write_typed_typedef_alloc_def (p
, "cleared_", single
, any_zone
);
4267 write_typed_typedef_alloc_def (p
, "vec_", vector
, any_zone
);
4268 write_typed_typedef_alloc_def (p
, "cleared_vec_", vector
, any_zone
);
4269 write_typed_typedef_alloc_def (p
, "zone_", single
, specific_zone
);
4270 write_typed_typedef_alloc_def (p
, "zone_cleared_", single
,
4272 write_typed_typedef_alloc_def (p
, "zone_cleared_vec_", vector
,
4277 /* Prints not-as-ugly version of a typename of T to OF. Trades the uniquness
4278 guaranteee for somewhat increased readability. If name conflicts do happen,
4279 this funcion will have to be adjusted to be more like
4280 output_mangled_typename. */
4283 output_typename (outf_p of
, const_type_p t
)
4288 oprintf (of
, "str");
4291 oprintf (of
, "scalar");
4294 output_typename (of
, t
->u
.p
);
4298 case TYPE_LANG_STRUCT
:
4299 oprintf (of
, "%s", t
->u
.s
.tag
);
4301 case TYPE_PARAM_STRUCT
:
4304 for (i
= 0; i
< NUM_PARAM
; i
++)
4305 if (t
->u
.param_struct
.param
[i
] != NULL
)
4307 output_typename (of
, t
->u
.param_struct
.param
[i
]);
4310 output_typename (of
, t
->u
.param_struct
.stru
);
4318 /* Writes a typed GC allocator for type S that is suitable as a callback for
4319 the splay tree implementation in libiberty. */
4322 write_splay_tree_allocator_def (const_type_p s
)
4324 outf_p of
= get_output_file_with_visibility (NULL
);
4325 oprintf (of
, "void * ggc_alloc_splay_tree_");
4326 output_typename (of
, s
);
4327 oprintf (of
, " (int sz, void * nl)\n");
4328 oprintf (of
, "{\n");
4329 oprintf (of
, " return ggc_splay_alloc (");
4330 oprintf (of
, "gt_e_");
4331 output_mangled_typename (of
, s
);
4332 oprintf (of
, ", sz, nl);\n");
4333 oprintf (of
, "}\n\n");
4336 /* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks
4337 for the splay tree implementation in libiberty. */
4340 write_splay_tree_allocators (const_type_p param_structs
)
4344 oprintf (header_file
, "\n/* Splay tree callback allocators. */\n");
4345 for (s
= param_structs
; s
; s
= s
->next
)
4346 if (s
->gc_used
== GC_POINTED_TO
)
4348 oprintf (header_file
, "extern void * ggc_alloc_splay_tree_");
4349 output_typename (header_file
, s
);
4350 oprintf (header_file
, " (int, void *);\n");
4351 write_splay_tree_allocator_def (s
);
4355 static void dump_pair (int indent
, pair_p p
);
4356 static void dump_type (int indent
, type_p p
);
4357 static void dump_type_list (int indent
, type_p p
);
4361 /* Dumps the value of typekind KIND. */
4364 dump_typekind (int indent
, enum typekind kind
)
4366 printf ("%*ckind = ", indent
, ' ');
4370 printf ("TYPE_SCALAR");
4373 printf ("TYPE_STRING");
4376 printf ("TYPE_STRUCT");
4379 printf ("TYPE_UNION");
4382 printf ("TYPE_POINTER");
4385 printf ("TYPE_ARRAY");
4387 case TYPE_LANG_STRUCT
:
4388 printf ("TYPE_LANG_STRUCT");
4390 case TYPE_PARAM_STRUCT
:
4391 printf ("TYPE_PARAM_STRUCT");
4399 /* Dumps the value of GC_USED flag. */
4402 dump_gc_used (int indent
, enum gc_used_enum gc_used
)
4404 printf ("%*cgc_used = ", indent
, ' ');
4408 printf ("GC_UNUSED");
4413 case GC_MAYBE_POINTED_TO
:
4414 printf ("GC_MAYBE_POINTED_TO");
4417 printf ("GC_POINTED_TO");
4425 /* Dumps the type options OPT. */
4428 dump_options (int indent
, options_p opt
)
4431 printf ("%*coptions = ", indent
, ' ');
4438 printf ("%s:string %s ", o
->name
, o
->info
.string
);
4441 printf ("%s:type ", o
->name
);
4442 dump_type (indent
+1, o
->info
.type
);
4445 printf ("%s:nested ", o
->name
);
4455 /* Dumps the source file location in LINE. */
4458 dump_fileloc (int indent
, struct fileloc line
)
4460 printf ("%*cfileloc: file = %s, line = %d\n", indent
, ' ',
4461 get_input_file_name (line
.file
),
4465 /* Recursively dumps the struct, union, or a language-specific
4469 dump_type_u_s (int indent
, type_p t
)
4473 gcc_assert (t
->kind
== TYPE_STRUCT
|| t
->kind
== TYPE_UNION
4474 || t
->kind
== TYPE_LANG_STRUCT
);
4475 printf ("%*cu.s.tag = %s\n", indent
, ' ', t
->u
.s
.tag
);
4476 dump_fileloc (indent
, t
->u
.s
.line
);
4477 printf ("%*cu.s.fields =\n", indent
, ' ');
4478 fields
= t
->u
.s
.fields
;
4481 dump_pair (indent
+ INDENT
, fields
);
4482 fields
= fields
->next
;
4484 printf ("%*cend of fields of type %p\n", indent
, ' ', (void *) t
);
4485 dump_options (indent
, t
->u
.s
.opt
);
4486 printf ("%*cu.s.bitmap = %X\n", indent
, ' ', t
->u
.s
.bitmap
);
4487 if (t
->kind
== TYPE_LANG_STRUCT
)
4489 printf ("%*cu.s.lang_struct:\n", indent
, ' ');
4490 dump_type_list (indent
+ INDENT
, t
->u
.s
.lang_struct
);
4494 /* Recursively dumps the array T. */
4497 dump_type_u_a (int indent
, type_p t
)
4499 gcc_assert (t
->kind
== TYPE_ARRAY
);
4500 printf ("%*clen = %s, u.a.p:\n", indent
, ' ', t
->u
.a
.len
);
4501 dump_type_list (indent
+ INDENT
, t
->u
.a
.p
);
4504 /* Recursively dumps the parameterized struct T. */
4507 dump_type_u_param_struct (int indent
, type_p t
)
4510 gcc_assert (t
->kind
== TYPE_PARAM_STRUCT
);
4511 printf ("%*cu.param_struct.stru:\n", indent
, ' ');
4512 dump_type_list (indent
, t
->u
.param_struct
.stru
);
4513 dump_fileloc (indent
, t
->u
.param_struct
.line
);
4514 for (i
= 0; i
< NUM_PARAM
; i
++)
4516 if (t
->u
.param_struct
.param
[i
] == NULL
)
4518 printf ("%*cu.param_struct.param[%d]:\n", indent
, ' ', i
);
4519 dump_type (indent
+ INDENT
, t
->u
.param_struct
.param
[i
]);
4523 /* Recursively dumps the type list T. */
4526 dump_type_list (int indent
, type_p t
)
4531 dump_type (indent
, p
);
4536 static htab_t seen_types
;
4538 /* Recursively dumps the type T if it was not dumped previously. */
4541 dump_type (int indent
, type_p t
)
4545 printf ("%*cType at %p: ", indent
, ' ', (void *) t
);
4546 slot
= htab_find_slot (seen_types
, t
, INSERT
);
4549 printf ("already seen.\n");
4555 dump_typekind (indent
, t
->kind
);
4556 printf ("%*cpointer_to = %p\n", indent
+ INDENT
, ' ',
4557 (void *) t
->pointer_to
);
4558 dump_gc_used (indent
+ INDENT
, t
->gc_used
);
4562 printf ("%*cscalar_is_char = %s\n", indent
+ INDENT
, ' ',
4563 t
->u
.scalar_is_char
? "true" : "false");
4569 case TYPE_LANG_STRUCT
:
4570 dump_type_u_s (indent
+ INDENT
, t
);
4573 printf ("%*cp:\n", indent
+ INDENT
, ' ');
4574 dump_type (indent
+ INDENT
, t
->u
.p
);
4577 dump_type_u_a (indent
+ INDENT
, t
);
4579 case TYPE_PARAM_STRUCT
:
4580 dump_type_u_param_struct (indent
+ INDENT
, t
);
4585 printf ("%*cEnd of type at %p\n", indent
, ' ', (void *) t
);
4588 /* Dumps the pair P. */
4591 dump_pair (int indent
, pair_p p
)
4593 printf ("%*cpair: name = %s\n", indent
, ' ', p
->name
);
4594 dump_type (indent
, p
->type
);
4595 dump_fileloc (indent
, p
->line
);
4596 dump_options (indent
, p
->opt
);
4597 printf ("%*cEnd of pair %s\n", indent
, ' ', p
->name
);
4600 /* Dumps the list of pairs PP. */
4603 dump_pair_list (const char *name
, pair_p pp
)
4606 printf ("%s:\n", name
);
4607 for (p
= pp
; p
!= NULL
; p
= p
->next
)
4609 printf ("End of %s\n\n", name
);
4612 /* Dumps the STRUCTURES. */
4615 dump_structures (const char *name
, type_p structures
)
4617 printf ("%s:\n", name
);
4618 dump_type_list (0, structures
);
4619 printf ("End of %s\n\n", name
);
4622 /* Dumps the internal structures of gengtype. This is useful to debug
4623 gengtype itself, or to understand what it does, e.g. for plugin
4627 dump_everything (void)
4629 seen_types
= htab_create (100, htab_hash_pointer
, htab_eq_pointer
, NULL
);
4630 dump_pair_list ("typedefs", typedefs
);
4631 dump_structures ("structures", structures
);
4632 dump_structures ("param_structs", param_structs
);
4633 dump_pair_list ("variables", variables
);
4634 htab_delete (seen_types
);
4639 /* Option specification for getopt_long. */
4640 static const struct option gengtype_long_options
[] = {
4641 {"help", no_argument
, NULL
, 'h'},
4642 {"version", no_argument
, NULL
, 'V'},
4643 {"verbose", no_argument
, NULL
, 'v'},
4644 {"dump", no_argument
, NULL
, 'd'},
4645 {"debug", no_argument
, NULL
, 'D'},
4646 {"plugin", required_argument
, NULL
, 'P'},
4647 {"srcdir", required_argument
, NULL
, 'S'},
4648 {"backupdir", required_argument
, NULL
, 'B'},
4649 {"inputs", required_argument
, NULL
, 'I'},
4650 {"read-state", required_argument
, NULL
, 'r'},
4651 {"write-state", required_argument
, NULL
, 'w'},
4652 /* Terminating NULL placeholder. */
4653 {NULL
, no_argument
, NULL
, 0},
4660 printf ("Usage: %s\n", progname
);
4661 printf ("\t -h | --help " " \t# Give this help.\n");
4662 printf ("\t -D | --debug "
4663 " \t# Give debug output to debug %s itself.\n", progname
);
4664 printf ("\t -V | --version " " \t# Give version information.\n");
4665 printf ("\t -v | --verbose \t# Increase verbosity. Can be given several times.\n");
4666 printf ("\t -d | --dump " " \t# Dump state for debugging.\n");
4667 printf ("\t -P | --plugin <output-file> <plugin-src> ... "
4668 " \t# Generate for plugin.\n");
4669 printf ("\t -S | --srcdir <GCC-directory> "
4670 " \t# Specify the GCC source directory.\n");
4671 printf ("\t -B | --backupdir <directory> "
4672 " \t# Specify the backup directory for updated files.\n");
4673 printf ("\t -I | --inputs <input-list> "
4674 " \t# Specify the file with source files list.\n");
4675 printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n");
4676 printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n");
4680 print_version (void)
4682 printf ("%s %s%s\n", progname
, pkgversion_string
, version_string
);
4683 printf ("Report bugs: %s\n", bug_report_url
);
4686 /* Parse the program options using getopt_long... */
4688 parse_program_options (int argc
, char **argv
)
4691 while ((opt
= getopt_long (argc
, argv
, "hVvdP:S:B:I:w:r:D",
4692 gengtype_long_options
, NULL
)) >= 0)
4696 case 'h': /* --help */
4699 case 'V': /* --version */
4702 case 'd': /* --dump */
4705 case 'D': /* --debug */
4708 case 'v': /* --verbose */
4711 case 'P': /* --plugin */
4713 plugin_output_filename
= optarg
;
4715 fatal ("missing plugin output file name");
4717 case 'S': /* --srcdir */
4721 fatal ("missing source directory");
4722 srcdir_len
= strlen (srcdir
);
4724 case 'B': /* --backupdir */
4726 backup_dir
= optarg
;
4728 fatal ("missing backup directory");
4730 case 'I': /* --inputs */
4734 fatal ("missing input list");
4736 case 'r': /* --read-state */
4738 read_state_filename
= optarg
;
4740 fatal ("missing read state file");
4741 DBGPRINTF ("read state %s\n", optarg
);
4743 case 'w': /* --write-state */
4744 DBGPRINTF ("write state %s\n", optarg
);
4746 write_state_filename
= optarg
;
4748 fatal ("missing write state file");
4751 fprintf (stderr
, "%s: unknown flag '%c'\n", progname
, opt
);
4753 fatal ("unexpected flag");
4756 if (plugin_output_filename
)
4758 /* In plugin mode we require some input files. */
4761 fatal ("no source files given in plugin mode");
4762 nb_plugin_files
= argc
- optind
;
4763 plugin_files
= XNEWVEC (input_file
*, nb_plugin_files
);
4764 for (i
= 0; i
< (int) nb_plugin_files
; i
++)
4766 char *name
= argv
[i
+ optind
];
4767 plugin_files
[i
] = input_file_by_name (name
);
4774 /******* Manage input files. ******/
4776 /* Hash table of unique input file names. */
4777 static htab_t input_file_htab
;
4779 /* Find or allocate a new input_file by hash-consing it. */
4781 input_file_by_name (const char* name
)
4784 input_file
* f
= NULL
;
4788 namlen
= strlen (name
);
4789 f
= XCNEWVAR (input_file
, sizeof (input_file
)+namlen
+2);
4792 strcpy (f
->inpname
, name
);
4793 slot
= htab_find_slot (input_file_htab
, f
, INSERT
);
4794 gcc_assert (slot
!= NULL
);
4797 /* Already known input file. */
4799 return (input_file
*)(*slot
);
4801 /* New input file. */
4806 /* Hash table support routines for input_file-s. */
4808 htab_hash_inputfile (const void *p
)
4810 const input_file
*inpf
= (const input_file
*) p
;
4812 return htab_hash_string (get_input_file_name (inpf
));
4816 htab_eq_inputfile (const void *x
, const void *y
)
4818 const input_file
*inpfx
= (const input_file
*) x
;
4819 const input_file
*inpfy
= (const input_file
*) y
;
4820 gcc_assert (inpfx
!= NULL
&& inpfy
!= NULL
);
4821 return !strcmp (get_input_file_name (inpfx
), get_input_file_name (inpfy
));
4826 main (int argc
, char **argv
)
4829 static struct fileloc pos
= { NULL
, 0 };
4830 outf_p output_header
;
4832 /* Mandatory common initializations. */
4833 progname
= "gengtype"; /* For fatal and messages. */
4834 /* Create the hash-table used to hash-cons input files. */
4836 htab_create (800, htab_hash_inputfile
, htab_eq_inputfile
, NULL
);
4837 /* Initialize our special input files. */
4838 this_file
= input_file_by_name (__FILE__
);
4839 system_h_file
= input_file_by_name ("system.h");
4840 /* Set the scalar_is_char union number for predefined scalar types. */
4841 scalar_nonchar
.u
.scalar_is_char
= FALSE
;
4842 scalar_char
.u
.scalar_is_char
= TRUE
;
4844 parse_program_options (argc
, argv
);
4849 time_t now
= (time_t) 0;
4851 DBGPRINTF ("gengtype started pid %d at %s",
4852 (int) getpid (), ctime (&now
));
4854 #endif /* ENABLE_CHECKING */
4856 /* Parse the input list and the input files. */
4857 DBGPRINTF ("inputlist %s", inputlist
);
4858 if (read_state_filename
)
4861 fatal ("input list %s cannot be given with a read state file %s",
4862 inputlist
, read_state_filename
);
4863 read_state (read_state_filename
);
4864 DBGPRINT_COUNT_TYPE ("structures after read_state", structures
);
4865 DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs
);
4869 /* These types are set up with #define or else outside of where
4870 we can see them. We should initialize them before calling
4872 #define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \
4874 POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos
));
4875 POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos
));
4876 POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos
));
4877 POS_HERE (do_scalar_typedef ("double_int", &pos
));
4878 POS_HERE (do_scalar_typedef ("uint64_t", &pos
));
4879 POS_HERE (do_scalar_typedef ("uint8", &pos
));
4880 POS_HERE (do_scalar_typedef ("jword", &pos
));
4881 POS_HERE (do_scalar_typedef ("JCF_u2", &pos
));
4882 POS_HERE (do_scalar_typedef ("void", &pos
));
4883 POS_HERE (do_typedef ("PTR",
4884 create_pointer (resolve_typedef ("void", &pos
)),
4887 read_input_list (inputlist
);
4888 for (i
= 0; i
< num_gt_files
; i
++)
4890 parse_file (get_input_file_name (gt_files
[i
]));
4891 DBGPRINTF ("parsed file #%d %s",
4892 (int) i
, get_input_file_name (gt_files
[i
]));
4894 if (verbosity_level
>= 1)
4895 printf ("%s parsed %d files with %d GTY types\n",
4896 progname
, (int) num_gt_files
, type_count
);
4898 DBGPRINT_COUNT_TYPE ("structures after parsing", structures
);
4899 DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs
);
4903 fatal ("either an input list or a read state file should be given");
4908 if (plugin_output_filename
)
4911 /* In plugin mode, we should have read a state file, and have
4912 given at least one plugin file. */
4913 if (!read_state_filename
)
4914 fatal ("No read state given in plugin mode for %s",
4915 plugin_output_filename
);
4917 if (nb_plugin_files
== 0 || !plugin_files
)
4918 fatal ("No plugin files given in plugin mode for %s",
4919 plugin_output_filename
);
4921 /* Parse our plugin files and augment the state. */
4922 for (ix
= 0; ix
< nb_plugin_files
; ix
++)
4923 parse_file (get_input_file_name (plugin_files
[ix
]));
4928 plugin_output
= create_file ("GCC", plugin_output_filename
);
4929 DBGPRINTF ("created plugin_output %p named %s",
4930 (void *) plugin_output
, plugin_output
->name
);
4933 { /* No plugin files, we are in normal mode. */
4935 fatal ("gengtype needs a source directory in normal mode");
4942 /* The call to set_gc_used may indirectly call find_param_structure
4943 hence enlarge the param_structs list of types. */
4944 set_gc_used (variables
);
4946 /* The state at this point is read from the state input file or by
4947 parsing source files and optionally augmented by parsing plugin
4948 source files. Write it now. */
4949 if (write_state_filename
)
4951 DBGPRINT_COUNT_TYPE ("structures before write_state", structures
);
4952 DBGPRINT_COUNT_TYPE ("param_structs before write_state", param_structs
);
4955 fatal ("didn't write state file %s after errors",
4956 write_state_filename
);
4958 DBGPRINTF ("before write_state %s", write_state_filename
);
4959 write_state (write_state_filename
);
4964 /* After having written the state file we return immediately to
4965 avoid generating any output file. */
4975 write_enum_defn (structures
, param_structs
);
4976 write_typed_alloc_defns (structures
, typedefs
);
4977 output_header
= plugin_output
? plugin_output
: header_file
;
4978 DBGPRINT_COUNT_TYPE ("structures before write_types outputheader",
4980 DBGPRINT_COUNT_TYPE ("param_structs before write_types outputheader",
4983 write_types (output_header
, structures
, param_structs
, &ggc_wtd
);
4984 if (plugin_files
== NULL
)
4986 DBGPRINT_COUNT_TYPE ("structures before write_types headerfil",
4988 DBGPRINT_COUNT_TYPE ("param_structs before write_types headerfil",
4990 write_types (header_file
, structures
, param_structs
, &pch_wtd
);
4991 write_local (header_file
, structures
, param_structs
);
4993 write_splay_tree_allocators (param_structs
);
4994 write_roots (variables
, plugin_files
== NULL
);
4996 close_output_files ();
5001 /* Don't bother about free-ing any input or plugin file, etc. */