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";
1104 else if (i
== ENTRY_VALUE
&& aindex
== 0)
1105 t
= rtx_tp
, subname
= "rt_rtx";
1110 "rtx type `%s' has `0' in position %lu, can't handle",
1111 rtx_name
[i
], (unsigned long) aindex
);
1133 subname
= "rt_rtvec";
1138 subname
= "rt_tree";
1149 "rtx type `%s' has `%c' in position %lu, can't handle",
1150 rtx_name
[i
], rtx_format
[i
][aindex
],
1151 (unsigned long) aindex
);
1157 subfields
= create_field (subfields
, t
,
1158 xasprintf (".fld[%lu].%s",
1159 (unsigned long) aindex
,
1161 subfields
->opt
= nodot
;
1162 if (t
== note_union_tp
)
1164 create_string_option (subfields
->opt
, "desc",
1166 if (t
== symbol_union_tp
)
1168 create_string_option (subfields
->opt
, "desc",
1169 "CONSTANT_POOL_ADDRESS_P (&%0)");
1172 if (i
== SYMBOL_REF
)
1174 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P
1176 type_p field_tp
= find_structure ("block_symbol", 0);
1178 = create_optional_field (subfields
, field_tp
, "block_sym",
1179 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1182 sname
= xasprintf ("rtx_def_%s", rtx_name
[i
]);
1183 substruct
= new_structure (sname
, 0, &lexer_line
, subfields
, NULL
);
1185 ftag
= xstrdup (rtx_name
[i
]);
1186 for (nmindex
= 0; nmindex
< strlen (ftag
); nmindex
++)
1187 ftag
[nmindex
] = TOUPPER (ftag
[nmindex
]);
1188 flds
= create_field (flds
, substruct
, "");
1189 flds
->opt
= create_string_option (nodot
, "tag", ftag
);
1191 return new_structure ("rtx_def_subunion", 1, &lexer_line
, flds
, nodot
);
1194 /* Handle `special("tree_exp")'. This is a special case for
1195 field `operands' of struct tree_exp, which although it claims to contain
1196 pointers to trees, actually sometimes contains pointers to RTL too.
1197 Passed T, the old type of the field, and OPT its options. Returns
1198 a new type for the field. */
1201 adjust_field_tree_exp (type_p t
, options_p opt ATTRIBUTE_UNUSED
)
1206 if (t
->kind
!= TYPE_ARRAY
)
1208 error_at_line (&lexer_line
,
1209 "special `tree_exp' must be applied to an array");
1210 return &string_type
;
1213 nodot
= create_string_option (NULL
, "dot", "");
1215 flds
= create_field (NULL
, t
, "");
1216 flds
->opt
= create_string_option (nodot
, "length",
1217 "TREE_OPERAND_LENGTH ((tree) &%0)");
1218 flds
->opt
= create_string_option (flds
->opt
, "default", "");
1220 return new_structure ("tree_exp_subunion", 1, &lexer_line
, flds
, nodot
);
1223 /* Perform any special processing on a type T, about to become the type
1224 of a field. Return the appropriate type for the field.
1226 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1227 - Similarly for arrays of pointer-to-char;
1228 - Converts structures for which a parameter is provided to
1230 - Handles "special" options.
1234 adjust_field_type (type_p t
, options_p opt
)
1237 const int pointer_p
= t
->kind
== TYPE_POINTER
;
1238 type_p params
[NUM_PARAM
];
1242 for (i
= 0; i
< NUM_PARAM
; i
++)
1245 for (; opt
; opt
= opt
->next
)
1246 if (strcmp (opt
->name
, "length") == 0)
1248 else if ((strcmp (opt
->name
, "param_is") == 0
1249 || (strncmp (opt
->name
, "param", 5) == 0
1250 && ISDIGIT (opt
->name
[5])
1251 && strcmp (opt
->name
+ 6, "_is") == 0))
1252 && opt
->kind
== OPTION_TYPE
)
1254 int num
= ISDIGIT (opt
->name
[5]) ? opt
->name
[5] - '0' : 0;
1256 if (!UNION_OR_STRUCT_P (t
)
1257 && (t
->kind
!= TYPE_POINTER
|| !UNION_OR_STRUCT_P (t
->u
.p
)))
1259 error_at_line (&lexer_line
,
1260 "option `%s' may only be applied to structures or structure pointers",
1266 if (params
[num
] != NULL
)
1267 error_at_line (&lexer_line
, "duplicate `%s' option", opt
->name
);
1268 if (!ISDIGIT (opt
->name
[5]))
1269 params
[num
] = create_pointer (opt
->info
.type
);
1271 params
[num
] = opt
->info
.type
;
1273 else if (strcmp (opt
->name
, "special") == 0
1274 && opt
->kind
== OPTION_STRING
)
1276 const char *special_name
= opt
->info
.string
;
1277 if (strcmp (special_name
, "tree_exp") == 0)
1278 t
= adjust_field_tree_exp (t
, opt
);
1279 else if (strcmp (special_name
, "rtx_def") == 0)
1280 t
= adjust_field_rtx_def (t
, opt
);
1282 error_at_line (&lexer_line
, "unknown special `%s'", special_name
);
1291 realt
= find_param_structure (t
, params
);
1292 t
= pointer_p
? create_pointer (realt
) : realt
;
1296 && pointer_p
&& t
->u
.p
->kind
== TYPE_SCALAR
&& t
->u
.p
->u
.scalar_is_char
)
1297 return &string_type
;
1298 if (t
->kind
== TYPE_ARRAY
&& t
->u
.a
.p
->kind
== TYPE_POINTER
1299 && t
->u
.a
.p
->u
.p
->kind
== TYPE_SCALAR
1300 && t
->u
.a
.p
->u
.p
->u
.scalar_is_char
)
1301 return create_array (&string_type
, t
->u
.a
.len
);
1307 static void set_gc_used_type (type_p
, enum gc_used_enum
, type_p
*);
1308 static void set_gc_used (pair_p
);
1310 /* Handle OPT for set_gc_used_type. */
1313 process_gc_options (options_p opt
, enum gc_used_enum level
, int *maybe_undef
,
1314 int *pass_param
, int *length
, int *skip
,
1318 for (o
= opt
; o
; o
= o
->next
)
1319 if (strcmp (o
->name
, "ptr_alias") == 0 && level
== GC_POINTED_TO
1320 && o
->kind
== OPTION_TYPE
)
1321 set_gc_used_type (o
->info
.type
,
1322 GC_POINTED_TO
, NULL
);
1323 else if (strcmp (o
->name
, "maybe_undef") == 0)
1325 else if (strcmp (o
->name
, "use_params") == 0)
1327 else if (strcmp (o
->name
, "length") == 0)
1329 else if (strcmp (o
->name
, "skip") == 0)
1331 else if (strcmp (o
->name
, "nested_ptr") == 0
1332 && o
->kind
== OPTION_NESTED
)
1333 *nested_ptr
= ((const struct nested_ptr_data
*) o
->info
.nested
)->type
;
1337 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1339 set_gc_used_type (type_p t
, enum gc_used_enum level
, type_p param
[NUM_PARAM
])
1341 if (t
->gc_used
>= level
)
1355 process_gc_options (t
->u
.s
.opt
, level
, &dummy
, &dummy
, &dummy
, &dummy
,
1358 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
1360 int maybe_undef
= 0;
1364 type_p nested_ptr
= NULL
;
1365 process_gc_options (f
->opt
, level
, &maybe_undef
, &pass_param
,
1366 &length
, &skip
, &nested_ptr
);
1368 if (nested_ptr
&& f
->type
->kind
== TYPE_POINTER
)
1369 set_gc_used_type (nested_ptr
, GC_POINTED_TO
,
1370 pass_param
? param
: NULL
);
1371 else if (length
&& f
->type
->kind
== TYPE_POINTER
)
1372 set_gc_used_type (f
->type
->u
.p
, GC_USED
, NULL
);
1373 else if (maybe_undef
&& f
->type
->kind
== TYPE_POINTER
)
1374 set_gc_used_type (f
->type
->u
.p
, GC_MAYBE_POINTED_TO
, NULL
);
1375 else if (pass_param
&& f
->type
->kind
== TYPE_POINTER
&& param
)
1376 set_gc_used_type (find_param_structure (f
->type
->u
.p
, param
),
1377 GC_POINTED_TO
, NULL
);
1379 ; /* target type is not used through this field */
1381 set_gc_used_type (f
->type
, GC_USED
, pass_param
? param
: NULL
);
1387 set_gc_used_type (t
->u
.p
, GC_POINTED_TO
, NULL
);
1391 set_gc_used_type (t
->u
.a
.p
, GC_USED
, param
);
1394 case TYPE_LANG_STRUCT
:
1395 for (t
= t
->u
.s
.lang_struct
; t
; t
= t
->next
)
1396 set_gc_used_type (t
, level
, param
);
1399 case TYPE_PARAM_STRUCT
:
1402 for (i
= 0; i
< NUM_PARAM
; i
++)
1403 if (t
->u
.param_struct
.param
[i
] != 0)
1404 set_gc_used_type (t
->u
.param_struct
.param
[i
], GC_USED
, NULL
);
1406 if (t
->u
.param_struct
.stru
->gc_used
== GC_POINTED_TO
)
1407 level
= GC_POINTED_TO
;
1410 t
->u
.param_struct
.stru
->gc_used
= GC_UNUSED
;
1411 set_gc_used_type (t
->u
.param_struct
.stru
, level
,
1412 t
->u
.param_struct
.param
);
1420 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1423 set_gc_used (pair_p variables
)
1427 for (p
= variables
; p
; p
= p
->next
)
1429 set_gc_used_type (p
->type
, GC_USED
, NULL
);
1432 if (verbosity_level
>= 2)
1433 printf ("%s used %d GTY-ed variables\n", progname
, nbvars
);
1436 /* File mapping routines. For each input file, there is one output .c file
1437 (but some output files have many input files), and there is one .h file
1438 for the whole build. */
1440 /* Output file handling. */
1442 /* Create and return an outf_p for a new file for NAME, to be called
1446 create_file (const char *name
, const char *oname
)
1448 static const char *const hdr
[] = {
1449 " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n",
1451 "This file is part of GCC.\n",
1453 "GCC is free software; you can redistribute it and/or modify it under\n",
1454 "the terms of the GNU General Public License as published by the Free\n",
1455 "Software Foundation; either version 3, or (at your option) any later\n",
1458 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1459 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1460 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1461 "for more details.\n",
1463 "You should have received a copy of the GNU General Public License\n",
1464 "along with GCC; see the file COPYING3. If not see\n",
1465 "<http://www.gnu.org/licenses/>. */\n",
1467 "/* This file is machine generated. Do not edit. */\n"
1472 gcc_assert (name
!= NULL
);
1473 gcc_assert (oname
!= NULL
);
1474 f
= XCNEW (struct outf
);
1475 f
->next
= output_files
;
1479 oprintf (f
, "/* Type information for %s.\n", name
);
1480 for (i
= 0; i
< ARRAY_SIZE (hdr
); i
++)
1481 oprintf (f
, "%s", hdr
[i
]);
1485 /* Print, like fprintf, to O.
1486 N.B. You might think this could be implemented more efficiently
1487 with vsnprintf(). Unfortunately, there are C libraries that
1488 provide that function but without the C99 semantics for its return
1489 value, making it impossible to know how much space is required. */
1491 oprintf (outf_p o
, const char *format
, ...)
1497 /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1502 va_start (ap
, format
);
1503 slength
= vasprintf (&s
, format
, ap
);
1504 if (s
== NULL
|| (int) slength
< 0)
1505 fatal ("out of memory");
1508 if (o
->bufused
+ slength
> o
->buflength
)
1510 size_t new_len
= o
->buflength
;
1517 while (o
->bufused
+ slength
>= new_len
);
1518 o
->buf
= XRESIZEVEC (char, o
->buf
, new_len
);
1519 o
->buflength
= new_len
;
1521 memcpy (o
->buf
+ o
->bufused
, s
, slength
);
1522 o
->bufused
+= slength
;
1526 /* Open the global header file and the language-specific header files. */
1529 open_base_files (void)
1533 if (nb_plugin_files
> 0 && plugin_files
)
1536 header_file
= create_file ("GCC", "gtype-desc.h");
1538 base_files
= XNEWVEC (outf_p
, num_lang_dirs
);
1540 for (i
= 0; i
< num_lang_dirs
; i
++)
1541 base_files
[i
] = create_file (lang_dir_names
[i
],
1542 xasprintf ("gtype-%s.h", lang_dir_names
[i
]));
1544 /* gtype-desc.c is a little special, so we create it here. */
1546 /* The order of files here matters very much. */
1547 static const char *const ifiles
[] = {
1548 "config.h", "system.h", "coretypes.h", "tm.h",
1549 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1550 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1551 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1552 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1553 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1554 "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h",
1555 "target.h", "ipa-prop.h", "lto-streamer.h", "target-globals.h", NULL
1557 const char *const *ifp
;
1558 outf_p gtype_desc_c
;
1560 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1561 for (ifp
= ifiles
; *ifp
; ifp
++)
1562 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1564 /* Make sure we handle "cfun" specially. */
1565 oprintf (gtype_desc_c
, "\n/* See definition in function.h. */\n");
1566 oprintf (gtype_desc_c
, "#undef cfun\n");
1570 /* For INPF an input file, return the real basename of INPF, with all
1571 the directory components skipped. */
1574 get_file_realbasename (const input_file
*inpf
)
1576 const char *f
= get_input_file_name (inpf
);
1577 const char *lastslash
= strrchr (f
, '/');
1579 return (lastslash
!= NULL
) ? lastslash
+ 1 : f
;
1582 /* For INPF a filename, return the relative path to INPF from
1583 $(srcdir) if the latter is a prefix in INPF, NULL otherwise. */
1586 get_file_srcdir_relative_path (const input_file
*inpf
)
1588 const char *f
= get_input_file_name (inpf
);
1589 if (strlen (f
) > srcdir_len
1590 && IS_DIR_SEPARATOR (f
[srcdir_len
])
1591 && strncmp (f
, srcdir
, srcdir_len
) == 0)
1592 return f
+ srcdir_len
+ 1;
1597 /* For INPF an input_file, return the relative path to INPF from
1598 $(srcdir) if the latter is a prefix in INPF, or the real basename
1599 of INPF otherwise. */
1602 get_file_basename (const input_file
*inpf
)
1604 const char *srcdir_path
= get_file_srcdir_relative_path (inpf
);
1606 return (srcdir_path
!= NULL
) ? srcdir_path
: get_file_realbasename (inpf
);
1609 /* For F a filename, return the lang_dir_names relative index of the language
1610 directory that is a prefix in F, if any, -1 otherwise. */
1613 get_prefix_langdir_index (const char *f
)
1615 size_t f_len
= strlen (f
);
1618 for (lang_index
= 0; lang_index
< num_lang_dirs
; lang_index
++)
1620 const char *langdir
= lang_dir_names
[lang_index
];
1621 size_t langdir_len
= strlen (langdir
);
1623 if (f_len
> langdir_len
1624 && IS_DIR_SEPARATOR (f
[langdir_len
])
1625 && memcmp (f
, langdir
, langdir_len
) == 0)
1632 /* For INPF an input file, return the name of language directory where
1633 F is located, if any, NULL otherwise. */
1636 get_file_langdir (const input_file
*inpf
)
1638 /* Get the relative path to INPF from $(srcdir) and find the
1639 language by comparing the prefix with language directory names.
1640 If INPF is not even srcdir relative, no point in looking
1644 const char *srcdir_relative_path
= get_file_srcdir_relative_path (inpf
);
1647 if (!srcdir_relative_path
)
1650 lang_index
= get_prefix_langdir_index (srcdir_relative_path
);
1651 if (lang_index
< 0 && strncmp (srcdir_relative_path
, "c-family", 8) == 0)
1653 else if (lang_index
>= 0)
1654 r
= lang_dir_names
[lang_index
];
1661 /* The gt- output file name for INPF. */
1664 get_file_gtfilename (const input_file
*inpf
)
1666 /* Cook up an initial version of the gt- file name from the file real
1667 basename and the language name, if any. */
1669 const char *basename
= get_file_realbasename (inpf
);
1670 const char *langdir
= get_file_langdir (inpf
);
1673 (langdir
? xasprintf ("gt-%s-%s", langdir
, basename
)
1674 : xasprintf ("gt-%s", basename
));
1676 /* Then replace all non alphanumerics characters by '-' and change the
1677 extension to ".h". We expect the input filename extension was at least
1678 one character long. */
1682 for (; *s
!= '.'; s
++)
1683 if (!ISALNUM (*s
) && *s
!= '-')
1686 memcpy (s
, ".h", sizeof (".h"));
1691 /* Each input_file has its associated output file outf_p. The
1692 association is computed by the function
1693 get_output_file_with_visibility. The associated file is cached
1694 inside input_file in its inpoutf field, so is really computed only
1695 once. Associated output file paths (i.e. output_name-s) are
1696 computed by a rule based regexp machinery, using the files_rules
1697 array of struct file_rule_st. A for_name is also computed, giving
1698 the source file name for which the output_file is generated; it is
1699 often the last component of the input_file path. */
1703 Regexpr machinery to compute the output_name and for_name-s of each
1704 input_file. We have a sequence of file rules which gives the POSIX
1705 extended regular expression to match an input file path, and two
1706 transformed strings for the corresponding output_name and the
1707 corresponding for_name. The transformed string contain dollars: $0
1708 is replaced by the entire match, $1 is replaced by the substring
1709 matching the first parenthesis in the regexp, etc. And $$ is replaced
1710 by a single verbatim dollar. The rule order is important. The
1711 general case is last, and the particular cases should come before.
1712 An action routine can, when needed, update the out_name & for_name
1713 and/or return the appropriate output file. It is invoked only when a
1714 rule is triggered. When a rule is triggered, the output_name and
1715 for_name are computed using their transform string in while $$, $0,
1716 $1, ... are suitably replaced. If there is an action, it is called.
1717 In some few cases, the action can directly return the outf_p, but
1718 usually it just updates the output_name and for_name so should free
1719 them before replacing them. The get_output_file_with_visibility
1720 function creates an outf_p only once per each output_name, so it
1721 scans the output_files list for previously seen output file names.
1724 /* Signature of actions in file rules. */
1725 typedef outf_p (frul_actionrout_t
) (input_file
*, char**, char**);
1728 struct file_rule_st
{
1729 const char* frul_srcexpr
; /* Source string for regexp. */
1730 int frul_rflags
; /* Flags passed to regcomp, usually
1732 regex_t
* frul_re
; /* Compiled regular expression
1733 obtained by regcomp. */
1734 const char* frul_tr_out
; /* Transformation string for making
1735 * the output_name, with $1 ... $9 for
1736 * subpatterns and $0 for the whole
1737 * matched filename. */
1738 const char* frul_tr_for
; /* Tranformation string for making the
1740 frul_actionrout_t
* frul_action
; /* The action, if non null, is
1741 * called once the rule matches, on
1742 * the transformed out_name &
1743 * for_name. It could change them
1744 * and/or give the output file. */
1747 /* File rule action handling *.h files. */
1748 static outf_p
header_dot_h_frul (input_file
*, char**, char**);
1750 /* File rule action handling *.c files. */
1751 static outf_p
source_dot_c_frul (input_file
*, char**, char**);
1753 #define NULL_REGEX (regex_t*)0
1755 /* The prefix in our regexp-s matching the directory. */
1756 #define DIR_PREFIX_REGEX "^(([^/]*/)*)"
1758 #define NULL_FRULACT (frul_actionrout_t*)0
1760 /* The array of our rules governing file name generation. Rules order
1761 matters, so change with extreme care! */
1763 struct file_rule_st files_rules
[] = {
1764 /* the c-family/ source directory is special. */
1765 { DIR_PREFIX_REGEX
"c-family/([[:alnum:]_-]*)\\.c$",
1766 REG_EXTENDED
, NULL_REGEX
,
1767 "gt-c-family-$3.h", "c-family/$3.c", NULL_FRULACT
},
1769 { DIR_PREFIX_REGEX
"c-family/([[:alnum:]_-]*)\\.h$",
1770 REG_EXTENDED
, NULL_REGEX
,
1771 "gt-c-family-$3.h", "c-family/$3.h", NULL_FRULACT
},
1773 /* Both c-lang.h & c-tree.h gives gt-c-decl.h for c-decl.c ! */
1774 { DIR_PREFIX_REGEX
"c-lang\\.h$",
1775 REG_EXTENDED
, NULL_REGEX
, "gt-c-decl.h", "c-decl.c", NULL_FRULACT
},
1777 { DIR_PREFIX_REGEX
"c-tree\\.h$",
1778 REG_EXTENDED
, NULL_REGEX
, "gt-c-decl.h", "c-decl.c", NULL_FRULACT
},
1780 /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.c ! */
1781 { DIR_PREFIX_REGEX
"cp/cp-tree\\.h$",
1782 REG_EXTENDED
, NULL_REGEX
,
1783 "gt-cp-tree.h", "cp/tree.c", NULL_FRULACT
},
1785 /* cp/decl.h & cp/decl.c gives gt-cp-decl.h for cp/decl.c ! */
1786 { DIR_PREFIX_REGEX
"cp/decl\\.[ch]$",
1787 REG_EXTENDED
, NULL_REGEX
,
1788 "gt-cp-decl.h", "cp/decl.c", NULL_FRULACT
},
1790 /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.c ! */
1791 { DIR_PREFIX_REGEX
"cp/name-lookup\\.h$",
1792 REG_EXTENDED
, NULL_REGEX
,
1793 "gt-cp-name-lookup.h", "cp/name-lookup.c", NULL_FRULACT
},
1795 /* objc/objc-act.h fives gt-objc-objc-act.h for objc/objc-act.c ! */
1796 { DIR_PREFIX_REGEX
"objc/objc-act\\.h$",
1797 REG_EXTENDED
, NULL_REGEX
,
1798 "gt-objc-objc-act.h", "objc/objc-act.c", NULL_FRULACT
},
1800 /* General cases. For header *.h and source *.c files, we need
1801 * special actions to handle the language. */
1803 /* Source *.c files are using get_file_gtfilename to compute their
1804 output_name and get_file_basename to compute their for_name
1805 thru the source_dot_c_frul action. */
1806 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.c$",
1807 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.c", source_dot_c_frul
},
1808 /* Common header files get "gtype-desc.c" as their output_name,
1809 * while language specific header files are handled specially. So
1810 * we need the header_dot_h_frul action. */
1811 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.h$",
1812 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.h", header_dot_h_frul
},
1814 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.in$",
1815 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.in", NULL_FRULACT
},
1817 /* Mandatory null last entry signaling end of rules. */
1818 {NULL
, 0, NULL_REGEX
, NULL
, NULL
, NULL_FRULACT
}
1821 /* Special file rules action for handling *.h header files. It gives
1822 "gtype-desc.c" for common headers and corresponding output
1823 files for language-specific header files. */
1825 header_dot_h_frul (input_file
* inpf
, char**poutname
,
1826 char**pforname ATTRIBUTE_UNUSED
)
1828 const char *basename
= 0;
1830 DBGPRINTF ("inpf %p inpname %s outname %s forname %s",
1831 (void*) inpf
, get_input_file_name (inpf
),
1832 *poutname
, *pforname
);
1833 basename
= get_file_basename (inpf
);
1834 lang_index
= get_prefix_langdir_index (basename
);
1835 DBGPRINTF ("basename %s lang_index %d", basename
, lang_index
);
1837 if (lang_index
>= 0)
1839 /* The header is language specific. Given output_name &
1840 for_name remains unchanged. The base_files array gives the
1842 DBGPRINTF ("header_dot_h found language specific @ %p '%s'",
1843 (void*) base_files
[lang_index
],
1844 (base_files
[lang_index
])->name
);
1845 return base_files
[lang_index
];
1849 /* The header is common to all front-end languages. So
1850 output_name is "gtype-desc.c" file. The calling function
1851 get_output_file_with_visibility will find its outf_p. */
1853 *poutname
= xstrdup ("gtype-desc.c");
1854 DBGPRINTF ("special 'gtype-desc.c' for inpname %s",
1855 get_input_file_name (inpf
));
1861 /* Special file rules action for handling *.c source files using
1862 * get_file_gtfilename to compute their output_name and
1863 * get_file_basename to compute their for_name. The output_name is
1864 * gt-<LANG>-<BASE>.h for language specific source files, and
1865 * gt-<BASE>.h for common source files. */
1867 source_dot_c_frul (input_file
* inpf
, char**poutname
, char**pforname
)
1869 char *newbasename
= CONST_CAST (char*, get_file_basename (inpf
));
1870 char *newoutname
= CONST_CAST (char*, get_file_gtfilename (inpf
));
1871 DBGPRINTF ("inpf %p inpname %s original outname %s forname %s",
1872 (void*) inpf
, get_input_file_name (inpf
),
1873 *poutname
, *pforname
);
1874 DBGPRINTF ("newoutname %s", newoutname
);
1875 DBGPRINTF ("newbasename %s", newbasename
);
1878 *poutname
= newoutname
;
1879 *pforname
= newbasename
;
1883 /* Utility function for get_output_file_with_visibility which returns
1884 * a malloc-ed substituted string using TRS on matching of the FILNAM
1885 * file name, using the PMATCH array. */
1887 matching_file_name_substitute (const char *filnam
, regmatch_t pmatch
[10],
1890 struct obstack str_obstack
;
1892 char *rawstr
= NULL
;
1893 const char *pt
= NULL
;
1894 DBGPRINTF ("filnam %s", filnam
);
1895 obstack_init (&str_obstack
);
1896 for (pt
= trs
; *pt
; pt
++) {
1902 /* A double dollar $$ is substituted by a single verbatim
1903 dollar, but who really uses dollar signs in file
1905 obstack_1grow (&str_obstack
, '$');
1907 else if (ISDIGIT (pt
[1]))
1909 /* Handle $0 $1 ... $9 by appropriate substitution. */
1910 int dolnum
= pt
[1] - '0';
1911 int so
= pmatch
[dolnum
].rm_so
;
1912 int eo
= pmatch
[dolnum
].rm_eo
;
1913 DBGPRINTF ("so=%d eo=%d dolnum=%d", so
, eo
, dolnum
);
1914 if (so
>=0 && eo
>=so
)
1915 obstack_grow (&str_obstack
, filnam
+ so
, eo
- so
);
1919 /* This can happen only when files_rules is buggy! */
1922 /* Always skip the character after the dollar. */
1926 obstack_1grow (&str_obstack
, c
);
1928 obstack_1grow (&str_obstack
, '\0');
1929 rawstr
= XOBFINISH (&str_obstack
, char *);
1930 str
= xstrdup (rawstr
);
1931 obstack_free (&str_obstack
, rawstr
);
1932 DBGPRINTF ("matched replacement %s", str
);
1938 /* An output file, suitable for definitions, that can see declarations
1939 made in INPF and is linked into every language that uses INPF.
1940 Since the the result is cached inside INPF, that argument cannot be
1941 declared constant, but is "almost" constant. */
1944 get_output_file_with_visibility (input_file
*inpf
)
1947 char *for_name
= NULL
;
1948 char *output_name
= NULL
;
1949 const char* inpfname
;
1951 /* This can happen when we need a file with visibility on a
1952 structure that we've never seen. We have to just hope that it's
1953 globally visible. */
1955 inpf
= system_h_file
;
1957 /* The result is cached in INPF, so return it if already known. */
1959 return inpf
->inpoutf
;
1961 /* In plugin mode, return NULL unless the input_file is one of the
1966 for (i
= 0; i
< nb_plugin_files
; i
++)
1967 if (inpf
== plugin_files
[i
])
1969 inpf
->inpoutf
= plugin_output
;
1970 return plugin_output
;
1976 inpfname
= get_input_file_name (inpf
);
1978 /* Try each rule in sequence in files_rules until one is triggered. */
1981 DBGPRINTF ("passing input file @ %p named %s thru the files_rules",
1982 (void*) inpf
, inpfname
);
1984 for (; files_rules
[rulix
].frul_srcexpr
!= NULL
; rulix
++)
1986 DBGPRINTF ("rulix#%d srcexpr %s",
1987 rulix
, files_rules
[rulix
].frul_srcexpr
);
1989 if (!files_rules
[rulix
].frul_re
)
1991 /* Compile the regexpr lazily. */
1993 files_rules
[rulix
].frul_re
= XCNEW (regex_t
);
1994 err
= regcomp (files_rules
[rulix
].frul_re
,
1995 files_rules
[rulix
].frul_srcexpr
,
1996 files_rules
[rulix
].frul_rflags
);
1999 /* The regular expression compilation fails only when
2000 file_rules is buggy. */
2008 /* Match the regexpr and trigger the rule if matched. */
2010 /* We have exactly ten pmatch-s, one for each $0, $1, $2,
2012 regmatch_t pmatch
[10];
2013 memset (pmatch
, 0, sizeof (pmatch
));
2014 if (!regexec (files_rules
[rulix
].frul_re
,
2015 inpfname
, 10, pmatch
, 0))
2017 DBGPRINTF ("input @ %p filename %s matched rulix#%d pattern %s",
2018 (void*) inpf
, inpfname
, rulix
,
2019 files_rules
[rulix
].frul_srcexpr
);
2021 matching_file_name_substitute (inpfname
, pmatch
,
2022 files_rules
[rulix
].frul_tr_for
);
2023 DBGPRINTF ("for_name %s", for_name
);
2025 matching_file_name_substitute (inpfname
, pmatch
,
2026 files_rules
[rulix
].frul_tr_out
);
2027 DBGPRINTF ("output_name %s", output_name
);
2028 if (files_rules
[rulix
].frul_action
)
2030 /* Invoke our action routine. */
2032 DBGPRINTF ("before action rulix#%d output_name %s for_name %s",
2033 rulix
, output_name
, for_name
);
2035 (files_rules
[rulix
].frul_action
) (inpf
,
2036 &output_name
, &for_name
);
2037 DBGPRINTF ("after action rulix#%d of=%p output_name %s for_name %s",
2038 rulix
, (void*)of
, output_name
, for_name
);
2039 /* If the action routine returned something, give it back
2040 immediately and cache it in inpf. */
2047 /* The rule matched, and had no action, or that action did
2048 not return any output file but could have changed the
2049 output_name or for_name. We break out of the loop on the
2055 /* The regexpr did not match. */
2056 DBGPRINTF ("rulix#%d did not match %s pattern %s",
2057 rulix
, inpfname
, files_rules
[rulix
].frul_srcexpr
);
2063 if (!output_name
|| !for_name
)
2065 /* This is impossible, and could only happen if the files_rules is
2066 incomplete or buggy. */
2070 /* Look through to see if we've ever seen this output filename
2071 before. If found, cache the result in inpf. */
2072 for (r
= output_files
; r
; r
= r
->next
)
2073 if (strcmp (r
->name
, output_name
) == 0)
2076 DBGPRINTF ("found r @ %p for output_name %s for_name %s", (void*)r
,
2077 output_name
, for_name
);
2081 /* If not found, create it, and cache it in inpf. */
2082 r
= create_file (for_name
, output_name
);
2084 gcc_assert (r
&& r
->name
);
2085 DBGPRINTF ("created r @ %p for output_name %s for_name %s", (void*) r
,
2086 output_name
, for_name
);
2093 /* The name of an output file, suitable for definitions, that can see
2094 declarations made in INPF and is linked into every language that
2098 get_output_file_name (input_file
* inpf
)
2100 outf_p o
= get_output_file_with_visibility (inpf
);
2106 /* Check if existing file is equal to the in memory buffer. */
2109 is_file_equal (outf_p of
)
2111 FILE *newfile
= fopen (of
->name
, "r");
2114 if (newfile
== NULL
)
2118 for (i
= 0; i
< of
->bufused
; i
++)
2121 ch
= fgetc (newfile
);
2122 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
2132 /* Copy the output to its final destination,
2133 but don't unnecessarily change modification times. */
2136 close_output_files (void)
2138 int nbwrittenfiles
= 0;
2141 for (of
= output_files
; of
; of
= of
->next
)
2144 if (!is_file_equal (of
))
2146 FILE *newfile
= NULL
;
2147 char *backupname
= NULL
;
2148 /* Back up the old version of the output file gt-FOO.c as
2149 BACKUPDIR/gt-FOO.c~ if we have a backup directory. */
2152 backupname
= concat (backup_dir
, "/",
2153 lbasename (of
->name
), "~", NULL
);
2154 if (!access (of
->name
, F_OK
) && rename (of
->name
, backupname
))
2155 fatal ("failed to back up %s as %s: %s",
2156 of
->name
, backupname
, xstrerror (errno
));
2159 newfile
= fopen (of
->name
, "w");
2160 if (newfile
== NULL
)
2161 fatal ("opening output file %s: %s", of
->name
, xstrerror (errno
));
2162 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
2163 fatal ("writing output file %s: %s", of
->name
, xstrerror (errno
));
2164 if (fclose (newfile
) != 0)
2165 fatal ("closing output file %s: %s", of
->name
, xstrerror (errno
));
2167 if (verbosity_level
>= 2 && backupname
)
2168 printf ("%s wrote #%-3d %s backed-up in %s\n",
2169 progname
, nbwrittenfiles
, of
->name
, backupname
);
2170 else if (verbosity_level
>= 1)
2171 printf ("%s write #%-3d %s\n", progname
, nbwrittenfiles
, of
->name
);
2176 /* output file remains unchanged. */
2177 if (verbosity_level
>= 2)
2178 printf ("%s keep %s\n", progname
, of
->name
);
2182 of
->bufused
= of
->buflength
= 0;
2184 if (verbosity_level
>= 1)
2185 printf ("%s wrote %d files.\n", progname
, nbwrittenfiles
);
2192 const input_file
* file
;
2196 struct walk_type_data
;
2198 /* For scalars and strings, given the item in 'val'.
2199 For structures, given a pointer to the item in 'val'.
2200 For misc. pointers, given the item in 'val'.
2202 typedef void (*process_field_fn
) (type_p f
, const struct walk_type_data
* p
);
2203 typedef void (*func_name_fn
) (type_p s
, const struct walk_type_data
* p
);
2205 /* Parameters for write_types. */
2207 struct write_types_data
2210 const char *param_prefix
;
2211 const char *subfield_marker_routine
;
2212 const char *marker_routine
;
2213 const char *reorder_note_routine
;
2214 const char *comment
;
2215 int skip_hooks
; /* skip hook generation if non zero */
2218 static void output_escaped_param (struct walk_type_data
*d
,
2219 const char *, const char *);
2220 static void output_mangled_typename (outf_p
, const_type_p
);
2221 static void walk_type (type_p t
, struct walk_type_data
*d
);
2222 static void write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2223 const struct write_types_data
*wtd
);
2224 static void write_types_process_field
2225 (type_p f
, const struct walk_type_data
*d
);
2226 static void write_types (outf_p output_header
,
2228 type_p param_structs
,
2229 const struct write_types_data
*wtd
);
2230 static void write_types_local_process_field
2231 (type_p f
, const struct walk_type_data
*d
);
2232 static void write_local_func_for_structure
2233 (const_type_p orig_s
, type_p s
, type_p
*param
);
2234 static void write_local (outf_p output_header
,
2235 type_p structures
, type_p param_structs
);
2236 static void write_enum_defn (type_p structures
, type_p param_structs
);
2237 static int contains_scalar_p (type_p t
);
2238 static void put_mangled_filename (outf_p
, const input_file
*);
2239 static void finish_root_table (struct flist
*flp
, const char *pfx
,
2240 const char *tname
, const char *lastname
,
2242 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
2243 struct fileloc
*, const char *, bool);
2244 static void write_array (outf_p f
, pair_p v
,
2245 const struct write_types_data
*wtd
);
2246 static void write_roots (pair_p
, bool);
2248 /* Parameters for walk_type. */
2250 struct walk_type_data
2252 process_field_fn process_field
;
2257 const char *prev_val
[4];
2260 const struct fileloc
*line
;
2265 const char *reorder_fn
;
2267 bool fn_wants_lvalue
;
2270 /* Print a mangled name representing T to OF. */
2273 output_mangled_typename (outf_p of
, const_type_p t
)
2285 output_mangled_typename (of
, t
->u
.p
);
2295 case TYPE_LANG_STRUCT
:
2296 oprintf (of
, "%lu%s", (unsigned long) strlen (t
->u
.s
.tag
),
2299 case TYPE_PARAM_STRUCT
:
2302 for (i
= 0; i
< NUM_PARAM
; i
++)
2303 if (t
->u
.param_struct
.param
[i
] != NULL
)
2304 output_mangled_typename (of
, t
->u
.param_struct
.param
[i
]);
2305 output_mangled_typename (of
, t
->u
.param_struct
.stru
);
2313 /* Print PARAM to D->OF processing escapes. D->VAL references the
2314 current object, D->PREV_VAL the object containing the current
2315 object, ONAME is the name of the option and D->LINE is used to
2316 print error messages. */
2319 output_escaped_param (struct walk_type_data
*d
, const char *param
,
2324 for (p
= param
; *p
; p
++)
2326 oprintf (d
->of
, "%c", *p
);
2331 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
2334 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
2337 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
2341 const char *pp
= d
->val
+ strlen (d
->val
);
2342 while (pp
[-1] == ']')
2345 oprintf (d
->of
, "%s", pp
);
2349 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
2354 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2355 which is of type T. Write code to D->OF to constrain execution (at
2356 the point that D->PROCESS_FIELD is called) to the appropriate
2357 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2358 pointers to those objects. D->PREV_VAL lists the objects
2359 containing the current object, D->OPT is a list of options to
2360 apply, D->INDENT is the current indentation level, D->LINE is used
2361 to print error messages, D->BITMAP indicates which languages to
2362 print the structure for, and D->PARAM is the current parameter
2363 (from an enclosing param_is option). */
2366 walk_type (type_p t
, struct walk_type_data
*d
)
2368 const char *length
= NULL
;
2369 const char *desc
= NULL
;
2370 int maybe_undef_p
= 0;
2371 int use_param_num
= -1;
2372 int use_params_p
= 0;
2374 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
2376 d
->needs_cast_p
= false;
2377 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
2378 if (strcmp (oo
->name
, "length") == 0 && oo
->kind
== OPTION_STRING
)
2379 length
= oo
->info
.string
;
2380 else if (strcmp (oo
->name
, "maybe_undef") == 0)
2382 else if (strncmp (oo
->name
, "use_param", 9) == 0
2383 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2384 use_param_num
= oo
->name
[9] == '\0' ? 0 : oo
->name
[9] - '0';
2385 else if (strcmp (oo
->name
, "use_params") == 0)
2387 else if (strcmp (oo
->name
, "desc") == 0 && oo
->kind
== OPTION_STRING
)
2388 desc
= oo
->info
.string
;
2389 else if (strcmp (oo
->name
, "mark_hook") == 0)
2391 else if (strcmp (oo
->name
, "nested_ptr") == 0
2392 && oo
->kind
== OPTION_NESTED
)
2393 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
.nested
;
2394 else if (strcmp (oo
->name
, "dot") == 0)
2396 else if (strcmp (oo
->name
, "tag") == 0)
2398 else if (strcmp (oo
->name
, "special") == 0)
2400 else if (strcmp (oo
->name
, "skip") == 0)
2402 else if (strcmp (oo
->name
, "default") == 0)
2404 else if (strcmp (oo
->name
, "param_is") == 0)
2406 else if (strncmp (oo
->name
, "param", 5) == 0
2407 && ISDIGIT (oo
->name
[5]) && strcmp (oo
->name
+ 6, "_is") == 0)
2409 else if (strcmp (oo
->name
, "chain_next") == 0)
2411 else if (strcmp (oo
->name
, "chain_prev") == 0)
2413 else if (strcmp (oo
->name
, "chain_circular") == 0)
2415 else if (strcmp (oo
->name
, "reorder") == 0)
2417 else if (strcmp (oo
->name
, "variable_size") == 0)
2420 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
2427 int pointer_p
= t
->kind
== TYPE_POINTER
;
2431 if (!UNION_OR_STRUCT_P (t
))
2432 error_at_line (d
->line
, "`use_params' option on unimplemented type");
2434 t
= find_param_structure (t
, d
->param
);
2436 t
= create_pointer (t
);
2439 if (use_param_num
!= -1)
2441 if (d
->param
!= NULL
&& d
->param
[use_param_num
] != NULL
)
2443 type_p nt
= d
->param
[use_param_num
];
2445 if (t
->kind
== TYPE_ARRAY
)
2446 nt
= create_array (nt
, t
->u
.a
.len
);
2447 else if (length
!= NULL
&& t
->kind
== TYPE_POINTER
)
2448 nt
= create_pointer (nt
);
2449 d
->needs_cast_p
= (t
->kind
!= TYPE_POINTER
2450 && (nt
->kind
== TYPE_POINTER
2451 || nt
->kind
== TYPE_STRING
));
2455 error_at_line (d
->line
, "no parameter defined for `%s'", d
->val
);
2459 && (t
->kind
!= TYPE_POINTER
|| !UNION_OR_STRUCT_P (t
->u
.p
)))
2461 error_at_line (d
->line
,
2462 "field `%s' has invalid option `maybe_undef_p'\n",
2471 d
->process_field (t
, d
);
2476 if (maybe_undef_p
&& t
->u
.p
->u
.s
.line
.file
== NULL
)
2478 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2484 if (!UNION_OR_STRUCT_P (t
->u
.p
)
2485 && t
->u
.p
->kind
!= TYPE_PARAM_STRUCT
)
2487 error_at_line (d
->line
,
2488 "field `%s' is pointer to unimplemented type",
2495 const char *oldprevval2
= d
->prev_val
[2];
2497 if (!UNION_OR_STRUCT_P (nested_ptr_d
->type
))
2499 error_at_line (d
->line
,
2500 "field `%s' has invalid "
2501 "option `nested_ptr'\n", d
->val
);
2505 d
->prev_val
[2] = d
->val
;
2506 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2508 d
->val
= xasprintf ("x%d", d
->counter
++);
2509 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2510 (nested_ptr_d
->type
->kind
== TYPE_UNION
2511 ? "union" : "struct"),
2512 nested_ptr_d
->type
->u
.s
.tag
,
2513 d
->fn_wants_lvalue
? "" : "const ", d
->val
);
2514 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2515 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2517 oprintf (d
->of
, ";\n");
2519 d
->process_field (nested_ptr_d
->type
, d
);
2521 if (d
->fn_wants_lvalue
)
2523 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2525 d
->prev_val
[2] = d
->val
;
2526 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2528 oprintf (d
->of
, ";\n");
2532 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2533 d
->val
= d
->prev_val
[2];
2534 d
->prev_val
[2] = oldprevval2
;
2537 d
->process_field (t
->u
.p
, d
);
2541 int loopcounter
= d
->counter
++;
2542 const char *oldval
= d
->val
;
2543 const char *oldprevval3
= d
->prev_val
[3];
2546 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2548 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2549 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
,
2550 "", loopcounter
, loopcounter
);
2551 output_escaped_param (d
, length
, "length");
2552 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2554 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2556 d
->prev_val
[3] = oldval
;
2557 walk_type (t
->u
.p
, d
);
2560 d
->prev_val
[3] = oldprevval3
;
2563 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2564 d
->process_field (t
, d
);
2566 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2573 int loopcounter
= d
->counter
++;
2574 const char *oldval
= d
->val
;
2577 /* If it's an array of scalars, we optimize by not generating
2579 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2582 /* When walking an array, compute the length and store it in a
2583 local variable before walking the array elements, instead of
2584 recomputing the length expression each time through the loop.
2585 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2586 where the length is stored in the first array element,
2587 because otherwise that operand can get overwritten on the
2589 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2591 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2592 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2593 d
->indent
, "", loopcounter
);
2595 output_escaped_param (d
, length
, "length");
2597 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2598 oprintf (d
->of
, ");\n");
2600 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2602 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2604 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2606 walk_type (t
->u
.a
.p
, d
);
2611 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2613 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2621 const char *oldval
= d
->val
;
2622 const char *oldprevval1
= d
->prev_val
[1];
2623 const char *oldprevval2
= d
->prev_val
[2];
2624 const int union_p
= t
->kind
== TYPE_UNION
;
2625 int seen_default_p
= 0;
2628 if (!t
->u
.s
.line
.file
)
2629 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2631 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2633 error_at_line (d
->line
,
2634 "structure `%s' defined for mismatching languages",
2636 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2639 /* Some things may also be defined in the structure's options. */
2640 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2641 if (!desc
&& strcmp (o
->name
, "desc") == 0
2642 && o
->kind
== OPTION_STRING
)
2643 desc
= o
->info
.string
;
2645 d
->prev_val
[2] = oldval
;
2646 d
->prev_val
[1] = oldprevval2
;
2651 error_at_line (d
->line
,
2652 "missing `desc' option for union `%s'",
2656 oprintf (d
->of
, "%*sswitch (", d
->indent
, "");
2657 output_escaped_param (d
, desc
, "desc");
2658 oprintf (d
->of
, ")\n");
2660 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2662 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
2665 const char *dot
= ".";
2666 const char *tagid
= NULL
;
2669 int use_param_p
= 0;
2672 d
->reorder_fn
= NULL
;
2673 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2674 if (strcmp (oo
->name
, "dot") == 0
2675 && oo
->kind
== OPTION_STRING
)
2676 dot
= oo
->info
.string
;
2677 else if (strcmp (oo
->name
, "tag") == 0
2678 && oo
->kind
== OPTION_STRING
)
2679 tagid
= oo
->info
.string
;
2680 else if (strcmp (oo
->name
, "skip") == 0)
2682 else if (strcmp (oo
->name
, "default") == 0)
2684 else if (strcmp (oo
->name
, "reorder") == 0
2685 && oo
->kind
== OPTION_STRING
)
2686 d
->reorder_fn
= oo
->info
.string
;
2687 else if (strncmp (oo
->name
, "use_param", 9) == 0
2688 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2694 if (union_p
&& tagid
)
2696 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
2699 else if (union_p
&& default_p
)
2701 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2705 else if (!union_p
&& (default_p
|| tagid
))
2706 error_at_line (d
->line
,
2707 "can't use `%s' outside a union on field `%s'",
2708 default_p
? "default" : "tag", f
->name
);
2709 else if (union_p
&& !(default_p
|| tagid
)
2710 && f
->type
->kind
== TYPE_SCALAR
)
2713 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2714 get_input_file_name (d
->line
->file
), d
->line
->line
,
2718 else if (union_p
&& !(default_p
|| tagid
))
2719 error_at_line (d
->line
,
2720 "field `%s' is missing `tag' or `default' option",
2724 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
2726 d
->used_length
= false;
2728 if (union_p
&& use_param_p
&& d
->param
== NULL
)
2729 oprintf (d
->of
, "%*sgcc_unreachable ();\n", d
->indent
, "");
2731 walk_type (f
->type
, d
);
2737 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2741 d
->reorder_fn
= NULL
;
2744 d
->prev_val
[1] = oldprevval1
;
2745 d
->prev_val
[2] = oldprevval2
;
2747 if (union_p
&& !seen_default_p
)
2749 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2750 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
2754 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2760 case TYPE_LANG_STRUCT
:
2763 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
2764 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
2767 error_at_line (d
->line
, "structure `%s' differs between languages",
2774 case TYPE_PARAM_STRUCT
:
2776 type_p
*oldparam
= d
->param
;
2778 d
->param
= t
->u
.param_struct
.param
;
2779 walk_type (t
->u
.param_struct
.stru
, d
);
2780 d
->param
= oldparam
;
2789 /* process_field routine for marking routines. */
2792 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
2794 const struct write_types_data
*wtd
;
2795 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
2796 wtd
= (const struct write_types_data
*) d
->cookie
;
2803 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
2804 wtd
->subfield_marker_routine
, cast
, d
->val
);
2805 if (wtd
->param_prefix
)
2807 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
2810 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
2811 output_mangled_typename (d
->of
, d
->orig_s
);
2814 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
2816 if (f
->u
.p
->kind
== TYPE_PARAM_STRUCT
2817 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2819 oprintf (d
->of
, ", gt_e_");
2820 output_mangled_typename (d
->of
, f
);
2822 else if (UNION_OR_STRUCT_P (f
) && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2824 oprintf (d
->of
, ", gt_ggc_e_");
2825 output_mangled_typename (d
->of
, f
);
2828 oprintf (d
->of
, ", gt_types_enum_last");
2830 oprintf (d
->of
, ");\n");
2831 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2832 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
2833 wtd
->reorder_note_routine
, cast
, d
->val
,
2834 d
->prev_val
[3], d
->reorder_fn
);
2840 case TYPE_LANG_STRUCT
:
2841 case TYPE_PARAM_STRUCT
:
2842 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
2843 output_mangled_typename (d
->of
, f
);
2844 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
2845 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2846 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
2847 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
2859 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2862 output_type_enum (outf_p of
, type_p s
)
2864 if (s
->kind
== TYPE_PARAM_STRUCT
&& s
->u
.param_struct
.line
.file
!= NULL
)
2866 oprintf (of
, ", gt_e_");
2867 output_mangled_typename (of
, s
);
2869 else if (UNION_OR_STRUCT_P (s
) && s
->u
.s
.line
.file
!= NULL
)
2871 oprintf (of
, ", gt_ggc_e_");
2872 output_mangled_typename (of
, s
);
2875 oprintf (of
, ", gt_types_enum_last");
2878 /* Return an output file that is suitable for definitions which can
2879 reference struct S */
2882 get_output_file_for_structure (const_type_p s
, type_p
*param
)
2884 const input_file
*fn
;
2887 gcc_assert (UNION_OR_STRUCT_P (s
));
2888 fn
= s
->u
.s
.line
.file
;
2890 /* This is a hack, and not the good kind either. */
2891 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2892 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2893 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2894 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2896 /* The call to get_output_file_with_visibility may update fn by
2897 caching its result inside, so we need the CONST_CAST. */
2898 return get_output_file_with_visibility (CONST_CAST (input_file
*, fn
));
2901 /* For S, a structure that's part of ORIG_S, and using parameters
2902 PARAM, write out a routine that:
2903 - Takes a parameter, a void * but actually of type *S
2904 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2905 field of S or its substructures and (in some cases) things
2906 that are pointed to by S.
2910 write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2911 const struct write_types_data
*wtd
)
2913 const char *chain_next
= NULL
;
2914 const char *chain_prev
= NULL
;
2915 const char *chain_circular
= NULL
;
2916 const char *mark_hook_name
= NULL
;
2918 struct walk_type_data d
;
2920 memset (&d
, 0, sizeof (d
));
2921 d
.of
= get_output_file_for_structure (s
, param
);
2922 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2923 if (strcmp (opt
->name
, "chain_next") == 0
2924 && opt
->kind
== OPTION_STRING
)
2925 chain_next
= opt
->info
.string
;
2926 else if (strcmp (opt
->name
, "chain_prev") == 0
2927 && opt
->kind
== OPTION_STRING
)
2928 chain_prev
= opt
->info
.string
;
2929 else if (strcmp (opt
->name
, "chain_circular") == 0
2930 && opt
->kind
== OPTION_STRING
)
2931 chain_circular
= opt
->info
.string
;
2932 else if (strcmp (opt
->name
, "mark_hook") == 0
2933 && opt
->kind
== OPTION_STRING
)
2934 mark_hook_name
= opt
->info
.string
;
2935 if (chain_prev
!= NULL
&& chain_next
== NULL
)
2936 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
2937 if (chain_circular
!= NULL
&& chain_next
!= NULL
)
2938 error_at_line (&s
->u
.s
.line
, "chain_circular with chain_next");
2939 if (chain_circular
!= NULL
)
2940 chain_next
= chain_circular
;
2942 d
.process_field
= write_types_process_field
;
2946 d
.line
= &s
->u
.s
.line
;
2947 d
.bitmap
= s
->u
.s
.bitmap
;
2949 d
.prev_val
[0] = "*x";
2950 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2951 d
.prev_val
[3] = "x";
2954 oprintf (d
.of
, "\n");
2955 oprintf (d
.of
, "void\n");
2957 oprintf (d
.of
, "gt_%sx_%s", wtd
->prefix
, orig_s
->u
.s
.tag
);
2960 oprintf (d
.of
, "gt_%s_", wtd
->prefix
);
2961 output_mangled_typename (d
.of
, orig_s
);
2963 oprintf (d
.of
, " (void *x_p)\n");
2964 oprintf (d
.of
, "{\n");
2965 oprintf (d
.of
, " %s %s * %sx = (%s %s *)x_p;\n",
2966 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2967 chain_next
== NULL
? "const " : "",
2968 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2969 if (chain_next
!= NULL
)
2970 oprintf (d
.of
, " %s %s * xlimit = x;\n",
2971 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2972 if (chain_next
== NULL
)
2974 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
2975 if (wtd
->param_prefix
)
2977 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
2978 output_mangled_typename (d
.of
, orig_s
);
2979 output_type_enum (d
.of
, orig_s
);
2981 oprintf (d
.of
, "))\n");
2985 if (chain_circular
!= NULL
)
2986 oprintf (d
.of
, " if (!%s (xlimit", wtd
->marker_routine
);
2988 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2989 if (wtd
->param_prefix
)
2991 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2992 output_mangled_typename (d
.of
, orig_s
);
2993 output_type_enum (d
.of
, orig_s
);
2995 oprintf (d
.of
, "))\n");
2996 if (chain_circular
!= NULL
)
2997 oprintf (d
.of
, " return;\n do\n");
2998 if (mark_hook_name
&& !wtd
->skip_hooks
)
3000 oprintf (d
.of
, " {\n");
3001 oprintf (d
.of
, " %s (xlimit);\n ", mark_hook_name
);
3003 oprintf (d
.of
, " xlimit = (");
3004 d
.prev_val
[2] = "*xlimit";
3005 output_escaped_param (&d
, chain_next
, "chain_next");
3006 oprintf (d
.of
, ");\n");
3007 if (mark_hook_name
&& !wtd
->skip_hooks
)
3008 oprintf (d
.of
, " }\n");
3009 if (chain_prev
!= NULL
)
3011 oprintf (d
.of
, " if (x != xlimit)\n");
3012 oprintf (d
.of
, " for (;;)\n");
3013 oprintf (d
.of
, " {\n");
3014 oprintf (d
.of
, " %s %s * const xprev = (",
3015 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
3017 d
.prev_val
[2] = "*x";
3018 output_escaped_param (&d
, chain_prev
, "chain_prev");
3019 oprintf (d
.of
, ");\n");
3020 oprintf (d
.of
, " if (xprev == NULL) break;\n");
3021 oprintf (d
.of
, " x = xprev;\n");
3022 oprintf (d
.of
, " (void) %s (xprev", wtd
->marker_routine
);
3023 if (wtd
->param_prefix
)
3025 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
3026 output_mangled_typename (d
.of
, orig_s
);
3027 output_type_enum (d
.of
, orig_s
);
3029 oprintf (d
.of
, ");\n");
3030 oprintf (d
.of
, " }\n");
3032 if (chain_circular
!= NULL
)
3034 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
3035 if (wtd
->param_prefix
)
3037 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
3038 output_mangled_typename (d
.of
, orig_s
);
3039 output_type_enum (d
.of
, orig_s
);
3041 oprintf (d
.of
, "));\n");
3042 if (mark_hook_name
&& !wtd
->skip_hooks
)
3043 oprintf (d
.of
, " %s (xlimit);\n", mark_hook_name
);
3044 oprintf (d
.of
, " do\n");
3047 oprintf (d
.of
, " while (x != xlimit)\n");
3049 oprintf (d
.of
, " {\n");
3050 if (mark_hook_name
&& chain_next
== NULL
&& !wtd
->skip_hooks
)
3052 oprintf (d
.of
, " %s (x);\n", mark_hook_name
);
3054 d
.prev_val
[2] = "*x";
3058 if (chain_next
!= NULL
)
3060 oprintf (d
.of
, " x = (");
3061 output_escaped_param (&d
, chain_next
, "chain_next");
3062 oprintf (d
.of
, ");\n");
3065 oprintf (d
.of
, " }\n");
3066 if (chain_circular
!= NULL
)
3067 oprintf (d
.of
, " while (x != xlimit);\n");
3068 oprintf (d
.of
, "}\n");
3071 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
3074 write_types (outf_p output_header
, type_p structures
, type_p param_structs
,
3075 const struct write_types_data
*wtd
)
3077 int nbfun
= 0; /* Count the emitted functions. */
3080 oprintf (output_header
, "\n/* %s*/\n", wtd
->comment
);
3081 /* We first emit the macros and the declarations. Functions' code is
3082 emitted afterwards. This is needed in plugin mode. */
3083 oprintf (output_header
, "/* macros and declarations */\n");
3084 for (s
= structures
; s
; s
= s
->next
)
3085 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3089 if (s
->gc_used
== GC_MAYBE_POINTED_TO
&& s
->u
.s
.line
.file
== NULL
)
3092 oprintf (output_header
, "#define gt_%s_", wtd
->prefix
);
3093 output_mangled_typename (output_header
, s
);
3094 oprintf (output_header
, "(X) do { \\\n");
3095 oprintf (output_header
,
3096 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
3098 oprintf (output_header
, " } while (0)\n");
3100 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3101 if (strcmp (opt
->name
, "ptr_alias") == 0
3102 && opt
->kind
== OPTION_TYPE
)
3104 const_type_p
const t
= (const_type_p
) opt
->info
.type
;
3105 if (t
->kind
== TYPE_STRUCT
3106 || t
->kind
== TYPE_UNION
|| t
->kind
== TYPE_LANG_STRUCT
)
3107 oprintf (output_header
,
3108 "#define gt_%sx_%s gt_%sx_%s\n",
3109 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t
->u
.s
.tag
);
3111 error_at_line (&s
->u
.s
.line
,
3112 "structure alias is not a structure");
3118 /* Declare the marker procedure only once. */
3119 oprintf (output_header
,
3120 "extern void gt_%sx_%s (void *);\n",
3121 wtd
->prefix
, s
->u
.s
.tag
);
3123 if (s
->u
.s
.line
.file
== NULL
)
3125 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3131 for (s
= param_structs
; s
; s
= s
->next
)
3132 if (s
->gc_used
== GC_POINTED_TO
)
3134 type_p stru
= s
->u
.param_struct
.stru
;
3136 /* Declare the marker procedure. */
3137 oprintf (output_header
, "extern void gt_%s_", wtd
->prefix
);
3138 output_mangled_typename (output_header
, s
);
3139 oprintf (output_header
, " (void *);\n");
3141 if (stru
->u
.s
.line
.file
== NULL
)
3143 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3149 /* At last we emit the functions code. */
3150 oprintf (output_header
, "\n/* functions code */\n");
3151 for (s
= structures
; s
; s
= s
->next
)
3152 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3156 if (s
->gc_used
== GC_MAYBE_POINTED_TO
&& s
->u
.s
.line
.file
== NULL
)
3158 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3159 if (strcmp (opt
->name
, "ptr_alias") == 0)
3164 if (s
->kind
== TYPE_LANG_STRUCT
)
3167 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3170 DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'",
3171 nbfun
, (void*) ss
, ss
->u
.s
.tag
);
3172 write_func_for_structure (s
, ss
, NULL
, wtd
);
3178 DBGPRINTF ("writing func #%d struct s @ %p '%s'",
3179 nbfun
, (void*) s
, s
->u
.s
.tag
);
3180 write_func_for_structure (s
, s
, NULL
, wtd
);
3185 /* Structure s is not possibly pointed to, so can be ignored. */
3186 DBGPRINTF ("ignored s @ %p '%s' gc_used#%d",
3187 (void*)s
, s
->u
.s
.tag
,
3191 for (s
= param_structs
; s
; s
= s
->next
)
3192 if (s
->gc_used
== GC_POINTED_TO
)
3194 type_p
*param
= s
->u
.param_struct
.param
;
3195 type_p stru
= s
->u
.param_struct
.stru
;
3196 if (stru
->u
.s
.line
.file
== NULL
)
3198 if (stru
->kind
== TYPE_LANG_STRUCT
)
3201 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3204 DBGPRINTF ("writing func #%d param lang_struct ss @ %p '%s'",
3205 nbfun
, (void*) ss
, ss
->u
.s
.tag
);
3206 write_func_for_structure (s
, ss
, param
, wtd
);
3212 DBGPRINTF ("writing func #%d param struct s @ %p stru @ %p '%s'",
3214 (void*) stru
, stru
->u
.s
.tag
);
3215 write_func_for_structure (s
, stru
, param
, wtd
);
3220 /* Param structure s is not pointed to, so should be ignored. */
3221 DBGPRINTF ("ignored s @ %p", (void*)s
);
3223 if (verbosity_level
>= 2)
3224 printf ("%s emitted %d routines for %s\n",
3225 progname
, nbfun
, wtd
->comment
);
3228 static const struct write_types_data ggc_wtd
= {
3229 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
3230 "GC marker procedures. ",
3234 static const struct write_types_data pch_wtd
= {
3235 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
3236 "gt_pch_note_reorder",
3237 "PCH type-walking procedures. ",
3241 /* Write out the local pointer-walking routines. */
3243 /* process_field routine for local pointer-walking. */
3246 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
3253 case TYPE_LANG_STRUCT
:
3254 case TYPE_PARAM_STRUCT
:
3256 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
3258 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
3269 /* For S, a structure that's part of ORIG_S, and using parameters
3270 PARAM, write out a routine that:
3271 - Is of type gt_note_pointers
3272 - Calls PROCESS_FIELD on each field of S or its substructures.
3276 write_local_func_for_structure (const_type_p orig_s
, type_p s
, type_p
*param
)
3278 struct walk_type_data d
;
3280 memset (&d
, 0, sizeof (d
));
3281 d
.of
= get_output_file_for_structure (s
, param
);
3282 d
.process_field
= write_types_local_process_field
;
3284 d
.line
= &s
->u
.s
.line
;
3285 d
.bitmap
= s
->u
.s
.bitmap
;
3287 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
3288 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
3289 d
.prev_val
[3] = "x";
3291 d
.fn_wants_lvalue
= true;
3293 oprintf (d
.of
, "\n");
3294 oprintf (d
.of
, "void\n");
3295 oprintf (d
.of
, "gt_pch_p_");
3296 output_mangled_typename (d
.of
, orig_s
);
3297 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
3299 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3300 "\tATTRIBUTE_UNUSED void *cookie)\n");
3301 oprintf (d
.of
, "{\n");
3302 oprintf (d
.of
, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
3303 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
3304 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
3307 oprintf (d
.of
, "}\n");
3310 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
3313 write_local (outf_p output_header
, type_p structures
, type_p param_structs
)
3319 oprintf (output_header
, "\n/* Local pointer-walking routines. */\n");
3320 for (s
= structures
; s
; s
= s
->next
)
3321 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3325 if (s
->u
.s
.line
.file
== NULL
)
3327 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3328 if (strcmp (opt
->name
, "ptr_alias") == 0
3329 && opt
->kind
== OPTION_TYPE
)
3331 const_type_p
const t
= (const_type_p
) opt
->info
.type
;
3332 if (t
->kind
== TYPE_STRUCT
3333 || t
->kind
== TYPE_UNION
|| t
->kind
== TYPE_LANG_STRUCT
)
3335 oprintf (output_header
, "#define gt_pch_p_");
3336 output_mangled_typename (output_header
, s
);
3337 oprintf (output_header
, " gt_pch_p_");
3338 output_mangled_typename (output_header
, t
);
3339 oprintf (output_header
, "\n");
3342 error_at_line (&s
->u
.s
.line
,
3343 "structure alias is not a structure");
3349 /* Declare the marker procedure only once. */
3350 oprintf (output_header
, "extern void gt_pch_p_");
3351 output_mangled_typename (output_header
, s
);
3352 oprintf (output_header
,
3353 "\n (void *, void *, gt_pointer_operator, void *);\n");
3355 if (s
->kind
== TYPE_LANG_STRUCT
)
3358 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3359 write_local_func_for_structure (s
, ss
, NULL
);
3362 write_local_func_for_structure (s
, s
, NULL
);
3365 for (s
= param_structs
; s
; s
= s
->next
)
3366 if (s
->gc_used
== GC_POINTED_TO
)
3368 type_p
*param
= s
->u
.param_struct
.param
;
3369 type_p stru
= s
->u
.param_struct
.stru
;
3371 /* Declare the marker procedure. */
3372 oprintf (output_header
, "extern void gt_pch_p_");
3373 output_mangled_typename (output_header
, s
);
3374 oprintf (output_header
,
3375 "\n (void *, void *, gt_pointer_operator, void *);\n");
3377 if (stru
->u
.s
.line
.file
== NULL
)
3379 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3384 if (stru
->kind
== TYPE_LANG_STRUCT
)
3387 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3388 write_local_func_for_structure (s
, ss
, param
);
3391 write_local_func_for_structure (s
, stru
, param
);
3395 /* Nonzero if S is a type for which typed GC allocators should be output. */
3397 #define USED_BY_TYPED_GC_P(s) \
3398 (((s->kind == TYPE_POINTER) \
3399 && ((s->u.p->gc_used == GC_POINTED_TO) \
3400 || (s->u.p->gc_used == GC_USED))) \
3401 || (UNION_OR_STRUCT_P (s) && \
3402 (((s)->gc_used == GC_POINTED_TO) \
3403 || ((s)->gc_used == GC_MAYBE_POINTED_TO \
3404 && s->u.s.line.file != NULL) \
3405 || ((s)->gc_used == GC_USED \
3406 && strncmp (s->u.s.tag, "anonymous", strlen ("anonymous"))))))
3409 /* Write out the 'enum' definition for gt_types_enum. */
3412 write_enum_defn (type_p structures
, type_p param_structs
)
3416 int nbparamstruct
= 0;
3420 oprintf (header_file
, "\n/* Enumeration of types known. */\n");
3421 oprintf (header_file
, "enum gt_types_enum {\n");
3422 for (s
= structures
; s
; s
= s
->next
)
3423 if (USED_BY_TYPED_GC_P (s
))
3426 DBGPRINTF ("write_enum_defn s @ %p nbstruct %d",
3427 (void*) s
, nbstruct
);
3428 if (UNION_OR_STRUCT_P (s
))
3429 DBGPRINTF ("write_enum_defn s %p #%d is unionorstruct tagged %s",
3430 (void*) s
, nbstruct
, s
->u
.s
.tag
);
3431 oprintf (header_file
, " gt_ggc_e_");
3432 output_mangled_typename (header_file
, s
);
3433 oprintf (header_file
, ",\n");
3435 for (s
= param_structs
; s
; s
= s
->next
)
3436 if (s
->gc_used
== GC_POINTED_TO
)
3439 DBGPRINTF ("write_enum_defn s %p nbparamstruct %d",
3440 (void*) s
, nbparamstruct
);
3441 oprintf (header_file
, " gt_e_");
3442 output_mangled_typename (header_file
, s
);
3443 oprintf (header_file
, ",\n");
3445 oprintf (header_file
, " gt_types_enum_last\n");
3446 oprintf (header_file
, "};\n");
3447 if (verbosity_level
>= 2)
3448 printf ("%s handled %d GTY-ed structures & %d parameterized structures.\n",
3449 progname
, nbstruct
, nbparamstruct
);
3453 /* Might T contain any non-pointer elements? */
3456 contains_scalar_p (type_p t
)
3464 return contains_scalar_p (t
->u
.a
.p
);
3466 /* Could also check for structures that have no non-pointer
3467 fields, but there aren't enough of those to worry about. */
3472 /* Mangle INPF and print it to F. */
3475 put_mangled_filename (outf_p f
, const input_file
*inpf
)
3477 /* The call to get_output_file_name may indirectly update fn since
3478 get_output_file_with_visibility caches its result inside, so we
3479 need the CONST_CAST. */
3480 const char *name
= get_output_file_name (CONST_CAST (input_file
*, inpf
));
3483 for (; *name
!= 0; name
++)
3484 if (ISALNUM (*name
))
3485 oprintf (f
, "%c", *name
);
3487 oprintf (f
, "%c", '_');
3490 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
3491 LASTNAME, and NAME are all strings to insert in various places in
3492 the resulting code. */
3495 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
3496 const char *tname
, const char *name
)
3500 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3501 if (fli2
->started_p
)
3503 oprintf (fli2
->f
, " %s\n", lastname
);
3504 oprintf (fli2
->f
, "};\n\n");
3507 for (fli2
= flp
; fli2
&& base_files
; fli2
= fli2
->next
)
3508 if (fli2
->started_p
)
3510 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
3513 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
3516 oprintf (base_files
[fnum
],
3517 "extern const struct %s gt_%s_", tname
, pfx
);
3518 put_mangled_filename (base_files
[fnum
], fli2
->file
);
3519 oprintf (base_files
[fnum
], "[];\n");
3525 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3526 oprintf (base_files
[fnum
],
3527 "EXPORTED_CONST struct %s * const %s[] = {\n", tname
, name
);
3531 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3532 if (fli2
->started_p
)
3534 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
3537 fli2
->started_p
= 0;
3539 for (fnum
= 0; base_files
&& bitmap
!= 0; fnum
++, bitmap
>>= 1)
3542 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
3543 put_mangled_filename (base_files
[fnum
], fli2
->file
);
3544 oprintf (base_files
[fnum
], ",\n");
3550 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3552 oprintf (base_files
[fnum
], " NULL\n");
3553 oprintf (base_files
[fnum
], "};\n");
3558 /* Write the first three fields (pointer, count and stride) for
3559 root NAME to F. V and LINE are as for write_root.
3561 Return true if the entry could be written; return false on error. */
3564 start_root_entry (outf_p f
, pair_p v
, const char *name
, struct fileloc
*line
)
3570 error_at_line (line
, "`%s' is too complex to be a root", name
);
3574 oprintf (f
, " {\n");
3575 oprintf (f
, " &%s,\n", name
);
3578 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3580 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
3581 else if (ap
== v
->type
)
3582 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
3584 oprintf (f
, " sizeof (%s", v
->name
);
3585 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3587 oprintf (f
, "),\n");
3591 /* A subroutine of write_root for writing the roots for field FIELD_NAME,
3592 which has type FIELD_TYPE. Parameters F to EMIT_PCH are the parameters
3596 write_field_root (outf_p f
, pair_p v
, type_p type
, const char *name
,
3597 int has_length
, struct fileloc
*line
, const char *if_marked
,
3598 bool emit_pch
, type_p field_type
, const char *field_name
)
3600 /* If the field reference is relative to V, rather than to some
3601 subcomponent of V, we can mark any subarrays with a single stride.
3602 We're effectively treating the field as a global variable in its
3604 if (v
&& type
== v
->type
)
3609 newv
.type
= field_type
;
3610 newv
.name
= ACONCAT ((v
->name
, ".", field_name
, NULL
));
3613 /* Otherwise, any arrays nested in the structure are too complex to
3615 else if (field_type
->kind
== TYPE_ARRAY
)
3617 write_root (f
, v
, field_type
, ACONCAT ((name
, ".", field_name
, NULL
)),
3618 has_length
, line
, if_marked
, emit_pch
);
3621 /* Write out to F the table entry and any marker routines needed to
3622 mark NAME as TYPE. V can be one of three values:
3624 - null, if NAME is too complex to represent using a single
3625 count and stride. In this case, it is an error for NAME to
3626 contain any gc-ed data.
3628 - the outermost array that contains NAME, if NAME is part of an array.
3630 - the C variable that contains NAME, if NAME is not part of an array.
3632 LINE is the line of the C source that declares the root variable.
3633 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
3634 is nonzero iff we are building the root table for hash table caches. */
3637 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
3638 struct fileloc
*line
, const char *if_marked
, bool emit_pch
)
3645 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
3648 const char *desc
= NULL
;
3651 for (o
= fld
->opt
; o
; o
= o
->next
)
3652 if (strcmp (o
->name
, "skip") == 0)
3654 else if (strcmp (o
->name
, "desc") == 0
3655 && o
->kind
== OPTION_STRING
)
3656 desc
= o
->info
.string
;
3657 else if (strcmp (o
->name
, "param_is") == 0)
3660 error_at_line (line
,
3661 "field `%s' of global `%s' has unknown option `%s'",
3662 fld
->name
, name
, o
->name
);
3666 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
3668 pair_p validf
= NULL
;
3671 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
3673 const char *tag
= NULL
;
3675 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
3676 if (strcmp (oo
->name
, "tag") == 0
3677 && oo
->kind
== OPTION_STRING
)
3678 tag
= oo
->info
.string
;
3679 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
3682 error_at_line (line
,
3683 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3684 name
, fld
->name
, validf
->name
,
3685 name
, fld
->name
, ufld
->name
, tag
);
3689 write_field_root (f
, v
, type
, name
, 0, line
, if_marked
,
3690 emit_pch
, validf
->type
,
3691 ACONCAT ((fld
->name
, ".",
3692 validf
->name
, NULL
)));
3695 error_at_line (line
,
3696 "global `%s.%s' has `desc' option but is not union",
3699 write_field_root (f
, v
, type
, name
, 0, line
, if_marked
,
3700 emit_pch
, fld
->type
, fld
->name
);
3708 newname
= xasprintf ("%s[0]", name
);
3709 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, if_marked
,
3719 if (!start_root_entry (f
, v
, name
, line
))
3724 if (!has_length
&& UNION_OR_STRUCT_P (tp
))
3726 oprintf (f
, " >_ggc_mx_%s,\n", tp
->u
.s
.tag
);
3728 oprintf (f
, " >_pch_nx_%s", tp
->u
.s
.tag
);
3730 oprintf (f
, " NULL");
3732 else if (!has_length
&& tp
->kind
== TYPE_PARAM_STRUCT
)
3734 oprintf (f
, " >_ggc_m_");
3735 output_mangled_typename (f
, tp
);
3738 oprintf (f
, ",\n >_pch_n_");
3739 output_mangled_typename (f
, tp
);
3742 oprintf (f
, ",\n NULL");
3745 && (tp
->kind
== TYPE_POINTER
|| UNION_OR_STRUCT_P (tp
)))
3747 oprintf (f
, " >_ggc_ma_%s,\n", name
);
3749 oprintf (f
, " >_pch_na_%s", name
);
3751 oprintf (f
, " NULL");
3755 error_at_line (line
,
3756 "global `%s' is pointer to unimplemented type",
3760 oprintf (f
, ",\n &%s", if_marked
);
3761 oprintf (f
, "\n },\n");
3767 if (!start_root_entry (f
, v
, name
, line
))
3770 oprintf (f
, " (gt_pointer_walker) >_ggc_m_S,\n");
3771 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
3772 oprintf (f
, " },\n");
3780 error_at_line (line
, "global `%s' is unimplemented type", name
);
3784 /* This generates a routine to walk an array. */
3787 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
3789 struct walk_type_data d
;
3792 memset (&d
, 0, sizeof (d
));
3798 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
3801 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
3803 if (wtd
->param_prefix
)
3805 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
3806 oprintf (f
, " (void *, void *, gt_pointer_operator, void *);\n");
3807 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3808 wtd
->param_prefix
, v
->name
);
3810 " ATTRIBUTE_UNUSED void *x_p,\n"
3811 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3812 " ATTRIBUTE_UNUSED void * cookie)\n");
3813 oprintf (d
.of
, "{\n");
3814 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3815 d
.process_field
= write_types_local_process_field
;
3816 walk_type (v
->type
, &d
);
3817 oprintf (f
, "}\n\n");
3821 oprintf (f
, "static void gt_%sa_%s (void *);\n", wtd
->prefix
, v
->name
);
3822 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3823 wtd
->prefix
, v
->name
);
3825 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3826 d
.process_field
= write_types_process_field
;
3827 walk_type (v
->type
, &d
);
3829 oprintf (f
, "}\n\n");
3832 /* Output a table describing the locations and types of VARIABLES. */
3835 write_roots (pair_p variables
, bool emit_pch
)
3838 struct flist
*flp
= NULL
;
3840 for (v
= variables
; v
; v
= v
->next
)
3843 get_output_file_with_visibility (CONST_CAST (input_file
*,
3846 const char *length
= NULL
;
3847 int deletable_p
= 0;
3849 for (o
= v
->opt
; o
; o
= o
->next
)
3850 if (strcmp (o
->name
, "length") == 0
3851 && o
->kind
== OPTION_STRING
)
3852 length
= o
->info
.string
;
3853 else if (strcmp (o
->name
, "deletable") == 0)
3855 else if (strcmp (o
->name
, "param_is") == 0)
3857 else if (strncmp (o
->name
, "param", 5) == 0
3858 && ISDIGIT (o
->name
[5]) && strcmp (o
->name
+ 6, "_is") == 0)
3860 else if (strcmp (o
->name
, "if_marked") == 0)
3863 error_at_line (&v
->line
,
3864 "global `%s' has unknown option `%s'",
3867 for (fli
= flp
; fli
; fli
= fli
->next
)
3868 if (fli
->f
== f
&& f
)
3872 fli
= XNEW (struct flist
);
3876 fli
->file
= v
->line
.file
;
3877 gcc_assert (fli
->file
);
3880 oprintf (f
, "\n/* GC roots. */\n\n");
3885 && v
->type
->kind
== TYPE_POINTER
3886 && (v
->type
->u
.p
->kind
== TYPE_POINTER
3887 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
3889 write_array (f
, v
, &ggc_wtd
);
3890 write_array (f
, v
, &pch_wtd
);
3894 for (v
= variables
; v
; v
= v
->next
)
3896 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
3903 for (o
= v
->opt
; o
; o
= o
->next
)
3904 if (strcmp (o
->name
, "length") == 0)
3906 else if (strcmp (o
->name
, "deletable") == 0
3907 || strcmp (o
->name
, "if_marked") == 0)
3913 for (fli
= flp
; fli
; fli
= fli
->next
)
3916 if (!fli
->started_p
)
3920 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3921 put_mangled_filename (f
, v
->line
.file
);
3922 oprintf (f
, "[] = {\n");
3925 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
, emit_pch
);
3928 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3931 for (v
= variables
; v
; v
= v
->next
)
3933 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
3939 for (o
= v
->opt
; o
; o
= o
->next
)
3940 if (strcmp (o
->name
, "deletable") == 0)
3942 else if (strcmp (o
->name
, "if_marked") == 0)
3948 for (fli
= flp
; fli
; fli
= fli
->next
)
3951 if (!fli
->started_p
)
3955 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3956 put_mangled_filename (f
, v
->line
.file
);
3957 oprintf (f
, "[] = {\n");
3960 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3964 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3965 "gt_ggc_deletable_rtab");
3967 for (v
= variables
; v
; v
= v
->next
)
3969 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
3972 const char *if_marked
= NULL
;
3976 for (o
= v
->opt
; o
; o
= o
->next
)
3977 if (strcmp (o
->name
, "length") == 0)
3979 else if (strcmp (o
->name
, "if_marked") == 0
3980 && o
->kind
== OPTION_STRING
)
3981 if_marked
= o
->info
.string
;
3982 if (if_marked
== NULL
)
3984 if (v
->type
->kind
!= TYPE_POINTER
3985 || v
->type
->u
.p
->kind
!= TYPE_PARAM_STRUCT
3986 || v
->type
->u
.p
->u
.param_struct
.stru
!= find_structure ("htab", 0))
3988 error_at_line (&v
->line
,
3989 "if_marked option used but not hash table");
3993 for (fli
= flp
; fli
; fli
= fli
->next
)
3996 if (!fli
->started_p
)
4000 oprintf (f
, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
4001 put_mangled_filename (f
, v
->line
.file
);
4002 oprintf (f
, "[] = {\n");
4005 write_root (f
, v
, v
->type
->u
.p
->u
.param_struct
.param
[0],
4006 v
->name
, length_p
, &v
->line
, if_marked
, emit_pch
);
4009 finish_root_table (flp
, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
4010 "gt_ggc_cache_rtab");
4015 for (v
= variables
; v
; v
= v
->next
)
4017 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4021 int if_marked_p
= 0;
4024 for (o
= v
->opt
; o
; o
= o
->next
)
4025 if (strcmp (o
->name
, "length") == 0)
4027 else if (strcmp (o
->name
, "if_marked") == 0)
4033 for (fli
= flp
; fli
; fli
= fli
->next
)
4036 if (!fli
->started_p
)
4040 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
4041 put_mangled_filename (f
, v
->line
.file
);
4042 oprintf (f
, "[] = {\n");
4045 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
, emit_pch
);
4048 finish_root_table (flp
, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4049 "gt_pch_cache_rtab");
4051 for (v
= variables
; v
; v
= v
->next
)
4053 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4059 for (o
= v
->opt
; o
; o
= o
->next
)
4060 if (strcmp (o
->name
, "deletable") == 0
4061 || strcmp (o
->name
, "if_marked") == 0)
4067 if (!contains_scalar_p (v
->type
))
4070 for (fli
= flp
; fli
; fli
= fli
->next
)
4073 if (!fli
->started_p
)
4077 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
4078 put_mangled_filename (f
, v
->line
.file
);
4079 oprintf (f
, "[] = {\n");
4082 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
4086 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4087 "gt_pch_scalar_rtab");
4090 /* Record the definition of a generic VEC structure, as if we had expanded
4091 the macros in vec.h:
4093 typedef struct VEC_<type>_base GTY(()) {
4096 <type> GTY((length ("%h.num"))) vec[1];
4099 where the GTY(()) tags are only present if is_scalar is _false_. */
4102 note_def_vec (const char *type_name
, bool is_scalar
, struct fileloc
*pos
)
4107 type_p len_ty
= create_scalar_type ("unsigned");
4108 const char *name
= concat ("VEC_", type_name
, "_base", (char *) 0);
4112 t
= create_scalar_type (type_name
);
4117 t
= resolve_typedef (type_name
, pos
);
4118 o
= create_string_option (0, "length", "%h.num");
4120 /* We assemble the field list in reverse order. */
4121 fields
= create_field_at (0, create_array (t
, "1"), "vec", o
, pos
);
4122 fields
= create_field_at (fields
, len_ty
, "alloc", 0, pos
);
4123 fields
= create_field_at (fields
, len_ty
, "num", 0, pos
);
4125 do_typedef (name
, new_structure (name
, 0, pos
, fields
, 0), pos
);
4128 /* Record the definition of an allocation-specific VEC structure, as if
4129 we had expanded the macros in vec.h:
4131 typedef struct VEC_<type>_<astrat> {
4132 VEC_<type>_base base;
4133 } VEC_<type>_<astrat>;
4136 note_def_vec_alloc (const char *type
, const char *astrat
, struct fileloc
*pos
)
4138 const char *astratname
= concat ("VEC_", type
, "_", astrat
, (char *) 0);
4139 const char *basename
= concat ("VEC_", type
, "_base", (char *) 0);
4141 pair_p field
= create_field_at (0, resolve_typedef (basename
, pos
),
4144 do_typedef (astratname
, new_structure (astratname
, 0, pos
, field
, 0), pos
);
4147 /* Returns the specifier keyword for a string or union type S, empty string
4151 get_type_specifier (const type_p s
)
4153 if (s
->kind
== TYPE_STRUCT
|| s
->kind
== TYPE_LANG_STRUCT
)
4155 if (s
->kind
== TYPE_UNION
)
4160 /* TRUE if type S has the GTY variable_size annotation. */
4163 variable_size_p (const type_p s
)
4166 for (o
= s
->u
.s
.opt
; o
; o
= o
->next
)
4167 if (strcmp (o
->name
, "variable_size") == 0)
4175 { any_zone
, specific_zone
};
4177 /* Writes one typed allocator definition for type identifier TYPE_NAME with
4178 optional type specifier TYPE_SPECIFIER. The allocator name will contain
4179 ALLOCATOR_TYPE. If VARIABLE_SIZE is true, the allocator will have an extra
4180 parameter specifying number of bytes to allocate. If QUANTITY is set to
4181 VECTOR, a vector allocator will be output, if ZONE is set to SPECIFIC_ZONE,
4182 the allocator will be zone-specific. */
4185 write_typed_alloc_def (bool variable_size
, const char *type_specifier
,
4186 const char *type_name
, const char *allocator_type
,
4187 enum alloc_quantity quantity
, enum alloc_zone zone
)
4189 bool two_args
= variable_size
&& (quantity
== vector
);
4190 bool third_arg
= ((zone
== specific_zone
)
4191 && (variable_size
|| (quantity
== vector
)));
4193 oprintf (header_file
, "#define ggc_alloc_%s%s", allocator_type
, type_name
);
4194 oprintf (header_file
, "(%s%s%s%s%s) ",
4195 (variable_size
? "SIZE" : ""),
4196 (two_args
? ", " : ""),
4197 (quantity
== vector
) ? "n" : "",
4198 (third_arg
? ", " : ""), (zone
== specific_zone
) ? "z" : "");
4199 oprintf (header_file
, "((%s%s *)", type_specifier
, type_name
);
4200 oprintf (header_file
, "(ggc_internal_%salloc_stat (", allocator_type
);
4201 if (zone
== specific_zone
)
4202 oprintf (header_file
, "z, ");
4204 oprintf (header_file
, "SIZE");
4206 oprintf (header_file
, "sizeof (%s%s)", type_specifier
, type_name
);
4207 if (quantity
== vector
)
4208 oprintf (header_file
, ", n");
4209 oprintf (header_file
, " MEM_STAT_INFO)))\n");
4212 /* Writes a typed allocator definition for a struct or union S. */
4215 write_typed_struct_alloc_def (const type_p s
, const char *allocator_type
,
4216 enum alloc_quantity quantity
,
4217 enum alloc_zone zone
)
4219 write_typed_alloc_def (variable_size_p (s
), get_type_specifier (s
),
4220 s
->u
.s
.tag
, allocator_type
, quantity
, zone
);
4223 /* Writes a typed allocator definition for a typedef P. */
4226 write_typed_typedef_alloc_def (const pair_p p
, const char *allocator_type
,
4227 enum alloc_quantity quantity
,
4228 enum alloc_zone zone
)
4230 write_typed_alloc_def (variable_size_p (p
->type
), "", p
->name
,
4231 allocator_type
, quantity
, zone
);
4234 /* Writes typed allocator definitions for the types in STRUCTURES and
4235 TYPEDEFS that are used by GC. */
4238 write_typed_alloc_defns (const type_p structures
, const pair_p typedefs
)
4243 oprintf (header_file
,
4244 "\n/* Allocators for known structs and unions. */\n\n");
4245 for (s
= structures
; s
; s
= s
->next
)
4247 if (!USED_BY_TYPED_GC_P (s
))
4249 write_typed_struct_alloc_def (s
, "", single
, any_zone
);
4250 write_typed_struct_alloc_def (s
, "cleared_", single
, any_zone
);
4251 write_typed_struct_alloc_def (s
, "vec_", vector
, any_zone
);
4252 write_typed_struct_alloc_def (s
, "cleared_vec_", vector
, any_zone
);
4253 write_typed_struct_alloc_def (s
, "zone_", single
, specific_zone
);
4254 write_typed_struct_alloc_def (s
, "zone_cleared_", single
,
4256 write_typed_struct_alloc_def (s
, "zone_vec_", vector
, specific_zone
);
4257 write_typed_struct_alloc_def (s
, "zone_cleared_vec_", vector
,
4261 oprintf (header_file
, "\n/* Allocators for known typedefs. */\n");
4262 for (p
= typedefs
; p
; p
= p
->next
)
4265 if (!USED_BY_TYPED_GC_P (s
) || (strcmp (p
->name
, s
->u
.s
.tag
) == 0))
4267 write_typed_typedef_alloc_def (p
, "", single
, any_zone
);
4268 write_typed_typedef_alloc_def (p
, "cleared_", single
, any_zone
);
4269 write_typed_typedef_alloc_def (p
, "vec_", vector
, any_zone
);
4270 write_typed_typedef_alloc_def (p
, "cleared_vec_", vector
, any_zone
);
4271 write_typed_typedef_alloc_def (p
, "zone_", single
, specific_zone
);
4272 write_typed_typedef_alloc_def (p
, "zone_cleared_", single
,
4274 write_typed_typedef_alloc_def (p
, "zone_cleared_vec_", vector
,
4279 /* Prints not-as-ugly version of a typename of T to OF. Trades the uniquness
4280 guaranteee for somewhat increased readability. If name conflicts do happen,
4281 this funcion will have to be adjusted to be more like
4282 output_mangled_typename. */
4285 output_typename (outf_p of
, const_type_p t
)
4290 oprintf (of
, "str");
4293 oprintf (of
, "scalar");
4296 output_typename (of
, t
->u
.p
);
4300 case TYPE_LANG_STRUCT
:
4301 oprintf (of
, "%s", t
->u
.s
.tag
);
4303 case TYPE_PARAM_STRUCT
:
4306 for (i
= 0; i
< NUM_PARAM
; i
++)
4307 if (t
->u
.param_struct
.param
[i
] != NULL
)
4309 output_typename (of
, t
->u
.param_struct
.param
[i
]);
4312 output_typename (of
, t
->u
.param_struct
.stru
);
4320 /* Writes a typed GC allocator for type S that is suitable as a callback for
4321 the splay tree implementation in libiberty. */
4324 write_splay_tree_allocator_def (const_type_p s
)
4326 outf_p of
= get_output_file_with_visibility (NULL
);
4327 oprintf (of
, "void * ggc_alloc_splay_tree_");
4328 output_typename (of
, s
);
4329 oprintf (of
, " (int sz, void * nl)\n");
4330 oprintf (of
, "{\n");
4331 oprintf (of
, " return ggc_splay_alloc (");
4332 oprintf (of
, "gt_e_");
4333 output_mangled_typename (of
, s
);
4334 oprintf (of
, ", sz, nl);\n");
4335 oprintf (of
, "}\n\n");
4338 /* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks
4339 for the splay tree implementation in libiberty. */
4342 write_splay_tree_allocators (const_type_p param_structs
)
4346 oprintf (header_file
, "\n/* Splay tree callback allocators. */\n");
4347 for (s
= param_structs
; s
; s
= s
->next
)
4348 if (s
->gc_used
== GC_POINTED_TO
)
4350 oprintf (header_file
, "extern void * ggc_alloc_splay_tree_");
4351 output_typename (header_file
, s
);
4352 oprintf (header_file
, " (int, void *);\n");
4353 write_splay_tree_allocator_def (s
);
4357 static void dump_pair (int indent
, pair_p p
);
4358 static void dump_type (int indent
, type_p p
);
4359 static void dump_type_list (int indent
, type_p p
);
4363 /* Dumps the value of typekind KIND. */
4366 dump_typekind (int indent
, enum typekind kind
)
4368 printf ("%*ckind = ", indent
, ' ');
4372 printf ("TYPE_SCALAR");
4375 printf ("TYPE_STRING");
4378 printf ("TYPE_STRUCT");
4381 printf ("TYPE_UNION");
4384 printf ("TYPE_POINTER");
4387 printf ("TYPE_ARRAY");
4389 case TYPE_LANG_STRUCT
:
4390 printf ("TYPE_LANG_STRUCT");
4392 case TYPE_PARAM_STRUCT
:
4393 printf ("TYPE_PARAM_STRUCT");
4401 /* Dumps the value of GC_USED flag. */
4404 dump_gc_used (int indent
, enum gc_used_enum gc_used
)
4406 printf ("%*cgc_used = ", indent
, ' ');
4410 printf ("GC_UNUSED");
4415 case GC_MAYBE_POINTED_TO
:
4416 printf ("GC_MAYBE_POINTED_TO");
4419 printf ("GC_POINTED_TO");
4427 /* Dumps the type options OPT. */
4430 dump_options (int indent
, options_p opt
)
4433 printf ("%*coptions = ", indent
, ' ');
4440 printf ("%s:string %s ", o
->name
, o
->info
.string
);
4443 printf ("%s:type ", o
->name
);
4444 dump_type (indent
+1, o
->info
.type
);
4447 printf ("%s:nested ", o
->name
);
4457 /* Dumps the source file location in LINE. */
4460 dump_fileloc (int indent
, struct fileloc line
)
4462 printf ("%*cfileloc: file = %s, line = %d\n", indent
, ' ',
4463 get_input_file_name (line
.file
),
4467 /* Recursively dumps the struct, union, or a language-specific
4471 dump_type_u_s (int indent
, type_p t
)
4475 gcc_assert (t
->kind
== TYPE_STRUCT
|| t
->kind
== TYPE_UNION
4476 || t
->kind
== TYPE_LANG_STRUCT
);
4477 printf ("%*cu.s.tag = %s\n", indent
, ' ', t
->u
.s
.tag
);
4478 dump_fileloc (indent
, t
->u
.s
.line
);
4479 printf ("%*cu.s.fields =\n", indent
, ' ');
4480 fields
= t
->u
.s
.fields
;
4483 dump_pair (indent
+ INDENT
, fields
);
4484 fields
= fields
->next
;
4486 printf ("%*cend of fields of type %p\n", indent
, ' ', (void *) t
);
4487 dump_options (indent
, t
->u
.s
.opt
);
4488 printf ("%*cu.s.bitmap = %X\n", indent
, ' ', t
->u
.s
.bitmap
);
4489 if (t
->kind
== TYPE_LANG_STRUCT
)
4491 printf ("%*cu.s.lang_struct:\n", indent
, ' ');
4492 dump_type_list (indent
+ INDENT
, t
->u
.s
.lang_struct
);
4496 /* Recursively dumps the array T. */
4499 dump_type_u_a (int indent
, type_p t
)
4501 gcc_assert (t
->kind
== TYPE_ARRAY
);
4502 printf ("%*clen = %s, u.a.p:\n", indent
, ' ', t
->u
.a
.len
);
4503 dump_type_list (indent
+ INDENT
, t
->u
.a
.p
);
4506 /* Recursively dumps the parameterized struct T. */
4509 dump_type_u_param_struct (int indent
, type_p t
)
4512 gcc_assert (t
->kind
== TYPE_PARAM_STRUCT
);
4513 printf ("%*cu.param_struct.stru:\n", indent
, ' ');
4514 dump_type_list (indent
, t
->u
.param_struct
.stru
);
4515 dump_fileloc (indent
, t
->u
.param_struct
.line
);
4516 for (i
= 0; i
< NUM_PARAM
; i
++)
4518 if (t
->u
.param_struct
.param
[i
] == NULL
)
4520 printf ("%*cu.param_struct.param[%d]:\n", indent
, ' ', i
);
4521 dump_type (indent
+ INDENT
, t
->u
.param_struct
.param
[i
]);
4525 /* Recursively dumps the type list T. */
4528 dump_type_list (int indent
, type_p t
)
4533 dump_type (indent
, p
);
4538 static htab_t seen_types
;
4540 /* Recursively dumps the type T if it was not dumped previously. */
4543 dump_type (int indent
, type_p t
)
4547 printf ("%*cType at %p: ", indent
, ' ', (void *) t
);
4548 slot
= htab_find_slot (seen_types
, t
, INSERT
);
4551 printf ("already seen.\n");
4557 dump_typekind (indent
, t
->kind
);
4558 printf ("%*cpointer_to = %p\n", indent
+ INDENT
, ' ',
4559 (void *) t
->pointer_to
);
4560 dump_gc_used (indent
+ INDENT
, t
->gc_used
);
4564 printf ("%*cscalar_is_char = %s\n", indent
+ INDENT
, ' ',
4565 t
->u
.scalar_is_char
? "true" : "false");
4571 case TYPE_LANG_STRUCT
:
4572 dump_type_u_s (indent
+ INDENT
, t
);
4575 printf ("%*cp:\n", indent
+ INDENT
, ' ');
4576 dump_type (indent
+ INDENT
, t
->u
.p
);
4579 dump_type_u_a (indent
+ INDENT
, t
);
4581 case TYPE_PARAM_STRUCT
:
4582 dump_type_u_param_struct (indent
+ INDENT
, t
);
4587 printf ("%*cEnd of type at %p\n", indent
, ' ', (void *) t
);
4590 /* Dumps the pair P. */
4593 dump_pair (int indent
, pair_p p
)
4595 printf ("%*cpair: name = %s\n", indent
, ' ', p
->name
);
4596 dump_type (indent
, p
->type
);
4597 dump_fileloc (indent
, p
->line
);
4598 dump_options (indent
, p
->opt
);
4599 printf ("%*cEnd of pair %s\n", indent
, ' ', p
->name
);
4602 /* Dumps the list of pairs PP. */
4605 dump_pair_list (const char *name
, pair_p pp
)
4608 printf ("%s:\n", name
);
4609 for (p
= pp
; p
!= NULL
; p
= p
->next
)
4611 printf ("End of %s\n\n", name
);
4614 /* Dumps the STRUCTURES. */
4617 dump_structures (const char *name
, type_p structures
)
4619 printf ("%s:\n", name
);
4620 dump_type_list (0, structures
);
4621 printf ("End of %s\n\n", name
);
4624 /* Dumps the internal structures of gengtype. This is useful to debug
4625 gengtype itself, or to understand what it does, e.g. for plugin
4629 dump_everything (void)
4631 seen_types
= htab_create (100, htab_hash_pointer
, htab_eq_pointer
, NULL
);
4632 dump_pair_list ("typedefs", typedefs
);
4633 dump_structures ("structures", structures
);
4634 dump_structures ("param_structs", param_structs
);
4635 dump_pair_list ("variables", variables
);
4636 htab_delete (seen_types
);
4641 /* Option specification for getopt_long. */
4642 static const struct option gengtype_long_options
[] = {
4643 {"help", no_argument
, NULL
, 'h'},
4644 {"version", no_argument
, NULL
, 'V'},
4645 {"verbose", no_argument
, NULL
, 'v'},
4646 {"dump", no_argument
, NULL
, 'd'},
4647 {"debug", no_argument
, NULL
, 'D'},
4648 {"plugin", required_argument
, NULL
, 'P'},
4649 {"srcdir", required_argument
, NULL
, 'S'},
4650 {"backupdir", required_argument
, NULL
, 'B'},
4651 {"inputs", required_argument
, NULL
, 'I'},
4652 {"read-state", required_argument
, NULL
, 'r'},
4653 {"write-state", required_argument
, NULL
, 'w'},
4654 /* Terminating NULL placeholder. */
4655 {NULL
, no_argument
, NULL
, 0},
4662 printf ("Usage: %s\n", progname
);
4663 printf ("\t -h | --help " " \t# Give this help.\n");
4664 printf ("\t -D | --debug "
4665 " \t# Give debug output to debug %s itself.\n", progname
);
4666 printf ("\t -V | --version " " \t# Give version information.\n");
4667 printf ("\t -v | --verbose \t# Increase verbosity. Can be given several times.\n");
4668 printf ("\t -d | --dump " " \t# Dump state for debugging.\n");
4669 printf ("\t -P | --plugin <output-file> <plugin-src> ... "
4670 " \t# Generate for plugin.\n");
4671 printf ("\t -S | --srcdir <GCC-directory> "
4672 " \t# Specify the GCC source directory.\n");
4673 printf ("\t -B | --backupdir <directory> "
4674 " \t# Specify the backup directory for updated files.\n");
4675 printf ("\t -I | --inputs <input-list> "
4676 " \t# Specify the file with source files list.\n");
4677 printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n");
4678 printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n");
4682 print_version (void)
4684 printf ("%s %s%s\n", progname
, pkgversion_string
, version_string
);
4685 printf ("Report bugs: %s\n", bug_report_url
);
4688 /* Parse the program options using getopt_long... */
4690 parse_program_options (int argc
, char **argv
)
4693 while ((opt
= getopt_long (argc
, argv
, "hVvdP:S:B:I:w:r:D",
4694 gengtype_long_options
, NULL
)) >= 0)
4698 case 'h': /* --help */
4701 case 'V': /* --version */
4704 case 'd': /* --dump */
4707 case 'D': /* --debug */
4710 case 'v': /* --verbose */
4713 case 'P': /* --plugin */
4715 plugin_output_filename
= optarg
;
4717 fatal ("missing plugin output file name");
4719 case 'S': /* --srcdir */
4723 fatal ("missing source directory");
4724 srcdir_len
= strlen (srcdir
);
4726 case 'B': /* --backupdir */
4728 backup_dir
= optarg
;
4730 fatal ("missing backup directory");
4732 case 'I': /* --inputs */
4736 fatal ("missing input list");
4738 case 'r': /* --read-state */
4740 read_state_filename
= optarg
;
4742 fatal ("missing read state file");
4743 DBGPRINTF ("read state %s\n", optarg
);
4745 case 'w': /* --write-state */
4746 DBGPRINTF ("write state %s\n", optarg
);
4748 write_state_filename
= optarg
;
4750 fatal ("missing write state file");
4753 fprintf (stderr
, "%s: unknown flag '%c'\n", progname
, opt
);
4755 fatal ("unexpected flag");
4758 if (plugin_output_filename
)
4760 /* In plugin mode we require some input files. */
4763 fatal ("no source files given in plugin mode");
4764 nb_plugin_files
= argc
- optind
;
4765 plugin_files
= XNEWVEC (input_file
*, nb_plugin_files
);
4766 for (i
= 0; i
< (int) nb_plugin_files
; i
++)
4768 char *name
= argv
[i
+ optind
];
4769 plugin_files
[i
] = input_file_by_name (name
);
4776 /******* Manage input files. ******/
4778 /* Hash table of unique input file names. */
4779 static htab_t input_file_htab
;
4781 /* Find or allocate a new input_file by hash-consing it. */
4783 input_file_by_name (const char* name
)
4786 input_file
* f
= NULL
;
4790 namlen
= strlen (name
);
4791 f
= XCNEWVAR (input_file
, sizeof (input_file
)+namlen
+2);
4794 strcpy (f
->inpname
, name
);
4795 slot
= htab_find_slot (input_file_htab
, f
, INSERT
);
4796 gcc_assert (slot
!= NULL
);
4799 /* Already known input file. */
4801 return (input_file
*)(*slot
);
4803 /* New input file. */
4808 /* Hash table support routines for input_file-s. */
4810 htab_hash_inputfile (const void *p
)
4812 const input_file
*inpf
= (const input_file
*) p
;
4814 return htab_hash_string (get_input_file_name (inpf
));
4818 htab_eq_inputfile (const void *x
, const void *y
)
4820 const input_file
*inpfx
= (const input_file
*) x
;
4821 const input_file
*inpfy
= (const input_file
*) y
;
4822 gcc_assert (inpfx
!= NULL
&& inpfy
!= NULL
);
4823 return !strcmp (get_input_file_name (inpfx
), get_input_file_name (inpfy
));
4828 main (int argc
, char **argv
)
4831 static struct fileloc pos
= { NULL
, 0 };
4832 outf_p output_header
;
4834 /* Mandatory common initializations. */
4835 progname
= "gengtype"; /* For fatal and messages. */
4836 /* Create the hash-table used to hash-cons input files. */
4838 htab_create (800, htab_hash_inputfile
, htab_eq_inputfile
, NULL
);
4839 /* Initialize our special input files. */
4840 this_file
= input_file_by_name (__FILE__
);
4841 system_h_file
= input_file_by_name ("system.h");
4842 /* Set the scalar_is_char union number for predefined scalar types. */
4843 scalar_nonchar
.u
.scalar_is_char
= FALSE
;
4844 scalar_char
.u
.scalar_is_char
= TRUE
;
4846 parse_program_options (argc
, argv
);
4851 time_t now
= (time_t) 0;
4853 DBGPRINTF ("gengtype started pid %d at %s",
4854 (int) getpid (), ctime (&now
));
4856 #endif /* ENABLE_CHECKING */
4858 /* Parse the input list and the input files. */
4859 DBGPRINTF ("inputlist %s", inputlist
);
4860 if (read_state_filename
)
4863 fatal ("input list %s cannot be given with a read state file %s",
4864 inputlist
, read_state_filename
);
4865 read_state (read_state_filename
);
4866 DBGPRINT_COUNT_TYPE ("structures after read_state", structures
);
4867 DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs
);
4871 /* These types are set up with #define or else outside of where
4872 we can see them. We should initialize them before calling
4874 #define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \
4876 POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos
));
4877 POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos
));
4878 POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos
));
4879 POS_HERE (do_scalar_typedef ("double_int", &pos
));
4880 POS_HERE (do_scalar_typedef ("uint64_t", &pos
));
4881 POS_HERE (do_scalar_typedef ("uint8", &pos
));
4882 POS_HERE (do_scalar_typedef ("jword", &pos
));
4883 POS_HERE (do_scalar_typedef ("JCF_u2", &pos
));
4884 POS_HERE (do_scalar_typedef ("void", &pos
));
4885 POS_HERE (do_typedef ("PTR",
4886 create_pointer (resolve_typedef ("void", &pos
)),
4889 read_input_list (inputlist
);
4890 for (i
= 0; i
< num_gt_files
; i
++)
4892 parse_file (get_input_file_name (gt_files
[i
]));
4893 DBGPRINTF ("parsed file #%d %s",
4894 (int) i
, get_input_file_name (gt_files
[i
]));
4896 if (verbosity_level
>= 1)
4897 printf ("%s parsed %d files with %d GTY types\n",
4898 progname
, (int) num_gt_files
, type_count
);
4900 DBGPRINT_COUNT_TYPE ("structures after parsing", structures
);
4901 DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs
);
4905 fatal ("either an input list or a read state file should be given");
4910 if (plugin_output_filename
)
4913 /* In plugin mode, we should have read a state file, and have
4914 given at least one plugin file. */
4915 if (!read_state_filename
)
4916 fatal ("No read state given in plugin mode for %s",
4917 plugin_output_filename
);
4919 if (nb_plugin_files
== 0 || !plugin_files
)
4920 fatal ("No plugin files given in plugin mode for %s",
4921 plugin_output_filename
);
4923 /* Parse our plugin files and augment the state. */
4924 for (ix
= 0; ix
< nb_plugin_files
; ix
++)
4925 parse_file (get_input_file_name (plugin_files
[ix
]));
4930 plugin_output
= create_file ("GCC", plugin_output_filename
);
4931 DBGPRINTF ("created plugin_output %p named %s",
4932 (void *) plugin_output
, plugin_output
->name
);
4935 { /* No plugin files, we are in normal mode. */
4937 fatal ("gengtype needs a source directory in normal mode");
4944 /* The call to set_gc_used may indirectly call find_param_structure
4945 hence enlarge the param_structs list of types. */
4946 set_gc_used (variables
);
4948 /* The state at this point is read from the state input file or by
4949 parsing source files and optionally augmented by parsing plugin
4950 source files. Write it now. */
4951 if (write_state_filename
)
4953 DBGPRINT_COUNT_TYPE ("structures before write_state", structures
);
4954 DBGPRINT_COUNT_TYPE ("param_structs before write_state", param_structs
);
4957 fatal ("didn't write state file %s after errors",
4958 write_state_filename
);
4960 DBGPRINTF ("before write_state %s", write_state_filename
);
4961 write_state (write_state_filename
);
4966 /* After having written the state file we return immediately to
4967 avoid generating any output file. */
4977 write_enum_defn (structures
, param_structs
);
4978 write_typed_alloc_defns (structures
, typedefs
);
4979 output_header
= plugin_output
? plugin_output
: header_file
;
4980 DBGPRINT_COUNT_TYPE ("structures before write_types outputheader",
4982 DBGPRINT_COUNT_TYPE ("param_structs before write_types outputheader",
4985 write_types (output_header
, structures
, param_structs
, &ggc_wtd
);
4986 if (plugin_files
== NULL
)
4988 DBGPRINT_COUNT_TYPE ("structures before write_types headerfil",
4990 DBGPRINT_COUNT_TYPE ("param_structs before write_types headerfil",
4992 write_types (header_file
, structures
, param_structs
, &pch_wtd
);
4993 write_local (header_file
, structures
, param_structs
);
4995 write_splay_tree_allocators (param_structs
);
4996 write_roots (variables
, plugin_files
== NULL
);
4998 close_output_files ();
5003 /* Don't bother about free-ing any input or plugin file, etc. */