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. */
31 #include "filenames.h"
33 /* Data types, macros, etc. used only in this file. */
36 /* The list of output files. */
39 /* The output header file that is included into pretty much every
44 /* The name of the file containing the list of input files. */
45 static char *inputlist
;
47 /* The plugin input files and their number; in that case only
48 a single file is produced. */
49 static input_file
**plugin_files
;
50 static size_t nb_plugin_files
;
52 /* The generated plugin output file and name. */
53 static outf_p plugin_output
;
54 static char *plugin_output_filename
;
56 /* Our source directory and its length. */
60 /* Variables used for reading and writing the state. */
61 const char *read_state_filename
;
62 const char *write_state_filename
;
64 /* Variables to help debugging. */
68 /* Level for verbose messages. */
71 /* We have a type count and use it to set the state_number of newly
72 allocated types to some unique negative number. */
73 static int type_count
;
75 /* The backup directory should be in the same file system as the
76 generated files, otherwise the rename(2) system call would fail.
77 If NULL, no backup is made when overwriting a generated file. */
78 static const char* backup_dir
; /* (-B) program option. */
81 static outf_p
create_file (const char *, const char *);
83 static const char *get_file_basename (const input_file
*);
84 static const char *get_file_realbasename (const input_file
*);
86 static int get_prefix_langdir_index (const char *);
87 static const char *get_file_langdir (const input_file
*);
90 /* Nonzero iff an error has occurred. */
91 bool hit_error
= false;
93 static void gen_rtx_next (void);
94 static void write_rtx_next (void);
95 static void open_base_files (void);
96 static void close_output_files (void);
98 /* Report an error at POS, printing MSG. */
101 error_at_line (const struct fileloc
*pos
, const char *msg
, ...)
105 gcc_assert (pos
!= NULL
&& pos
->file
!= NULL
);
108 fprintf (stderr
, "%s:%d: ", get_input_file_name (pos
->file
), pos
->line
);
109 vfprintf (stderr
, msg
, ap
);
110 fputc ('\n', stderr
);
116 /* asprintf, but produces fatal message on out-of-memory. */
118 xasprintf (const char *format
, ...)
124 va_start (ap
, format
);
125 n
= vasprintf (&result
, format
, ap
);
126 if (result
== NULL
|| n
< 0)
127 fatal ("out of memory");
133 /* Input file handling. */
135 /* Table of all input files. */
136 const input_file
**gt_files
;
139 /* A number of places use the name of this "gengtype.c" file for a
140 location for things that we can't rely on the source to define.
141 Make sure we can still use pointer comparison on filenames. */
142 input_file
* this_file
;
143 /* The "system.h" file is likewise specially useful. */
144 input_file
* system_h_file
;
146 /* Vector of per-language directories. */
147 const char **lang_dir_names
;
148 size_t num_lang_dirs
;
150 /* An array of output files suitable for definitions. There is one
151 BASE_FILES entry for each language. */
152 static outf_p
*base_files
;
157 /* Utility debugging function, printing the various type counts within
158 a list of types. Called thru the DBGPRINT_COUNT_TYPE macro. */
160 dbgprint_count_type_at (const char *fil
, int lin
, const char *msg
, type_p t
)
162 int nb_types
= 0, nb_scalar
= 0, nb_string
= 0;
163 int nb_struct
= 0, nb_union
= 0, nb_array
= 0, nb_pointer
= 0;
164 int nb_lang_struct
= 0, nb_param_struct
= 0;
166 for (p
= t
; p
; p
= p
->next
)
189 case TYPE_LANG_STRUCT
:
192 case TYPE_PARAM_STRUCT
:
199 fprintf (stderr
, "\n" "%s:%d: %s: @@%%@@ %d types ::\n",
200 lbasename (fil
), lin
, msg
, nb_types
);
201 if (nb_scalar
> 0 || nb_string
> 0)
202 fprintf (stderr
, "@@%%@@ %d scalars, %d strings\n", nb_scalar
, nb_string
);
203 if (nb_struct
> 0 || nb_union
> 0)
204 fprintf (stderr
, "@@%%@@ %d structs, %d unions\n", nb_struct
, nb_union
);
205 if (nb_pointer
> 0 || nb_array
> 0)
206 fprintf (stderr
, "@@%%@@ %d pointers, %d arrays\n", nb_pointer
, nb_array
);
207 if (nb_lang_struct
> 0 || nb_param_struct
> 0)
208 fprintf (stderr
, "@@%%@@ %d lang_structs, %d param_structs\n",
209 nb_lang_struct
, nb_param_struct
);
210 fprintf (stderr
, "\n");
212 #endif /* ENABLE_CHECKING */
214 /* Scan the input file, LIST, and determine how much space we need to
215 store strings in. Also, count the number of language directories
216 and files. The numbers returned are overestimates as they does not
217 consider repeated files. */
219 measure_input_list (FILE *list
)
225 num_gt_files
= plugin_files
? nb_plugin_files
: 0;
226 while ((c
= getc (list
)) != EOF
)
235 /* Add space for a lang_bitmap before the input file name. */
236 n
+= sizeof (lang_bitmap
);
250 /* Read one input line from LIST to HEREP (which is updated). A
251 pointer to the string is returned via LINEP. If it was a language
252 subdirectory in square brackets, strip off the square brackets and
253 return true. Otherwise, leave space before the string for a
254 lang_bitmap, and return false. At EOF, returns false, does not
255 touch *HEREP, and sets *LINEP to NULL. POS is used for
258 read_input_line (FILE *list
, char **herep
, char **linep
, struct fileloc
*pos
)
264 /* Read over whitespace. */
265 while (c
== '\n' || c
== ' ')
275 /* No space for a lang_bitmap is necessary. Discard the '['. */
278 while (c
!= ']' && c
!= '\n' && c
!= EOF
)
287 c
= getc (list
); /* eat what should be a newline */
288 if (c
!= '\n' && c
!= EOF
)
289 error_at_line (pos
, "junk on line after language tag [%s]", line
);
292 error_at_line (pos
, "missing close bracket for language tag [%s",
301 /* Leave space for a lang_bitmap. */
302 memset (here
, 0, sizeof (lang_bitmap
));
303 here
+= sizeof (lang_bitmap
);
310 while (c
!= EOF
&& c
!= '\n');
318 /* Read the list of input files from LIST and compute all of the
319 relevant tables. There is one file per line of the list. At
320 first, all the files on the list are language-generic, but
321 eventually a line will appear which is the name of a language
322 subdirectory in square brackets, like this: [cp]. All subsequent
323 files are specific to that language, until another language
324 subdirectory tag appears. Files can appear more than once, if
325 they apply to more than one language. */
327 read_input_list (const char *listname
)
329 FILE *list
= fopen (listname
, "r");
331 fatal ("cannot open %s: %s", listname
, xstrerror (errno
));
335 size_t bufsz
= measure_input_list (list
);
336 char *buf
= XNEWVEC (char, bufsz
);
338 char *committed
= buf
;
339 char *limit
= buf
+ bufsz
;
344 lang_bitmap curlangs
= (1 << num_lang_dirs
) - 1;
346 epos
.file
= input_file_by_name (listname
);
349 lang_dir_names
= XNEWVEC (const char *, num_lang_dirs
);
350 gt_files
= XNEWVEC (const input_file
*, num_gt_files
);
357 is_language
= read_input_line (list
, &here
, &line
, &epos
);
358 gcc_assert (here
<= limit
);
361 else if (is_language
)
364 gcc_assert (langno
<= num_lang_dirs
);
365 for (i
= 0; i
< langno
; i
++)
366 if (strcmp (lang_dir_names
[i
], line
) == 0)
368 error_at_line (&epos
, "duplicate language tag [%s]",
375 curlangs
= 1 << langno
;
376 lang_dir_names
[langno
++] = line
;
381 input_file
*inpf
= input_file_by_name (line
);
382 gcc_assert (nfiles
<= num_gt_files
);
383 for (i
= 0; i
< nfiles
; i
++)
384 /* Since the input_file-s are uniquely hash-consed, we
385 can just compare pointers! */
386 if (gt_files
[i
] == inpf
)
388 /* Throw away the string we just read, and add the
389 current language to the existing string's bitmap. */
390 lang_bitmap bmap
= get_lang_bitmap (inpf
);
392 error_at_line (&epos
,
393 "file %s specified more than once "
394 "for language %s", line
,
396 0 ? "(all)" : lang_dir_names
[langno
-
400 set_lang_bitmap (inpf
, bmap
);
405 set_lang_bitmap (inpf
, curlangs
);
406 gt_files
[nfiles
++] = inpf
;
409 /* Update the global counts now that we know accurately how many
410 things there are. (We do not bother resizing the arrays down.) */
411 num_lang_dirs
= langno
;
412 /* Add the plugin files if provided. */
416 for (i
= 0; i
< nb_plugin_files
; i
++)
417 gt_files
[nfiles
++] = plugin_files
[i
];
419 num_gt_files
= nfiles
;
422 /* Sanity check: any file that resides in a language subdirectory
423 (e.g. 'cp') ought to belong to the corresponding language.
424 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
425 (Can you even do that? Should you be allowed to?) */
428 for (f
= 0; f
< num_gt_files
; f
++)
430 lang_bitmap bitmap
= get_lang_bitmap (gt_files
[f
]);
431 const char *basename
= get_file_basename (gt_files
[f
]);
432 const char *slashpos
= strchr (basename
, '/');
433 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
434 const char *slashpos2
= strchr (basename
, '\\');
436 if (!slashpos
|| (slashpos2
&& slashpos2
< slashpos
))
437 slashpos
= slashpos2
;
443 for (l
= 0; l
< num_lang_dirs
; l
++)
444 if ((size_t) (slashpos
- basename
) == strlen (lang_dir_names
[l
])
445 && memcmp (basename
, lang_dir_names
[l
],
446 strlen (lang_dir_names
[l
])) == 0)
448 if (!(bitmap
& (1 << l
)))
449 error ("%s is in language directory '%s' but is not "
450 "tagged for that language",
451 basename
, lang_dir_names
[l
]);
459 fatal ("error reading %s: %s", listname
, xstrerror (errno
));
466 /* The one and only TYPE_STRING. */
468 struct type string_type
= {
469 TYPE_STRING
, 0, 0, 0, GC_USED
, {0}
472 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
473 set early in main. */
475 struct type scalar_nonchar
= {
476 TYPE_SCALAR
, 0, 0, 0, GC_USED
, {0}
479 struct type scalar_char
= {
480 TYPE_SCALAR
, 0, 0, 0, GC_USED
, {0}
483 /* Lists of various things. */
487 type_p param_structs
;
490 static type_p
find_param_structure (type_p t
, type_p param
[NUM_PARAM
]);
491 static type_p
adjust_field_tree_exp (type_p t
, options_p opt
);
492 static type_p
adjust_field_rtx_def (type_p t
, options_p opt
);
494 /* Define S as a typedef to T at POS. */
497 do_typedef (const char *s
, type_p t
, struct fileloc
*pos
)
501 /* temporary kludge - gengtype doesn't handle conditionals or
502 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
503 is coming from this file (main() sets them up with safe dummy
505 if (!strcmp (s
, "CUMULATIVE_ARGS") && pos
->file
!= this_file
)
508 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
509 if (strcmp (p
->name
, s
) == 0)
513 error_at_line (pos
, "type `%s' previously defined", s
);
514 error_at_line (&p
->line
, "previously defined here");
519 p
= XNEW (struct pair
);
528 /* Define S as a typename of a scalar. Cannot be used to define
529 typedefs of 'char'. Note: is also used for pointer-to-function
530 typedefs (which are therefore not treated as pointers). */
533 do_scalar_typedef (const char *s
, struct fileloc
*pos
)
535 do_typedef (s
, &scalar_nonchar
, pos
);
538 /* Return the type previously defined for S. Use POS to report errors. */
541 resolve_typedef (const char *s
, struct fileloc
*pos
)
544 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
545 if (strcmp (p
->name
, s
) == 0)
547 error_at_line (pos
, "unidentified type `%s'", s
);
548 return &scalar_nonchar
; /* treat as "int" */
551 /* Create and return a new structure with tag NAME (or a union iff
552 ISUNION is nonzero), at POS with fields FIELDS and options O. */
555 new_structure (const char *name
, int isunion
, struct fileloc
*pos
,
556 pair_p fields
, options_p o
)
560 lang_bitmap bitmap
= get_lang_bitmap (pos
->file
);
562 for (si
= structures
; si
!= NULL
; si
= si
->next
)
563 if (strcmp (name
, si
->u
.s
.tag
) == 0 && UNION_P (si
) == isunion
)
566 if (si
->kind
== TYPE_LANG_STRUCT
)
570 for (si
= ls
->u
.s
.lang_struct
; si
!= NULL
; si
= si
->next
)
571 if (si
->u
.s
.bitmap
== bitmap
)
574 else if (si
->u
.s
.line
.file
!= NULL
&& si
->u
.s
.bitmap
!= bitmap
)
578 si
= XCNEW (struct type
);
579 memcpy (si
, ls
, sizeof (struct type
));
580 ls
->kind
= TYPE_LANG_STRUCT
;
581 ls
->u
.s
.lang_struct
= si
;
582 ls
->u
.s
.fields
= NULL
;
584 si
->state_number
= -type_count
;
585 si
->pointer_to
= NULL
;
586 si
->u
.s
.lang_struct
= ls
;
591 if (ls
!= NULL
&& s
== NULL
)
594 s
= XCNEW (struct type
);
595 s
->state_number
= -type_count
;
596 s
->next
= ls
->u
.s
.lang_struct
;
597 ls
->u
.s
.lang_struct
= s
;
598 s
->u
.s
.lang_struct
= ls
;
606 s
= XCNEW (struct type
);
607 s
->state_number
= -type_count
;
608 s
->next
= structures
;
612 if (s
->u
.s
.line
.file
!= NULL
613 || (s
->u
.s
.lang_struct
&& (s
->u
.s
.lang_struct
->u
.s
.bitmap
& bitmap
)))
615 error_at_line (pos
, "duplicate definition of '%s %s'",
616 isunion
? "union" : "struct", s
->u
.s
.tag
);
617 error_at_line (&s
->u
.s
.line
, "previous definition here");
620 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
623 s
->u
.s
.fields
= fields
;
625 s
->u
.s
.bitmap
= bitmap
;
626 if (s
->u
.s
.lang_struct
)
627 s
->u
.s
.lang_struct
->u
.s
.bitmap
|= bitmap
;
632 /* Return the previously-defined structure with tag NAME (or a union
633 iff ISUNION is nonzero), or a new empty structure or union if none
634 was defined previously. */
637 find_structure (const char *name
, int isunion
)
641 for (s
= structures
; s
!= NULL
; s
= s
->next
)
642 if (strcmp (name
, s
->u
.s
.tag
) == 0 && UNION_P (s
) == isunion
)
646 s
= XCNEW (struct type
);
647 s
->next
= structures
;
648 s
->state_number
= -type_count
;
650 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
656 /* Return the previously-defined parameterized structure for structure
657 T and parameters PARAM, or a new parameterized empty structure or
658 union if none was defined previously. */
661 find_param_structure (type_p t
, type_p param
[NUM_PARAM
])
665 for (res
= param_structs
; res
; res
= res
->next
)
666 if (res
->u
.param_struct
.stru
== t
667 && memcmp (res
->u
.param_struct
.param
, param
,
668 sizeof (type_p
) * NUM_PARAM
) == 0)
673 res
= XCNEW (struct type
);
674 res
->kind
= TYPE_PARAM_STRUCT
;
675 res
->next
= param_structs
;
676 res
->state_number
= -type_count
;
678 res
->u
.param_struct
.stru
= t
;
679 memcpy (res
->u
.param_struct
.param
, param
, sizeof (type_p
) * NUM_PARAM
);
684 /* Return a scalar type with name NAME. */
687 create_scalar_type (const char *name
)
689 if (!strcmp (name
, "char") || !strcmp (name
, "unsigned char"))
692 return &scalar_nonchar
;
695 /* Return a pointer to T. */
698 create_pointer (type_p t
)
702 type_p r
= XCNEW (struct type
);
704 r
->state_number
= -type_count
;
705 r
->kind
= TYPE_POINTER
;
709 return t
->pointer_to
;
712 /* Return an array of length LEN. */
715 create_array (type_p t
, const char *len
)
720 v
= XCNEW (struct type
);
721 v
->kind
= TYPE_ARRAY
;
722 v
->state_number
= -type_count
;
728 /* Return a string options structure with name NAME and info INFO.
729 NEXT is the next option in the chain. */
731 create_string_option (options_p next
, const char *name
, const char *info
)
733 options_p o
= XNEW (struct options
);
734 o
->kind
= OPTION_STRING
;
737 o
->info
.string
= info
;
741 /* Create a type options structure with name NAME and info INFO. NEXT
742 is the next option in the chain. */
744 create_type_option (options_p next
, const char* name
, type_p info
)
746 options_p o
= XNEW (struct options
);
749 o
->kind
= OPTION_TYPE
;
754 /* Create a nested pointer options structure with name NAME and info
755 INFO. NEXT is the next option in the chain. */
757 create_nested_option (options_p next
, const char* name
,
758 struct nested_ptr_data
* info
)
761 o
= XNEW (struct options
);
764 o
->kind
= OPTION_NESTED
;
765 o
->info
.nested
= info
;
769 /* Return an options structure for a "nested_ptr" option. */
771 create_nested_ptr_option (options_p next
, type_p t
,
772 const char *to
, const char *from
)
774 struct nested_ptr_data
*d
= XNEW (struct nested_ptr_data
);
776 d
->type
= adjust_field_type (t
, 0);
778 d
->convert_from
= from
;
779 return create_nested_option (next
, "nested_ptr", d
);
782 /* Add a variable named S of type T with options O defined at POS,
785 note_variable (const char *s
, type_p t
, options_p o
, struct fileloc
*pos
)
788 n
= XNEW (struct pair
);
797 /* Most-general structure field creator. */
799 create_field_all (pair_p next
, type_p type
, const char *name
, options_p opt
,
800 const input_file
*inpf
, int line
)
804 field
= XNEW (struct pair
);
809 field
->line
.file
= inpf
;
810 field
->line
.line
= line
;
814 /* Create a field that came from the source code we are scanning,
815 i.e. we have a 'struct fileloc', and possibly options; also,
816 adjust_field_type should be called. */
818 create_field_at (pair_p next
, type_p type
, const char *name
, options_p opt
,
821 return create_field_all (next
, adjust_field_type (type
, opt
),
822 name
, opt
, pos
->file
, pos
->line
);
825 /* Create a fake field with the given type and name. NEXT is the next
826 field in the chain. */
827 #define create_field(next,type,name) \
828 create_field_all(next,type,name, 0, this_file, __LINE__)
830 /* Like create_field, but the field is only valid when condition COND
834 create_optional_field_ (pair_p next
, type_p type
, const char *name
,
835 const char *cond
, int line
)
841 /* Create a fake union type with a single nameless field of type TYPE.
842 The field has a tag of "1". This allows us to make the presence
843 of a field of type TYPE depend on some boolean "desc" being true. */
844 union_fields
= create_field (NULL
, type
, "");
846 create_string_option (union_fields
->opt
, "dot", "");
848 create_string_option (union_fields
->opt
, "tag", "1");
850 new_structure (xasprintf ("%s_%d", "fake_union", id
++), 1,
851 &lexer_line
, union_fields
, NULL
);
853 /* Create the field and give it the new fake union type. Add a "desc"
854 tag that specifies the condition under which the field is valid. */
855 return create_field_all (next
, union_type
, name
,
856 create_string_option (0, "desc", cond
),
860 #define create_optional_field(next,type,name,cond) \
861 create_optional_field_(next,type,name,cond,__LINE__)
863 /* Reverse a linked list of 'struct pair's in place. */
865 nreverse_pairs (pair_p list
)
867 pair_p prev
= 0, p
, next
;
868 for (p
= list
; p
; p
= next
)
878 /* We don't care how long a CONST_DOUBLE is. */
879 #define CONST_DOUBLE_FORMAT "ww"
880 /* We don't want to see codes that are only for generator files. */
881 #undef GENERATOR_FILE
885 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
891 static const char *const rtx_name
[NUM_RTX_CODE
] = {
892 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
897 static const char *const rtx_format
[NUM_RTX_CODE
] = {
898 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
903 static int rtx_next_new
[NUM_RTX_CODE
];
905 /* We also need codes and names for insn notes (not register notes).
906 Note that we do *not* bias the note values here. */
909 #define DEF_INSN_NOTE(NAME) NAME,
910 #include "insn-notes.def"
916 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
917 default field for line number notes. */
918 static const char *const note_insn_name
[NOTE_INSN_MAX
+ 1] = {
919 #define DEF_INSN_NOTE(NAME) #NAME,
920 #include "insn-notes.def"
924 #undef CONST_DOUBLE_FORMAT
925 #define GENERATOR_FILE
927 /* Generate the contents of the rtx_next array. This really doesn't belong
928 in gengtype at all, but it's needed for adjust_field_rtx_def. */
934 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
938 rtx_next_new
[i
] = -1;
939 if (strncmp (rtx_format
[i
], "iuu", 3) == 0)
941 else if (i
== COND_EXEC
|| i
== SET
|| i
== EXPR_LIST
|| i
== INSN_LIST
)
944 for (k
= strlen (rtx_format
[i
]) - 1; k
>= 0; k
--)
945 if (rtx_format
[i
][k
] == 'e' || rtx_format
[i
][k
] == 'u')
950 /* Write out the contents of the rtx_next array. */
952 write_rtx_next (void)
954 outf_p f
= get_output_file_with_visibility (NULL
);
959 oprintf (f
, "\n/* Used to implement the RTX_NEXT macro. */\n");
960 oprintf (f
, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
961 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
962 if (rtx_next_new
[i
] == -1)
963 oprintf (f
, " 0,\n");
966 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n", rtx_next_new
[i
]);
970 /* Handle `special("rtx_def")'. This is a special case for field
971 `fld' of struct rtx_def, which is an array of unions whose values
972 are based in a complex way on the type of RTL. */
975 adjust_field_rtx_def (type_p t
, options_p
ARG_UNUSED (opt
))
980 type_p rtx_tp
, rtvec_tp
, tree_tp
, mem_attrs_tp
, note_union_tp
, scalar_tp
;
981 type_p basic_block_tp
, reg_attrs_tp
, constant_tp
, symbol_union_tp
;
983 if (t
->kind
!= TYPE_UNION
)
985 error_at_line (&lexer_line
,
986 "special `rtx_def' must be applied to a union");
990 nodot
= create_string_option (NULL
, "dot", "");
992 rtx_tp
= create_pointer (find_structure ("rtx_def", 0));
993 rtvec_tp
= create_pointer (find_structure ("rtvec_def", 0));
994 tree_tp
= create_pointer (find_structure ("tree_node", 1));
995 mem_attrs_tp
= create_pointer (find_structure ("mem_attrs", 0));
997 create_pointer (find_structure ("reg_attrs", 0));
999 create_pointer (find_structure ("basic_block_def", 0));
1001 create_pointer (find_structure ("constant_descriptor_rtx", 0));
1002 scalar_tp
= &scalar_nonchar
; /* rtunion int */
1005 pair_p note_flds
= NULL
;
1008 for (c
= 0; c
<= NOTE_INSN_MAX
; c
++)
1013 case NOTE_INSN_DELETED_LABEL
:
1014 note_flds
= create_field (note_flds
, &string_type
, "rt_str");
1017 case NOTE_INSN_BLOCK_BEG
:
1018 case NOTE_INSN_BLOCK_END
:
1019 note_flds
= create_field (note_flds
, tree_tp
, "rt_tree");
1022 case NOTE_INSN_VAR_LOCATION
:
1023 case NOTE_INSN_CALL_ARG_LOCATION
:
1024 note_flds
= create_field (note_flds
, rtx_tp
, "rt_rtx");
1028 note_flds
= create_field (note_flds
, scalar_tp
, "rt_int");
1031 /* NOTE_INSN_MAX is used as the default field for line
1033 if (c
== NOTE_INSN_MAX
)
1035 create_string_option (nodot
, "default", "");
1038 create_string_option (nodot
, "tag", note_insn_name
[c
]);
1040 note_union_tp
= new_structure ("rtx_def_note_subunion", 1,
1041 &lexer_line
, note_flds
, NULL
);
1043 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1046 sym_flds
= create_field (NULL
, tree_tp
, "rt_tree");
1047 sym_flds
->opt
= create_string_option (nodot
, "default", "");
1048 sym_flds
= create_field (sym_flds
, constant_tp
, "rt_constant");
1049 sym_flds
->opt
= create_string_option (nodot
, "tag", "1");
1050 symbol_union_tp
= new_structure ("rtx_def_symbol_subunion", 1,
1051 &lexer_line
, sym_flds
, NULL
);
1053 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1055 pair_p subfields
= NULL
;
1056 size_t aindex
, nmindex
;
1061 for (aindex
= 0; aindex
< strlen (rtx_format
[i
]); aindex
++)
1064 const char *subname
;
1066 switch (rtx_format
[i
][aindex
])
1077 if (i
== MEM
&& aindex
== 1)
1078 t
= mem_attrs_tp
, subname
= "rt_mem";
1079 else if (i
== JUMP_INSN
&& aindex
== 8)
1080 t
= rtx_tp
, subname
= "rt_rtx";
1081 else if (i
== CODE_LABEL
&& aindex
== 5)
1082 t
= scalar_tp
, subname
= "rt_int";
1083 else if (i
== CODE_LABEL
&& aindex
== 4)
1084 t
= rtx_tp
, subname
= "rt_rtx";
1085 else if (i
== LABEL_REF
&& (aindex
== 1 || aindex
== 2))
1086 t
= rtx_tp
, subname
= "rt_rtx";
1087 else if (i
== NOTE
&& aindex
== 4)
1088 t
= note_union_tp
, subname
= "";
1089 else if (i
== NOTE
&& aindex
== 5)
1090 t
= scalar_tp
, subname
= "rt_int";
1091 else if (i
== NOTE
&& aindex
>= 7)
1092 t
= scalar_tp
, subname
= "rt_int";
1093 else if (i
== ADDR_DIFF_VEC
&& aindex
== 4)
1094 t
= scalar_tp
, subname
= "rt_int";
1095 else if (i
== VALUE
&& aindex
== 0)
1096 t
= scalar_tp
, subname
= "rt_int";
1097 else if (i
== DEBUG_EXPR
&& aindex
== 0)
1098 t
= tree_tp
, subname
= "rt_tree";
1099 else if (i
== REG
&& aindex
== 1)
1100 t
= scalar_tp
, subname
= "rt_int";
1101 else if (i
== REG
&& aindex
== 2)
1102 t
= reg_attrs_tp
, subname
= "rt_reg";
1103 else if (i
== SCRATCH
&& aindex
== 0)
1104 t
= scalar_tp
, subname
= "rt_int";
1105 else if (i
== SYMBOL_REF
&& aindex
== 1)
1106 t
= scalar_tp
, subname
= "rt_int";
1107 else if (i
== SYMBOL_REF
&& aindex
== 2)
1108 t
= symbol_union_tp
, subname
= "";
1109 else if (i
== BARRIER
&& aindex
>= 3)
1110 t
= scalar_tp
, subname
= "rt_int";
1111 else if (i
== ENTRY_VALUE
&& aindex
== 0)
1112 t
= rtx_tp
, subname
= "rt_rtx";
1117 "rtx type `%s' has `0' in position %lu, can't handle",
1118 rtx_name
[i
], (unsigned long) aindex
);
1140 subname
= "rt_rtvec";
1145 subname
= "rt_tree";
1156 "rtx type `%s' has `%c' in position %lu, can't handle",
1157 rtx_name
[i
], rtx_format
[i
][aindex
],
1158 (unsigned long) aindex
);
1164 subfields
= create_field (subfields
, t
,
1165 xasprintf (".fld[%lu].%s",
1166 (unsigned long) aindex
,
1168 subfields
->opt
= nodot
;
1169 if (t
== note_union_tp
)
1171 create_string_option (subfields
->opt
, "desc",
1173 if (t
== symbol_union_tp
)
1175 create_string_option (subfields
->opt
, "desc",
1176 "CONSTANT_POOL_ADDRESS_P (&%0)");
1179 if (i
== SYMBOL_REF
)
1181 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P
1183 type_p field_tp
= find_structure ("block_symbol", 0);
1185 = create_optional_field (subfields
, field_tp
, "block_sym",
1186 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1189 sname
= xasprintf ("rtx_def_%s", rtx_name
[i
]);
1190 substruct
= new_structure (sname
, 0, &lexer_line
, subfields
, NULL
);
1192 ftag
= xstrdup (rtx_name
[i
]);
1193 for (nmindex
= 0; nmindex
< strlen (ftag
); nmindex
++)
1194 ftag
[nmindex
] = TOUPPER (ftag
[nmindex
]);
1195 flds
= create_field (flds
, substruct
, "");
1196 flds
->opt
= create_string_option (nodot
, "tag", ftag
);
1198 return new_structure ("rtx_def_subunion", 1, &lexer_line
, flds
, nodot
);
1201 /* Handle `special("tree_exp")'. This is a special case for
1202 field `operands' of struct tree_exp, which although it claims to contain
1203 pointers to trees, actually sometimes contains pointers to RTL too.
1204 Passed T, the old type of the field, and OPT its options. Returns
1205 a new type for the field. */
1208 adjust_field_tree_exp (type_p t
, options_p opt ATTRIBUTE_UNUSED
)
1213 if (t
->kind
!= TYPE_ARRAY
)
1215 error_at_line (&lexer_line
,
1216 "special `tree_exp' must be applied to an array");
1217 return &string_type
;
1220 nodot
= create_string_option (NULL
, "dot", "");
1222 flds
= create_field (NULL
, t
, "");
1223 flds
->opt
= create_string_option (nodot
, "length",
1224 "TREE_OPERAND_LENGTH ((tree) &%0)");
1225 flds
->opt
= create_string_option (flds
->opt
, "default", "");
1227 return new_structure ("tree_exp_subunion", 1, &lexer_line
, flds
, nodot
);
1230 /* Perform any special processing on a type T, about to become the type
1231 of a field. Return the appropriate type for the field.
1233 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1234 - Similarly for arrays of pointer-to-char;
1235 - Converts structures for which a parameter is provided to
1237 - Handles "special" options.
1241 adjust_field_type (type_p t
, options_p opt
)
1244 const int pointer_p
= t
->kind
== TYPE_POINTER
;
1245 type_p params
[NUM_PARAM
];
1249 for (i
= 0; i
< NUM_PARAM
; i
++)
1252 for (; opt
; opt
= opt
->next
)
1253 if (strcmp (opt
->name
, "length") == 0)
1255 else if ((strcmp (opt
->name
, "param_is") == 0
1256 || (strncmp (opt
->name
, "param", 5) == 0
1257 && ISDIGIT (opt
->name
[5])
1258 && strcmp (opt
->name
+ 6, "_is") == 0))
1259 && opt
->kind
== OPTION_TYPE
)
1261 int num
= ISDIGIT (opt
->name
[5]) ? opt
->name
[5] - '0' : 0;
1263 if (!UNION_OR_STRUCT_P (t
)
1264 && (t
->kind
!= TYPE_POINTER
|| !UNION_OR_STRUCT_P (t
->u
.p
)))
1266 error_at_line (&lexer_line
,
1267 "option `%s' may only be applied to structures or structure pointers",
1273 if (params
[num
] != NULL
)
1274 error_at_line (&lexer_line
, "duplicate `%s' option", opt
->name
);
1275 if (!ISDIGIT (opt
->name
[5]))
1276 params
[num
] = create_pointer (opt
->info
.type
);
1278 params
[num
] = opt
->info
.type
;
1280 else if (strcmp (opt
->name
, "special") == 0
1281 && opt
->kind
== OPTION_STRING
)
1283 const char *special_name
= opt
->info
.string
;
1284 if (strcmp (special_name
, "tree_exp") == 0)
1285 t
= adjust_field_tree_exp (t
, opt
);
1286 else if (strcmp (special_name
, "rtx_def") == 0)
1287 t
= adjust_field_rtx_def (t
, opt
);
1289 error_at_line (&lexer_line
, "unknown special `%s'", special_name
);
1298 realt
= find_param_structure (t
, params
);
1299 t
= pointer_p
? create_pointer (realt
) : realt
;
1303 && pointer_p
&& t
->u
.p
->kind
== TYPE_SCALAR
&& t
->u
.p
->u
.scalar_is_char
)
1304 return &string_type
;
1305 if (t
->kind
== TYPE_ARRAY
&& t
->u
.a
.p
->kind
== TYPE_POINTER
1306 && t
->u
.a
.p
->u
.p
->kind
== TYPE_SCALAR
1307 && t
->u
.a
.p
->u
.p
->u
.scalar_is_char
)
1308 return create_array (&string_type
, t
->u
.a
.len
);
1314 static void set_gc_used_type (type_p
, enum gc_used_enum
, type_p
*);
1315 static void set_gc_used (pair_p
);
1317 /* Handle OPT for set_gc_used_type. */
1320 process_gc_options (options_p opt
, enum gc_used_enum level
, int *maybe_undef
,
1321 int *pass_param
, int *length
, int *skip
,
1325 for (o
= opt
; o
; o
= o
->next
)
1326 if (strcmp (o
->name
, "ptr_alias") == 0 && level
== GC_POINTED_TO
1327 && o
->kind
== OPTION_TYPE
)
1328 set_gc_used_type (o
->info
.type
,
1329 GC_POINTED_TO
, NULL
);
1330 else if (strcmp (o
->name
, "maybe_undef") == 0)
1332 else if (strcmp (o
->name
, "use_params") == 0)
1334 else if (strcmp (o
->name
, "length") == 0)
1336 else if (strcmp (o
->name
, "skip") == 0)
1338 else if (strcmp (o
->name
, "nested_ptr") == 0
1339 && o
->kind
== OPTION_NESTED
)
1340 *nested_ptr
= ((const struct nested_ptr_data
*) o
->info
.nested
)->type
;
1344 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1346 set_gc_used_type (type_p t
, enum gc_used_enum level
, type_p param
[NUM_PARAM
])
1348 if (t
->gc_used
>= level
)
1362 process_gc_options (t
->u
.s
.opt
, level
, &dummy
, &dummy
, &dummy
, &dummy
,
1365 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
1367 int maybe_undef
= 0;
1371 type_p nested_ptr
= NULL
;
1372 process_gc_options (f
->opt
, level
, &maybe_undef
, &pass_param
,
1373 &length
, &skip
, &nested_ptr
);
1375 if (nested_ptr
&& f
->type
->kind
== TYPE_POINTER
)
1376 set_gc_used_type (nested_ptr
, GC_POINTED_TO
,
1377 pass_param
? param
: NULL
);
1378 else if (length
&& f
->type
->kind
== TYPE_POINTER
)
1379 set_gc_used_type (f
->type
->u
.p
, GC_USED
, NULL
);
1380 else if (maybe_undef
&& f
->type
->kind
== TYPE_POINTER
)
1381 set_gc_used_type (f
->type
->u
.p
, GC_MAYBE_POINTED_TO
, NULL
);
1382 else if (pass_param
&& f
->type
->kind
== TYPE_POINTER
&& param
)
1383 set_gc_used_type (find_param_structure (f
->type
->u
.p
, param
),
1384 GC_POINTED_TO
, NULL
);
1386 ; /* target type is not used through this field */
1388 set_gc_used_type (f
->type
, GC_USED
, pass_param
? param
: NULL
);
1394 set_gc_used_type (t
->u
.p
, GC_POINTED_TO
, NULL
);
1398 set_gc_used_type (t
->u
.a
.p
, GC_USED
, param
);
1401 case TYPE_LANG_STRUCT
:
1402 for (t
= t
->u
.s
.lang_struct
; t
; t
= t
->next
)
1403 set_gc_used_type (t
, level
, param
);
1406 case TYPE_PARAM_STRUCT
:
1409 for (i
= 0; i
< NUM_PARAM
; i
++)
1410 if (t
->u
.param_struct
.param
[i
] != 0)
1411 set_gc_used_type (t
->u
.param_struct
.param
[i
], GC_USED
, NULL
);
1413 if (t
->u
.param_struct
.stru
->gc_used
== GC_POINTED_TO
)
1414 level
= GC_POINTED_TO
;
1417 t
->u
.param_struct
.stru
->gc_used
= GC_UNUSED
;
1418 set_gc_used_type (t
->u
.param_struct
.stru
, level
,
1419 t
->u
.param_struct
.param
);
1427 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1430 set_gc_used (pair_p variables
)
1434 for (p
= variables
; p
; p
= p
->next
)
1436 set_gc_used_type (p
->type
, GC_USED
, NULL
);
1439 if (verbosity_level
>= 2)
1440 printf ("%s used %d GTY-ed variables\n", progname
, nbvars
);
1443 /* File mapping routines. For each input file, there is one output .c file
1444 (but some output files have many input files), and there is one .h file
1445 for the whole build. */
1447 /* Output file handling. */
1449 /* Create and return an outf_p for a new file for NAME, to be called
1453 create_file (const char *name
, const char *oname
)
1455 static const char *const hdr
[] = {
1456 " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n",
1458 "This file is part of GCC.\n",
1460 "GCC is free software; you can redistribute it and/or modify it under\n",
1461 "the terms of the GNU General Public License as published by the Free\n",
1462 "Software Foundation; either version 3, or (at your option) any later\n",
1465 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1466 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1467 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1468 "for more details.\n",
1470 "You should have received a copy of the GNU General Public License\n",
1471 "along with GCC; see the file COPYING3. If not see\n",
1472 "<http://www.gnu.org/licenses/>. */\n",
1474 "/* This file is machine generated. Do not edit. */\n"
1479 gcc_assert (name
!= NULL
);
1480 gcc_assert (oname
!= NULL
);
1481 f
= XCNEW (struct outf
);
1482 f
->next
= output_files
;
1486 oprintf (f
, "/* Type information for %s.\n", name
);
1487 for (i
= 0; i
< ARRAY_SIZE (hdr
); i
++)
1488 oprintf (f
, "%s", hdr
[i
]);
1492 /* Print, like fprintf, to O.
1493 N.B. You might think this could be implemented more efficiently
1494 with vsnprintf(). Unfortunately, there are C libraries that
1495 provide that function but without the C99 semantics for its return
1496 value, making it impossible to know how much space is required. */
1498 oprintf (outf_p o
, const char *format
, ...)
1504 /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1509 va_start (ap
, format
);
1510 slength
= vasprintf (&s
, format
, ap
);
1511 if (s
== NULL
|| (int) slength
< 0)
1512 fatal ("out of memory");
1515 if (o
->bufused
+ slength
> o
->buflength
)
1517 size_t new_len
= o
->buflength
;
1524 while (o
->bufused
+ slength
>= new_len
);
1525 o
->buf
= XRESIZEVEC (char, o
->buf
, new_len
);
1526 o
->buflength
= new_len
;
1528 memcpy (o
->buf
+ o
->bufused
, s
, slength
);
1529 o
->bufused
+= slength
;
1533 /* Open the global header file and the language-specific header files. */
1536 open_base_files (void)
1540 if (nb_plugin_files
> 0 && plugin_files
)
1543 header_file
= create_file ("GCC", "gtype-desc.h");
1545 base_files
= XNEWVEC (outf_p
, num_lang_dirs
);
1547 for (i
= 0; i
< num_lang_dirs
; i
++)
1548 base_files
[i
] = create_file (lang_dir_names
[i
],
1549 xasprintf ("gtype-%s.h", lang_dir_names
[i
]));
1551 /* gtype-desc.c is a little special, so we create it here. */
1553 /* The order of files here matters very much. */
1554 static const char *const ifiles
[] = {
1555 "config.h", "system.h", "coretypes.h", "tm.h",
1556 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1557 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1558 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1559 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1560 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1561 "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h",
1562 "target.h", "ipa-prop.h", "lto-streamer.h", "target-globals.h",
1563 "ipa-inline.h", NULL
1565 const char *const *ifp
;
1566 outf_p gtype_desc_c
;
1568 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1569 for (ifp
= ifiles
; *ifp
; ifp
++)
1570 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1572 /* Make sure we handle "cfun" specially. */
1573 oprintf (gtype_desc_c
, "\n/* See definition in function.h. */\n");
1574 oprintf (gtype_desc_c
, "#undef cfun\n");
1578 /* For INPF an input file, return the real basename of INPF, with all
1579 the directory components skipped. */
1582 get_file_realbasename (const input_file
*inpf
)
1584 return lbasename (get_input_file_name (inpf
));
1587 /* For INPF a filename, return the relative path to INPF from
1588 $(srcdir) if the latter is a prefix in INPF, NULL otherwise. */
1591 get_file_srcdir_relative_path (const input_file
*inpf
)
1593 const char *f
= get_input_file_name (inpf
);
1594 if (strlen (f
) > srcdir_len
1595 && IS_DIR_SEPARATOR (f
[srcdir_len
])
1596 && strncmp (f
, srcdir
, srcdir_len
) == 0)
1597 return f
+ srcdir_len
+ 1;
1602 /* For INPF an input_file, return the relative path to INPF from
1603 $(srcdir) if the latter is a prefix in INPF, or the real basename
1604 of INPF otherwise. */
1607 get_file_basename (const input_file
*inpf
)
1609 const char *srcdir_path
= get_file_srcdir_relative_path (inpf
);
1611 return (srcdir_path
!= NULL
) ? srcdir_path
: get_file_realbasename (inpf
);
1614 /* For F a filename, return the lang_dir_names relative index of the language
1615 directory that is a prefix in F, if any, -1 otherwise. */
1618 get_prefix_langdir_index (const char *f
)
1620 size_t f_len
= strlen (f
);
1623 for (lang_index
= 0; lang_index
< num_lang_dirs
; lang_index
++)
1625 const char *langdir
= lang_dir_names
[lang_index
];
1626 size_t langdir_len
= strlen (langdir
);
1628 if (f_len
> langdir_len
1629 && IS_DIR_SEPARATOR (f
[langdir_len
])
1630 && memcmp (f
, langdir
, langdir_len
) == 0)
1637 /* For INPF an input file, return the name of language directory where
1638 F is located, if any, NULL otherwise. */
1641 get_file_langdir (const input_file
*inpf
)
1643 /* Get the relative path to INPF from $(srcdir) and find the
1644 language by comparing the prefix with language directory names.
1645 If INPF is not even srcdir relative, no point in looking
1649 const char *srcdir_relative_path
= get_file_srcdir_relative_path (inpf
);
1652 if (!srcdir_relative_path
)
1655 lang_index
= get_prefix_langdir_index (srcdir_relative_path
);
1656 if (lang_index
< 0 && strncmp (srcdir_relative_path
, "c-family", 8) == 0)
1658 else if (lang_index
>= 0)
1659 r
= lang_dir_names
[lang_index
];
1666 /* The gt- output file name for INPF. */
1669 get_file_gtfilename (const input_file
*inpf
)
1671 /* Cook up an initial version of the gt- file name from the file real
1672 basename and the language name, if any. */
1674 const char *basename
= get_file_realbasename (inpf
);
1675 const char *langdir
= get_file_langdir (inpf
);
1678 (langdir
? xasprintf ("gt-%s-%s", langdir
, basename
)
1679 : xasprintf ("gt-%s", basename
));
1681 /* Then replace all non alphanumerics characters by '-' and change the
1682 extension to ".h". We expect the input filename extension was at least
1683 one character long. */
1687 for (; *s
!= '.'; s
++)
1688 if (!ISALNUM (*s
) && *s
!= '-')
1691 memcpy (s
, ".h", sizeof (".h"));
1696 /* Each input_file has its associated output file outf_p. The
1697 association is computed by the function
1698 get_output_file_with_visibility. The associated file is cached
1699 inside input_file in its inpoutf field, so is really computed only
1700 once. Associated output file paths (i.e. output_name-s) are
1701 computed by a rule based regexp machinery, using the files_rules
1702 array of struct file_rule_st. A for_name is also computed, giving
1703 the source file name for which the output_file is generated; it is
1704 often the last component of the input_file path. */
1708 Regexpr machinery to compute the output_name and for_name-s of each
1709 input_file. We have a sequence of file rules which gives the POSIX
1710 extended regular expression to match an input file path, and two
1711 transformed strings for the corresponding output_name and the
1712 corresponding for_name. The transformed string contain dollars: $0
1713 is replaced by the entire match, $1 is replaced by the substring
1714 matching the first parenthesis in the regexp, etc. And $$ is replaced
1715 by a single verbatim dollar. The rule order is important. The
1716 general case is last, and the particular cases should come before.
1717 An action routine can, when needed, update the out_name & for_name
1718 and/or return the appropriate output file. It is invoked only when a
1719 rule is triggered. When a rule is triggered, the output_name and
1720 for_name are computed using their transform string in while $$, $0,
1721 $1, ... are suitably replaced. If there is an action, it is called.
1722 In some few cases, the action can directly return the outf_p, but
1723 usually it just updates the output_name and for_name so should free
1724 them before replacing them. The get_output_file_with_visibility
1725 function creates an outf_p only once per each output_name, so it
1726 scans the output_files list for previously seen output file names.
1729 /* Signature of actions in file rules. */
1730 typedef outf_p (frul_actionrout_t
) (input_file
*, char**, char**);
1733 struct file_rule_st
{
1734 const char* frul_srcexpr
; /* Source string for regexp. */
1735 int frul_rflags
; /* Flags passed to regcomp, usually
1737 regex_t
* frul_re
; /* Compiled regular expression
1738 obtained by regcomp. */
1739 const char* frul_tr_out
; /* Transformation string for making
1740 * the output_name, with $1 ... $9 for
1741 * subpatterns and $0 for the whole
1742 * matched filename. */
1743 const char* frul_tr_for
; /* Tranformation string for making the
1745 frul_actionrout_t
* frul_action
; /* The action, if non null, is
1746 * called once the rule matches, on
1747 * the transformed out_name &
1748 * for_name. It could change them
1749 * and/or give the output file. */
1752 /* File rule action handling *.h files. */
1753 static outf_p
header_dot_h_frul (input_file
*, char**, char**);
1755 /* File rule action handling *.c files. */
1756 static outf_p
source_dot_c_frul (input_file
*, char**, char**);
1758 #define NULL_REGEX (regex_t*)0
1760 /* The prefix in our regexp-s matching the directory. */
1761 #define DIR_PREFIX_REGEX "^(([^/]*/)*)"
1763 #define NULL_FRULACT (frul_actionrout_t*)0
1765 /* The array of our rules governing file name generation. Rules order
1766 matters, so change with extreme care! */
1768 struct file_rule_st files_rules
[] = {
1769 /* The general rule assumes that files in subdirectories belong to a
1770 particular front-end, and files not in subdirectories are shared.
1771 The following rules deal with exceptions - files that are in
1772 subdirectories and yet are shared, and files that are top-level,
1773 but are not shared. */
1775 /* the c-family/ source directory is special. */
1776 { DIR_PREFIX_REGEX
"c-family/([[:alnum:]_-]*)\\.c$",
1777 REG_EXTENDED
, NULL_REGEX
,
1778 "gt-c-family-$3.h", "c-family/$3.c", NULL_FRULACT
},
1780 { DIR_PREFIX_REGEX
"c-family/([[:alnum:]_-]*)\\.h$",
1781 REG_EXTENDED
, NULL_REGEX
,
1782 "gt-c-family-$3.h", "c-family/$3.h", NULL_FRULACT
},
1784 /* Both c-lang.h & c-tree.h gives gt-c-decl.h for c-decl.c ! */
1785 { DIR_PREFIX_REGEX
"c-lang\\.h$",
1786 REG_EXTENDED
, NULL_REGEX
, "gt-c-decl.h", "c-decl.c", NULL_FRULACT
},
1788 { DIR_PREFIX_REGEX
"c-tree\\.h$",
1789 REG_EXTENDED
, NULL_REGEX
, "gt-c-decl.h", "c-decl.c", NULL_FRULACT
},
1791 /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.c ! */
1792 { DIR_PREFIX_REGEX
"cp/cp-tree\\.h$",
1793 REG_EXTENDED
, NULL_REGEX
,
1794 "gt-cp-tree.h", "cp/tree.c", NULL_FRULACT
},
1796 /* cp/decl.h & cp/decl.c gives gt-cp-decl.h for cp/decl.c ! */
1797 { DIR_PREFIX_REGEX
"cp/decl\\.[ch]$",
1798 REG_EXTENDED
, NULL_REGEX
,
1799 "gt-cp-decl.h", "cp/decl.c", NULL_FRULACT
},
1801 /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.c ! */
1802 { DIR_PREFIX_REGEX
"cp/name-lookup\\.h$",
1803 REG_EXTENDED
, NULL_REGEX
,
1804 "gt-cp-name-lookup.h", "cp/name-lookup.c", NULL_FRULACT
},
1806 /* cp/parser.h gives gt-cp-parser.h for cp/parser.c ! */
1807 { DIR_PREFIX_REGEX
"cp/parser\\.h$",
1808 REG_EXTENDED
, NULL_REGEX
,
1809 "gt-cp-parser.h", "cp/parser.c", NULL_FRULACT
},
1811 /* objc/objc-act.h gives gt-objc-objc-act.h for objc/objc-act.c ! */
1812 { DIR_PREFIX_REGEX
"objc/objc-act\\.h$",
1813 REG_EXTENDED
, NULL_REGEX
,
1814 "gt-objc-objc-act.h", "objc/objc-act.c", NULL_FRULACT
},
1816 /* General cases. For header *.h and source *.c files, we need
1817 * special actions to handle the language. */
1819 /* Source *.c files are using get_file_gtfilename to compute their
1820 output_name and get_file_basename to compute their for_name
1821 thru the source_dot_c_frul action. */
1822 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.c$",
1823 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.c", source_dot_c_frul
},
1824 /* Common header files get "gtype-desc.c" as their output_name,
1825 * while language specific header files are handled specially. So
1826 * we need the header_dot_h_frul action. */
1827 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.h$",
1828 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.h", header_dot_h_frul
},
1830 { DIR_PREFIX_REGEX
"([[:alnum:]_-]*)\\.in$",
1831 REG_EXTENDED
, NULL_REGEX
, "gt-$3.h", "$3.in", NULL_FRULACT
},
1833 /* Mandatory null last entry signaling end of rules. */
1834 {NULL
, 0, NULL_REGEX
, NULL
, NULL
, NULL_FRULACT
}
1837 /* Special file rules action for handling *.h header files. It gives
1838 "gtype-desc.c" for common headers and corresponding output
1839 files for language-specific header files. */
1841 header_dot_h_frul (input_file
* inpf
, char**poutname
,
1842 char**pforname ATTRIBUTE_UNUSED
)
1844 const char *basename
= 0;
1846 DBGPRINTF ("inpf %p inpname %s outname %s forname %s",
1847 (void*) inpf
, get_input_file_name (inpf
),
1848 *poutname
, *pforname
);
1849 basename
= get_file_basename (inpf
);
1850 lang_index
= get_prefix_langdir_index (basename
);
1851 DBGPRINTF ("basename %s lang_index %d", basename
, lang_index
);
1853 if (lang_index
>= 0)
1855 /* The header is language specific. Given output_name &
1856 for_name remains unchanged. The base_files array gives the
1858 DBGPRINTF ("header_dot_h found language specific @ %p '%s'",
1859 (void*) base_files
[lang_index
],
1860 (base_files
[lang_index
])->name
);
1861 return base_files
[lang_index
];
1865 /* The header is common to all front-end languages. So
1866 output_name is "gtype-desc.c" file. The calling function
1867 get_output_file_with_visibility will find its outf_p. */
1869 *poutname
= xstrdup ("gtype-desc.c");
1870 DBGPRINTF ("special 'gtype-desc.c' for inpname %s",
1871 get_input_file_name (inpf
));
1877 /* Special file rules action for handling *.c source files using
1878 * get_file_gtfilename to compute their output_name and
1879 * get_file_basename to compute their for_name. The output_name is
1880 * gt-<LANG>-<BASE>.h for language specific source files, and
1881 * gt-<BASE>.h for common source files. */
1883 source_dot_c_frul (input_file
* inpf
, char**poutname
, char**pforname
)
1885 char *newbasename
= CONST_CAST (char*, get_file_basename (inpf
));
1886 char *newoutname
= CONST_CAST (char*, get_file_gtfilename (inpf
));
1887 DBGPRINTF ("inpf %p inpname %s original outname %s forname %s",
1888 (void*) inpf
, get_input_file_name (inpf
),
1889 *poutname
, *pforname
);
1890 DBGPRINTF ("newoutname %s", newoutname
);
1891 DBGPRINTF ("newbasename %s", newbasename
);
1894 *poutname
= newoutname
;
1895 *pforname
= newbasename
;
1899 /* Utility function for get_output_file_with_visibility which returns
1900 * a malloc-ed substituted string using TRS on matching of the FILNAM
1901 * file name, using the PMATCH array. */
1903 matching_file_name_substitute (const char *filnam
, regmatch_t pmatch
[10],
1906 struct obstack str_obstack
;
1908 char *rawstr
= NULL
;
1909 const char *pt
= NULL
;
1910 DBGPRINTF ("filnam %s", filnam
);
1911 obstack_init (&str_obstack
);
1912 for (pt
= trs
; *pt
; pt
++) {
1918 /* A double dollar $$ is substituted by a single verbatim
1919 dollar, but who really uses dollar signs in file
1921 obstack_1grow (&str_obstack
, '$');
1923 else if (ISDIGIT (pt
[1]))
1925 /* Handle $0 $1 ... $9 by appropriate substitution. */
1926 int dolnum
= pt
[1] - '0';
1927 int so
= pmatch
[dolnum
].rm_so
;
1928 int eo
= pmatch
[dolnum
].rm_eo
;
1929 DBGPRINTF ("so=%d eo=%d dolnum=%d", so
, eo
, dolnum
);
1930 if (so
>=0 && eo
>=so
)
1931 obstack_grow (&str_obstack
, filnam
+ so
, eo
- so
);
1935 /* This can happen only when files_rules is buggy! */
1938 /* Always skip the character after the dollar. */
1942 obstack_1grow (&str_obstack
, c
);
1944 obstack_1grow (&str_obstack
, '\0');
1945 rawstr
= XOBFINISH (&str_obstack
, char *);
1946 str
= xstrdup (rawstr
);
1947 obstack_free (&str_obstack
, NULL
);
1948 DBGPRINTF ("matched replacement %s", str
);
1954 /* An output file, suitable for definitions, that can see declarations
1955 made in INPF and is linked into every language that uses INPF.
1956 Since the result is cached inside INPF, that argument cannot be
1957 declared constant, but is "almost" constant. */
1960 get_output_file_with_visibility (input_file
*inpf
)
1963 char *for_name
= NULL
;
1964 char *output_name
= NULL
;
1965 const char* inpfname
;
1967 /* This can happen when we need a file with visibility on a
1968 structure that we've never seen. We have to just hope that it's
1969 globally visible. */
1971 inpf
= system_h_file
;
1973 /* The result is cached in INPF, so return it if already known. */
1975 return inpf
->inpoutf
;
1977 /* In plugin mode, return NULL unless the input_file is one of the
1982 for (i
= 0; i
< nb_plugin_files
; i
++)
1983 if (inpf
== plugin_files
[i
])
1985 inpf
->inpoutf
= plugin_output
;
1986 return plugin_output
;
1992 inpfname
= get_input_file_name (inpf
);
1994 /* Try each rule in sequence in files_rules until one is triggered. */
1997 DBGPRINTF ("passing input file @ %p named %s thru the files_rules",
1998 (void*) inpf
, inpfname
);
2000 for (; files_rules
[rulix
].frul_srcexpr
!= NULL
; rulix
++)
2002 DBGPRINTF ("rulix#%d srcexpr %s",
2003 rulix
, files_rules
[rulix
].frul_srcexpr
);
2005 if (!files_rules
[rulix
].frul_re
)
2007 /* Compile the regexpr lazily. */
2009 files_rules
[rulix
].frul_re
= XCNEW (regex_t
);
2010 err
= regcomp (files_rules
[rulix
].frul_re
,
2011 files_rules
[rulix
].frul_srcexpr
,
2012 files_rules
[rulix
].frul_rflags
);
2015 /* The regular expression compilation fails only when
2016 file_rules is buggy. */
2024 /* Match the regexpr and trigger the rule if matched. */
2026 /* We have exactly ten pmatch-s, one for each $0, $1, $2,
2028 regmatch_t pmatch
[10];
2029 memset (pmatch
, 0, sizeof (pmatch
));
2030 if (!regexec (files_rules
[rulix
].frul_re
,
2031 inpfname
, 10, pmatch
, 0))
2033 DBGPRINTF ("input @ %p filename %s matched rulix#%d pattern %s",
2034 (void*) inpf
, inpfname
, rulix
,
2035 files_rules
[rulix
].frul_srcexpr
);
2037 matching_file_name_substitute (inpfname
, pmatch
,
2038 files_rules
[rulix
].frul_tr_for
);
2039 DBGPRINTF ("for_name %s", for_name
);
2041 matching_file_name_substitute (inpfname
, pmatch
,
2042 files_rules
[rulix
].frul_tr_out
);
2043 DBGPRINTF ("output_name %s", output_name
);
2044 if (files_rules
[rulix
].frul_action
)
2046 /* Invoke our action routine. */
2048 DBGPRINTF ("before action rulix#%d output_name %s for_name %s",
2049 rulix
, output_name
, for_name
);
2051 (files_rules
[rulix
].frul_action
) (inpf
,
2052 &output_name
, &for_name
);
2053 DBGPRINTF ("after action rulix#%d of=%p output_name %s for_name %s",
2054 rulix
, (void*)of
, output_name
, for_name
);
2055 /* If the action routine returned something, give it back
2056 immediately and cache it in inpf. */
2063 /* The rule matched, and had no action, or that action did
2064 not return any output file but could have changed the
2065 output_name or for_name. We break out of the loop on the
2071 /* The regexpr did not match. */
2072 DBGPRINTF ("rulix#%d did not match %s pattern %s",
2073 rulix
, inpfname
, files_rules
[rulix
].frul_srcexpr
);
2079 if (!output_name
|| !for_name
)
2081 /* This is impossible, and could only happen if the files_rules is
2082 incomplete or buggy. */
2086 /* Look through to see if we've ever seen this output filename
2087 before. If found, cache the result in inpf. */
2088 for (r
= output_files
; r
; r
= r
->next
)
2089 if (filename_cmp (r
->name
, output_name
) == 0)
2092 DBGPRINTF ("found r @ %p for output_name %s for_name %s", (void*)r
,
2093 output_name
, for_name
);
2097 /* If not found, create it, and cache it in inpf. */
2098 r
= create_file (for_name
, output_name
);
2100 gcc_assert (r
&& r
->name
);
2101 DBGPRINTF ("created r @ %p for output_name %s for_name %s", (void*) r
,
2102 output_name
, for_name
);
2109 /* The name of an output file, suitable for definitions, that can see
2110 declarations made in INPF and is linked into every language that
2114 get_output_file_name (input_file
* inpf
)
2116 outf_p o
= get_output_file_with_visibility (inpf
);
2122 /* Check if existing file is equal to the in memory buffer. */
2125 is_file_equal (outf_p of
)
2127 FILE *newfile
= fopen (of
->name
, "r");
2130 if (newfile
== NULL
)
2134 for (i
= 0; i
< of
->bufused
; i
++)
2137 ch
= fgetc (newfile
);
2138 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
2148 /* Copy the output to its final destination,
2149 but don't unnecessarily change modification times. */
2152 close_output_files (void)
2154 int nbwrittenfiles
= 0;
2157 for (of
= output_files
; of
; of
= of
->next
)
2160 if (!is_file_equal (of
))
2162 FILE *newfile
= NULL
;
2163 char *backupname
= NULL
;
2164 /* Back up the old version of the output file gt-FOO.c as
2165 BACKUPDIR/gt-FOO.c~ if we have a backup directory. */
2168 backupname
= concat (backup_dir
, "/",
2169 lbasename (of
->name
), "~", NULL
);
2170 if (!access (of
->name
, F_OK
) && rename (of
->name
, backupname
))
2171 fatal ("failed to back up %s as %s: %s",
2172 of
->name
, backupname
, xstrerror (errno
));
2175 newfile
= fopen (of
->name
, "w");
2176 if (newfile
== NULL
)
2177 fatal ("opening output file %s: %s", of
->name
, xstrerror (errno
));
2178 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
2179 fatal ("writing output file %s: %s", of
->name
, xstrerror (errno
));
2180 if (fclose (newfile
) != 0)
2181 fatal ("closing output file %s: %s", of
->name
, xstrerror (errno
));
2183 if (verbosity_level
>= 2 && backupname
)
2184 printf ("%s wrote #%-3d %s backed-up in %s\n",
2185 progname
, nbwrittenfiles
, of
->name
, backupname
);
2186 else if (verbosity_level
>= 1)
2187 printf ("%s write #%-3d %s\n", progname
, nbwrittenfiles
, of
->name
);
2192 /* output file remains unchanged. */
2193 if (verbosity_level
>= 2)
2194 printf ("%s keep %s\n", progname
, of
->name
);
2198 of
->bufused
= of
->buflength
= 0;
2200 if (verbosity_level
>= 1)
2201 printf ("%s wrote %d files.\n", progname
, nbwrittenfiles
);
2208 const input_file
* file
;
2212 struct walk_type_data
;
2214 /* For scalars and strings, given the item in 'val'.
2215 For structures, given a pointer to the item in 'val'.
2216 For misc. pointers, given the item in 'val'.
2218 typedef void (*process_field_fn
) (type_p f
, const struct walk_type_data
* p
);
2219 typedef void (*func_name_fn
) (type_p s
, const struct walk_type_data
* p
);
2221 /* Parameters for write_types. */
2223 struct write_types_data
2226 const char *param_prefix
;
2227 const char *subfield_marker_routine
;
2228 const char *marker_routine
;
2229 const char *reorder_note_routine
;
2230 const char *comment
;
2231 int skip_hooks
; /* skip hook generation if non zero */
2234 static void output_escaped_param (struct walk_type_data
*d
,
2235 const char *, const char *);
2236 static void output_mangled_typename (outf_p
, const_type_p
);
2237 static void walk_type (type_p t
, struct walk_type_data
*d
);
2238 static void write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2239 const struct write_types_data
*wtd
);
2240 static void write_types_process_field
2241 (type_p f
, const struct walk_type_data
*d
);
2242 static void write_types (outf_p output_header
,
2244 type_p param_structs
,
2245 const struct write_types_data
*wtd
);
2246 static void write_types_local_process_field
2247 (type_p f
, const struct walk_type_data
*d
);
2248 static void write_local_func_for_structure
2249 (const_type_p orig_s
, type_p s
, type_p
*param
);
2250 static void write_local (outf_p output_header
,
2251 type_p structures
, type_p param_structs
);
2252 static void write_enum_defn (type_p structures
, type_p param_structs
);
2253 static int contains_scalar_p (type_p t
);
2254 static void put_mangled_filename (outf_p
, const input_file
*);
2255 static void finish_root_table (struct flist
*flp
, const char *pfx
,
2256 const char *tname
, const char *lastname
,
2258 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
2259 struct fileloc
*, const char *, bool);
2260 static void write_array (outf_p f
, pair_p v
,
2261 const struct write_types_data
*wtd
);
2262 static void write_roots (pair_p
, bool);
2264 /* Parameters for walk_type. */
2266 struct walk_type_data
2268 process_field_fn process_field
;
2273 const char *prev_val
[4];
2276 const struct fileloc
*line
;
2281 const char *reorder_fn
;
2283 bool fn_wants_lvalue
;
2286 /* Print a mangled name representing T to OF. */
2289 output_mangled_typename (outf_p of
, const_type_p t
)
2301 output_mangled_typename (of
, t
->u
.p
);
2311 case TYPE_LANG_STRUCT
:
2312 oprintf (of
, "%lu%s", (unsigned long) strlen (t
->u
.s
.tag
),
2315 case TYPE_PARAM_STRUCT
:
2318 for (i
= 0; i
< NUM_PARAM
; i
++)
2319 if (t
->u
.param_struct
.param
[i
] != NULL
)
2320 output_mangled_typename (of
, t
->u
.param_struct
.param
[i
]);
2321 output_mangled_typename (of
, t
->u
.param_struct
.stru
);
2329 /* Print PARAM to D->OF processing escapes. D->VAL references the
2330 current object, D->PREV_VAL the object containing the current
2331 object, ONAME is the name of the option and D->LINE is used to
2332 print error messages. */
2335 output_escaped_param (struct walk_type_data
*d
, const char *param
,
2340 for (p
= param
; *p
; p
++)
2342 oprintf (d
->of
, "%c", *p
);
2347 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
2350 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
2353 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
2357 const char *pp
= d
->val
+ strlen (d
->val
);
2358 while (pp
[-1] == ']')
2361 oprintf (d
->of
, "%s", pp
);
2365 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
2370 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2371 which is of type T. Write code to D->OF to constrain execution (at
2372 the point that D->PROCESS_FIELD is called) to the appropriate
2373 cases. Call D->PROCESS_FIELD on subobjects before calling it on
2374 pointers to those objects. D->PREV_VAL lists the objects
2375 containing the current object, D->OPT is a list of options to
2376 apply, D->INDENT is the current indentation level, D->LINE is used
2377 to print error messages, D->BITMAP indicates which languages to
2378 print the structure for, and D->PARAM is the current parameter
2379 (from an enclosing param_is option). */
2382 walk_type (type_p t
, struct walk_type_data
*d
)
2384 const char *length
= NULL
;
2385 const char *desc
= NULL
;
2386 int maybe_undef_p
= 0;
2387 int use_param_num
= -1;
2388 int use_params_p
= 0;
2390 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
2392 d
->needs_cast_p
= false;
2393 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
2394 if (strcmp (oo
->name
, "length") == 0 && oo
->kind
== OPTION_STRING
)
2395 length
= oo
->info
.string
;
2396 else if (strcmp (oo
->name
, "maybe_undef") == 0)
2398 else if (strncmp (oo
->name
, "use_param", 9) == 0
2399 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2400 use_param_num
= oo
->name
[9] == '\0' ? 0 : oo
->name
[9] - '0';
2401 else if (strcmp (oo
->name
, "use_params") == 0)
2403 else if (strcmp (oo
->name
, "desc") == 0 && oo
->kind
== OPTION_STRING
)
2404 desc
= oo
->info
.string
;
2405 else if (strcmp (oo
->name
, "mark_hook") == 0)
2407 else if (strcmp (oo
->name
, "nested_ptr") == 0
2408 && oo
->kind
== OPTION_NESTED
)
2409 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
.nested
;
2410 else if (strcmp (oo
->name
, "dot") == 0)
2412 else if (strcmp (oo
->name
, "tag") == 0)
2414 else if (strcmp (oo
->name
, "special") == 0)
2416 else if (strcmp (oo
->name
, "skip") == 0)
2418 else if (strcmp (oo
->name
, "default") == 0)
2420 else if (strcmp (oo
->name
, "param_is") == 0)
2422 else if (strncmp (oo
->name
, "param", 5) == 0
2423 && ISDIGIT (oo
->name
[5]) && strcmp (oo
->name
+ 6, "_is") == 0)
2425 else if (strcmp (oo
->name
, "chain_next") == 0)
2427 else if (strcmp (oo
->name
, "chain_prev") == 0)
2429 else if (strcmp (oo
->name
, "chain_circular") == 0)
2431 else if (strcmp (oo
->name
, "reorder") == 0)
2433 else if (strcmp (oo
->name
, "variable_size") == 0)
2436 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
2443 int pointer_p
= t
->kind
== TYPE_POINTER
;
2447 if (!UNION_OR_STRUCT_P (t
))
2448 error_at_line (d
->line
, "`use_params' option on unimplemented type");
2450 t
= find_param_structure (t
, d
->param
);
2452 t
= create_pointer (t
);
2455 if (use_param_num
!= -1)
2457 if (d
->param
!= NULL
&& d
->param
[use_param_num
] != NULL
)
2459 type_p nt
= d
->param
[use_param_num
];
2461 if (t
->kind
== TYPE_ARRAY
)
2462 nt
= create_array (nt
, t
->u
.a
.len
);
2463 else if (length
!= NULL
&& t
->kind
== TYPE_POINTER
)
2464 nt
= create_pointer (nt
);
2465 d
->needs_cast_p
= (t
->kind
!= TYPE_POINTER
2466 && (nt
->kind
== TYPE_POINTER
2467 || nt
->kind
== TYPE_STRING
));
2471 error_at_line (d
->line
, "no parameter defined for `%s'", d
->val
);
2475 && (t
->kind
!= TYPE_POINTER
|| !UNION_OR_STRUCT_P (t
->u
.p
)))
2477 error_at_line (d
->line
,
2478 "field `%s' has invalid option `maybe_undef_p'\n",
2487 d
->process_field (t
, d
);
2492 if (maybe_undef_p
&& t
->u
.p
->u
.s
.line
.file
== NULL
)
2494 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2500 if (!UNION_OR_STRUCT_P (t
->u
.p
)
2501 && t
->u
.p
->kind
!= TYPE_PARAM_STRUCT
)
2503 error_at_line (d
->line
,
2504 "field `%s' is pointer to unimplemented type",
2511 const char *oldprevval2
= d
->prev_val
[2];
2513 if (!UNION_OR_STRUCT_P (nested_ptr_d
->type
))
2515 error_at_line (d
->line
,
2516 "field `%s' has invalid "
2517 "option `nested_ptr'\n", d
->val
);
2521 d
->prev_val
[2] = d
->val
;
2522 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2524 d
->val
= xasprintf ("x%d", d
->counter
++);
2525 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2526 (nested_ptr_d
->type
->kind
== TYPE_UNION
2527 ? "union" : "struct"),
2528 nested_ptr_d
->type
->u
.s
.tag
,
2529 d
->fn_wants_lvalue
? "" : "const ", d
->val
);
2530 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2531 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2533 oprintf (d
->of
, ";\n");
2535 d
->process_field (nested_ptr_d
->type
, d
);
2537 if (d
->fn_wants_lvalue
)
2539 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2541 d
->prev_val
[2] = d
->val
;
2542 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2544 oprintf (d
->of
, ";\n");
2548 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2549 d
->val
= d
->prev_val
[2];
2550 d
->prev_val
[2] = oldprevval2
;
2553 d
->process_field (t
->u
.p
, d
);
2557 int loopcounter
= d
->counter
++;
2558 const char *oldval
= d
->val
;
2559 const char *oldprevval3
= d
->prev_val
[3];
2562 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2564 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2565 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
,
2566 "", loopcounter
, loopcounter
);
2567 output_escaped_param (d
, length
, "length");
2568 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2570 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2572 d
->prev_val
[3] = oldval
;
2573 walk_type (t
->u
.p
, d
);
2576 d
->prev_val
[3] = oldprevval3
;
2579 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2580 d
->process_field (t
, d
);
2582 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2589 int loopcounter
= d
->counter
++;
2590 const char *oldval
= d
->val
;
2593 /* If it's an array of scalars, we optimize by not generating
2595 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2598 /* When walking an array, compute the length and store it in a
2599 local variable before walking the array elements, instead of
2600 recomputing the length expression each time through the loop.
2601 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2602 where the length is stored in the first array element,
2603 because otherwise that operand can get overwritten on the
2605 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2607 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2608 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2609 d
->indent
, "", loopcounter
);
2611 output_escaped_param (d
, length
, "length");
2613 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2614 oprintf (d
->of
, ");\n");
2616 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2618 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2620 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2622 walk_type (t
->u
.a
.p
, d
);
2627 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2629 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2637 const char *oldval
= d
->val
;
2638 const char *oldprevval1
= d
->prev_val
[1];
2639 const char *oldprevval2
= d
->prev_val
[2];
2640 const int union_p
= t
->kind
== TYPE_UNION
;
2641 int seen_default_p
= 0;
2644 if (!t
->u
.s
.line
.file
)
2645 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2647 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2649 error_at_line (d
->line
,
2650 "structure `%s' defined for mismatching languages",
2652 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2655 /* Some things may also be defined in the structure's options. */
2656 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2657 if (!desc
&& strcmp (o
->name
, "desc") == 0
2658 && o
->kind
== OPTION_STRING
)
2659 desc
= o
->info
.string
;
2661 d
->prev_val
[2] = oldval
;
2662 d
->prev_val
[1] = oldprevval2
;
2667 error_at_line (d
->line
,
2668 "missing `desc' option for union `%s'",
2672 oprintf (d
->of
, "%*sswitch (", d
->indent
, "");
2673 output_escaped_param (d
, desc
, "desc");
2674 oprintf (d
->of
, ")\n");
2676 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2678 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
2681 const char *dot
= ".";
2682 const char *tagid
= NULL
;
2685 int use_param_p
= 0;
2688 d
->reorder_fn
= NULL
;
2689 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2690 if (strcmp (oo
->name
, "dot") == 0
2691 && oo
->kind
== OPTION_STRING
)
2692 dot
= oo
->info
.string
;
2693 else if (strcmp (oo
->name
, "tag") == 0
2694 && oo
->kind
== OPTION_STRING
)
2695 tagid
= oo
->info
.string
;
2696 else if (strcmp (oo
->name
, "skip") == 0)
2698 else if (strcmp (oo
->name
, "default") == 0)
2700 else if (strcmp (oo
->name
, "reorder") == 0
2701 && oo
->kind
== OPTION_STRING
)
2702 d
->reorder_fn
= oo
->info
.string
;
2703 else if (strncmp (oo
->name
, "use_param", 9) == 0
2704 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2710 if (union_p
&& tagid
)
2712 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
2715 else if (union_p
&& default_p
)
2717 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2721 else if (!union_p
&& (default_p
|| tagid
))
2722 error_at_line (d
->line
,
2723 "can't use `%s' outside a union on field `%s'",
2724 default_p
? "default" : "tag", f
->name
);
2725 else if (union_p
&& !(default_p
|| tagid
)
2726 && f
->type
->kind
== TYPE_SCALAR
)
2729 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2730 get_input_file_name (d
->line
->file
), d
->line
->line
,
2734 else if (union_p
&& !(default_p
|| tagid
))
2735 error_at_line (d
->line
,
2736 "field `%s' is missing `tag' or `default' option",
2740 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
2742 d
->used_length
= false;
2744 if (union_p
&& use_param_p
&& d
->param
== NULL
)
2745 oprintf (d
->of
, "%*sgcc_unreachable ();\n", d
->indent
, "");
2747 walk_type (f
->type
, d
);
2753 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2757 d
->reorder_fn
= NULL
;
2760 d
->prev_val
[1] = oldprevval1
;
2761 d
->prev_val
[2] = oldprevval2
;
2763 if (union_p
&& !seen_default_p
)
2765 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2766 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
2770 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2776 case TYPE_LANG_STRUCT
:
2779 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
2780 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
2783 error_at_line (d
->line
, "structure `%s' differs between languages",
2790 case TYPE_PARAM_STRUCT
:
2792 type_p
*oldparam
= d
->param
;
2794 d
->param
= t
->u
.param_struct
.param
;
2795 walk_type (t
->u
.param_struct
.stru
, d
);
2796 d
->param
= oldparam
;
2805 /* process_field routine for marking routines. */
2808 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
2810 const struct write_types_data
*wtd
;
2811 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
2812 wtd
= (const struct write_types_data
*) d
->cookie
;
2819 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
2820 wtd
->subfield_marker_routine
, cast
, d
->val
);
2821 if (wtd
->param_prefix
)
2823 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
2826 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
2827 output_mangled_typename (d
->of
, d
->orig_s
);
2830 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
2832 if (f
->u
.p
->kind
== TYPE_PARAM_STRUCT
2833 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2835 oprintf (d
->of
, ", gt_e_");
2836 output_mangled_typename (d
->of
, f
);
2838 else if (UNION_OR_STRUCT_P (f
) && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2840 oprintf (d
->of
, ", gt_ggc_e_");
2841 output_mangled_typename (d
->of
, f
);
2844 oprintf (d
->of
, ", gt_types_enum_last");
2846 oprintf (d
->of
, ");\n");
2847 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2848 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
2849 wtd
->reorder_note_routine
, cast
, d
->val
,
2850 d
->prev_val
[3], d
->reorder_fn
);
2856 case TYPE_LANG_STRUCT
:
2857 case TYPE_PARAM_STRUCT
:
2858 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
2859 output_mangled_typename (d
->of
, f
);
2860 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
2861 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2862 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
2863 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
2875 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2878 output_type_enum (outf_p of
, type_p s
)
2880 if (s
->kind
== TYPE_PARAM_STRUCT
&& s
->u
.param_struct
.line
.file
!= NULL
)
2882 oprintf (of
, ", gt_e_");
2883 output_mangled_typename (of
, s
);
2885 else if (UNION_OR_STRUCT_P (s
) && s
->u
.s
.line
.file
!= NULL
)
2887 oprintf (of
, ", gt_ggc_e_");
2888 output_mangled_typename (of
, s
);
2891 oprintf (of
, ", gt_types_enum_last");
2894 /* Return an output file that is suitable for definitions which can
2895 reference struct S */
2898 get_output_file_for_structure (const_type_p s
, type_p
*param
)
2900 const input_file
*fn
;
2903 gcc_assert (UNION_OR_STRUCT_P (s
));
2904 fn
= s
->u
.s
.line
.file
;
2906 /* This is a hack, and not the good kind either. */
2907 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2908 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2909 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2910 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2912 /* The call to get_output_file_with_visibility may update fn by
2913 caching its result inside, so we need the CONST_CAST. */
2914 return get_output_file_with_visibility (CONST_CAST (input_file
*, fn
));
2917 /* For S, a structure that's part of ORIG_S, and using parameters
2918 PARAM, write out a routine that:
2919 - Takes a parameter, a void * but actually of type *S
2920 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2921 field of S or its substructures and (in some cases) things
2922 that are pointed to by S.
2926 write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2927 const struct write_types_data
*wtd
)
2929 const char *chain_next
= NULL
;
2930 const char *chain_prev
= NULL
;
2931 const char *chain_circular
= NULL
;
2932 const char *mark_hook_name
= NULL
;
2934 struct walk_type_data d
;
2936 memset (&d
, 0, sizeof (d
));
2937 d
.of
= get_output_file_for_structure (s
, param
);
2938 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2939 if (strcmp (opt
->name
, "chain_next") == 0
2940 && opt
->kind
== OPTION_STRING
)
2941 chain_next
= opt
->info
.string
;
2942 else if (strcmp (opt
->name
, "chain_prev") == 0
2943 && opt
->kind
== OPTION_STRING
)
2944 chain_prev
= opt
->info
.string
;
2945 else if (strcmp (opt
->name
, "chain_circular") == 0
2946 && opt
->kind
== OPTION_STRING
)
2947 chain_circular
= opt
->info
.string
;
2948 else if (strcmp (opt
->name
, "mark_hook") == 0
2949 && opt
->kind
== OPTION_STRING
)
2950 mark_hook_name
= opt
->info
.string
;
2951 if (chain_prev
!= NULL
&& chain_next
== NULL
)
2952 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
2953 if (chain_circular
!= NULL
&& chain_next
!= NULL
)
2954 error_at_line (&s
->u
.s
.line
, "chain_circular with chain_next");
2955 if (chain_circular
!= NULL
)
2956 chain_next
= chain_circular
;
2958 d
.process_field
= write_types_process_field
;
2962 d
.line
= &s
->u
.s
.line
;
2963 d
.bitmap
= s
->u
.s
.bitmap
;
2965 d
.prev_val
[0] = "*x";
2966 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2967 d
.prev_val
[3] = "x";
2970 oprintf (d
.of
, "\n");
2971 oprintf (d
.of
, "void\n");
2973 oprintf (d
.of
, "gt_%sx_%s", wtd
->prefix
, orig_s
->u
.s
.tag
);
2976 oprintf (d
.of
, "gt_%s_", wtd
->prefix
);
2977 output_mangled_typename (d
.of
, orig_s
);
2979 oprintf (d
.of
, " (void *x_p)\n");
2980 oprintf (d
.of
, "{\n");
2981 oprintf (d
.of
, " %s %s * %sx = (%s %s *)x_p;\n",
2982 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2983 chain_next
== NULL
? "const " : "",
2984 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2985 if (chain_next
!= NULL
)
2986 oprintf (d
.of
, " %s %s * xlimit = x;\n",
2987 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2988 if (chain_next
== NULL
)
2990 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
2991 if (wtd
->param_prefix
)
2993 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
2994 output_mangled_typename (d
.of
, orig_s
);
2995 output_type_enum (d
.of
, orig_s
);
2997 oprintf (d
.of
, "))\n");
3001 if (chain_circular
!= NULL
)
3002 oprintf (d
.of
, " if (!%s (xlimit", wtd
->marker_routine
);
3004 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
3005 if (wtd
->param_prefix
)
3007 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
3008 output_mangled_typename (d
.of
, orig_s
);
3009 output_type_enum (d
.of
, orig_s
);
3011 oprintf (d
.of
, "))\n");
3012 if (chain_circular
!= NULL
)
3013 oprintf (d
.of
, " return;\n do\n");
3014 if (mark_hook_name
&& !wtd
->skip_hooks
)
3016 oprintf (d
.of
, " {\n");
3017 oprintf (d
.of
, " %s (xlimit);\n ", mark_hook_name
);
3019 oprintf (d
.of
, " xlimit = (");
3020 d
.prev_val
[2] = "*xlimit";
3021 output_escaped_param (&d
, chain_next
, "chain_next");
3022 oprintf (d
.of
, ");\n");
3023 if (mark_hook_name
&& !wtd
->skip_hooks
)
3024 oprintf (d
.of
, " }\n");
3025 if (chain_prev
!= NULL
)
3027 oprintf (d
.of
, " if (x != xlimit)\n");
3028 oprintf (d
.of
, " for (;;)\n");
3029 oprintf (d
.of
, " {\n");
3030 oprintf (d
.of
, " %s %s * const xprev = (",
3031 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
3033 d
.prev_val
[2] = "*x";
3034 output_escaped_param (&d
, chain_prev
, "chain_prev");
3035 oprintf (d
.of
, ");\n");
3036 oprintf (d
.of
, " if (xprev == NULL) break;\n");
3037 oprintf (d
.of
, " x = xprev;\n");
3038 oprintf (d
.of
, " (void) %s (xprev", wtd
->marker_routine
);
3039 if (wtd
->param_prefix
)
3041 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
3042 output_mangled_typename (d
.of
, orig_s
);
3043 output_type_enum (d
.of
, orig_s
);
3045 oprintf (d
.of
, ");\n");
3046 oprintf (d
.of
, " }\n");
3048 if (chain_circular
!= NULL
)
3050 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
3051 if (wtd
->param_prefix
)
3053 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
3054 output_mangled_typename (d
.of
, orig_s
);
3055 output_type_enum (d
.of
, orig_s
);
3057 oprintf (d
.of
, "));\n");
3058 if (mark_hook_name
&& !wtd
->skip_hooks
)
3059 oprintf (d
.of
, " %s (xlimit);\n", mark_hook_name
);
3060 oprintf (d
.of
, " do\n");
3063 oprintf (d
.of
, " while (x != xlimit)\n");
3065 oprintf (d
.of
, " {\n");
3066 if (mark_hook_name
&& chain_next
== NULL
&& !wtd
->skip_hooks
)
3068 oprintf (d
.of
, " %s (x);\n", mark_hook_name
);
3070 d
.prev_val
[2] = "*x";
3074 if (chain_next
!= NULL
)
3076 oprintf (d
.of
, " x = (");
3077 output_escaped_param (&d
, chain_next
, "chain_next");
3078 oprintf (d
.of
, ");\n");
3081 oprintf (d
.of
, " }\n");
3082 if (chain_circular
!= NULL
)
3083 oprintf (d
.of
, " while (x != xlimit);\n");
3084 oprintf (d
.of
, "}\n");
3087 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
3090 write_types (outf_p output_header
, type_p structures
, type_p param_structs
,
3091 const struct write_types_data
*wtd
)
3093 int nbfun
= 0; /* Count the emitted functions. */
3096 oprintf (output_header
, "\n/* %s*/\n", wtd
->comment
);
3097 /* We first emit the macros and the declarations. Functions' code is
3098 emitted afterwards. This is needed in plugin mode. */
3099 oprintf (output_header
, "/* macros and declarations */\n");
3100 for (s
= structures
; s
; s
= s
->next
)
3101 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3105 if (s
->gc_used
== GC_MAYBE_POINTED_TO
&& s
->u
.s
.line
.file
== NULL
)
3108 oprintf (output_header
, "#define gt_%s_", wtd
->prefix
);
3109 output_mangled_typename (output_header
, s
);
3110 oprintf (output_header
, "(X) do { \\\n");
3111 oprintf (output_header
,
3112 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
3114 oprintf (output_header
, " } while (0)\n");
3116 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3117 if (strcmp (opt
->name
, "ptr_alias") == 0
3118 && opt
->kind
== OPTION_TYPE
)
3120 const_type_p
const t
= (const_type_p
) opt
->info
.type
;
3121 if (t
->kind
== TYPE_STRUCT
3122 || t
->kind
== TYPE_UNION
|| t
->kind
== TYPE_LANG_STRUCT
)
3123 oprintf (output_header
,
3124 "#define gt_%sx_%s gt_%sx_%s\n",
3125 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t
->u
.s
.tag
);
3127 error_at_line (&s
->u
.s
.line
,
3128 "structure alias is not a structure");
3134 /* Declare the marker procedure only once. */
3135 oprintf (output_header
,
3136 "extern void gt_%sx_%s (void *);\n",
3137 wtd
->prefix
, s
->u
.s
.tag
);
3139 if (s
->u
.s
.line
.file
== NULL
)
3141 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3147 for (s
= param_structs
; s
; s
= s
->next
)
3148 if (s
->gc_used
== GC_POINTED_TO
)
3150 type_p stru
= s
->u
.param_struct
.stru
;
3152 /* Declare the marker procedure. */
3153 oprintf (output_header
, "extern void gt_%s_", wtd
->prefix
);
3154 output_mangled_typename (output_header
, s
);
3155 oprintf (output_header
, " (void *);\n");
3157 if (stru
->u
.s
.line
.file
== NULL
)
3159 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3165 /* At last we emit the functions code. */
3166 oprintf (output_header
, "\n/* functions code */\n");
3167 for (s
= structures
; s
; s
= s
->next
)
3168 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3172 if (s
->gc_used
== GC_MAYBE_POINTED_TO
&& s
->u
.s
.line
.file
== NULL
)
3174 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3175 if (strcmp (opt
->name
, "ptr_alias") == 0)
3180 if (s
->kind
== TYPE_LANG_STRUCT
)
3183 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3186 DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'",
3187 nbfun
, (void*) ss
, ss
->u
.s
.tag
);
3188 write_func_for_structure (s
, ss
, NULL
, wtd
);
3194 DBGPRINTF ("writing func #%d struct s @ %p '%s'",
3195 nbfun
, (void*) s
, s
->u
.s
.tag
);
3196 write_func_for_structure (s
, s
, NULL
, wtd
);
3201 /* Structure s is not possibly pointed to, so can be ignored. */
3202 DBGPRINTF ("ignored s @ %p '%s' gc_used#%d",
3203 (void*)s
, s
->u
.s
.tag
,
3207 for (s
= param_structs
; s
; s
= s
->next
)
3208 if (s
->gc_used
== GC_POINTED_TO
)
3210 type_p
*param
= s
->u
.param_struct
.param
;
3211 type_p stru
= s
->u
.param_struct
.stru
;
3212 if (stru
->u
.s
.line
.file
== NULL
)
3214 if (stru
->kind
== TYPE_LANG_STRUCT
)
3217 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3220 DBGPRINTF ("writing func #%d param lang_struct ss @ %p '%s'",
3221 nbfun
, (void*) ss
, ss
->u
.s
.tag
);
3222 write_func_for_structure (s
, ss
, param
, wtd
);
3228 DBGPRINTF ("writing func #%d param struct s @ %p stru @ %p '%s'",
3230 (void*) stru
, stru
->u
.s
.tag
);
3231 write_func_for_structure (s
, stru
, param
, wtd
);
3236 /* Param structure s is not pointed to, so should be ignored. */
3237 DBGPRINTF ("ignored s @ %p", (void*)s
);
3239 if (verbosity_level
>= 2)
3240 printf ("%s emitted %d routines for %s\n",
3241 progname
, nbfun
, wtd
->comment
);
3244 static const struct write_types_data ggc_wtd
= {
3245 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
3246 "GC marker procedures. ",
3250 static const struct write_types_data pch_wtd
= {
3251 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
3252 "gt_pch_note_reorder",
3253 "PCH type-walking procedures. ",
3257 /* Write out the local pointer-walking routines. */
3259 /* process_field routine for local pointer-walking. */
3262 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
3269 case TYPE_LANG_STRUCT
:
3270 case TYPE_PARAM_STRUCT
:
3272 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
3274 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
3285 /* For S, a structure that's part of ORIG_S, and using parameters
3286 PARAM, write out a routine that:
3287 - Is of type gt_note_pointers
3288 - Calls PROCESS_FIELD on each field of S or its substructures.
3292 write_local_func_for_structure (const_type_p orig_s
, type_p s
, type_p
*param
)
3294 struct walk_type_data d
;
3296 memset (&d
, 0, sizeof (d
));
3297 d
.of
= get_output_file_for_structure (s
, param
);
3298 d
.process_field
= write_types_local_process_field
;
3300 d
.line
= &s
->u
.s
.line
;
3301 d
.bitmap
= s
->u
.s
.bitmap
;
3303 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
3304 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
3305 d
.prev_val
[3] = "x";
3307 d
.fn_wants_lvalue
= true;
3309 oprintf (d
.of
, "\n");
3310 oprintf (d
.of
, "void\n");
3311 oprintf (d
.of
, "gt_pch_p_");
3312 output_mangled_typename (d
.of
, orig_s
);
3313 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
3315 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3316 "\tATTRIBUTE_UNUSED void *cookie)\n");
3317 oprintf (d
.of
, "{\n");
3318 oprintf (d
.of
, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
3319 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
3320 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
3323 oprintf (d
.of
, "}\n");
3326 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
3329 write_local (outf_p output_header
, type_p structures
, type_p param_structs
)
3335 oprintf (output_header
, "\n/* Local pointer-walking routines. */\n");
3336 for (s
= structures
; s
; s
= s
->next
)
3337 if (s
->gc_used
== GC_POINTED_TO
|| s
->gc_used
== GC_MAYBE_POINTED_TO
)
3341 if (s
->u
.s
.line
.file
== NULL
)
3343 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
3344 if (strcmp (opt
->name
, "ptr_alias") == 0
3345 && opt
->kind
== OPTION_TYPE
)
3347 const_type_p
const t
= (const_type_p
) opt
->info
.type
;
3348 if (t
->kind
== TYPE_STRUCT
3349 || t
->kind
== TYPE_UNION
|| t
->kind
== TYPE_LANG_STRUCT
)
3351 oprintf (output_header
, "#define gt_pch_p_");
3352 output_mangled_typename (output_header
, s
);
3353 oprintf (output_header
, " gt_pch_p_");
3354 output_mangled_typename (output_header
, t
);
3355 oprintf (output_header
, "\n");
3358 error_at_line (&s
->u
.s
.line
,
3359 "structure alias is not a structure");
3365 /* Declare the marker procedure only once. */
3366 oprintf (output_header
, "extern void gt_pch_p_");
3367 output_mangled_typename (output_header
, s
);
3368 oprintf (output_header
,
3369 "\n (void *, void *, gt_pointer_operator, void *);\n");
3371 if (s
->kind
== TYPE_LANG_STRUCT
)
3374 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3375 write_local_func_for_structure (s
, ss
, NULL
);
3378 write_local_func_for_structure (s
, s
, NULL
);
3381 for (s
= param_structs
; s
; s
= s
->next
)
3382 if (s
->gc_used
== GC_POINTED_TO
)
3384 type_p
*param
= s
->u
.param_struct
.param
;
3385 type_p stru
= s
->u
.param_struct
.stru
;
3387 /* Declare the marker procedure. */
3388 oprintf (output_header
, "extern void gt_pch_p_");
3389 output_mangled_typename (output_header
, s
);
3390 oprintf (output_header
,
3391 "\n (void *, void *, gt_pointer_operator, void *);\n");
3393 if (stru
->u
.s
.line
.file
== NULL
)
3395 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
3400 if (stru
->kind
== TYPE_LANG_STRUCT
)
3403 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
3404 write_local_func_for_structure (s
, ss
, param
);
3407 write_local_func_for_structure (s
, stru
, param
);
3411 /* Nonzero if S is a type for which typed GC allocators should be output. */
3413 #define USED_BY_TYPED_GC_P(s) \
3414 (((s->kind == TYPE_POINTER) \
3415 && ((s->u.p->gc_used == GC_POINTED_TO) \
3416 || (s->u.p->gc_used == GC_USED))) \
3417 || (UNION_OR_STRUCT_P (s) && \
3418 (((s)->gc_used == GC_POINTED_TO) \
3419 || ((s)->gc_used == GC_MAYBE_POINTED_TO \
3420 && s->u.s.line.file != NULL) \
3421 || ((s)->gc_used == GC_USED \
3422 && strncmp (s->u.s.tag, "anonymous", strlen ("anonymous"))))))
3425 /* Write out the 'enum' definition for gt_types_enum. */
3428 write_enum_defn (type_p structures
, type_p param_structs
)
3432 int nbparamstruct
= 0;
3436 oprintf (header_file
, "\n/* Enumeration of types known. */\n");
3437 oprintf (header_file
, "enum gt_types_enum {\n");
3438 for (s
= structures
; s
; s
= s
->next
)
3439 if (USED_BY_TYPED_GC_P (s
))
3442 DBGPRINTF ("write_enum_defn s @ %p nbstruct %d",
3443 (void*) s
, nbstruct
);
3444 if (UNION_OR_STRUCT_P (s
))
3445 DBGPRINTF ("write_enum_defn s %p #%d is unionorstruct tagged %s",
3446 (void*) s
, nbstruct
, s
->u
.s
.tag
);
3447 oprintf (header_file
, " gt_ggc_e_");
3448 output_mangled_typename (header_file
, s
);
3449 oprintf (header_file
, ",\n");
3451 for (s
= param_structs
; s
; s
= s
->next
)
3452 if (s
->gc_used
== GC_POINTED_TO
)
3455 DBGPRINTF ("write_enum_defn s %p nbparamstruct %d",
3456 (void*) s
, nbparamstruct
);
3457 oprintf (header_file
, " gt_e_");
3458 output_mangled_typename (header_file
, s
);
3459 oprintf (header_file
, ",\n");
3461 oprintf (header_file
, " gt_types_enum_last\n");
3462 oprintf (header_file
, "};\n");
3463 if (verbosity_level
>= 2)
3464 printf ("%s handled %d GTY-ed structures & %d parameterized structures.\n",
3465 progname
, nbstruct
, nbparamstruct
);
3469 /* Might T contain any non-pointer elements? */
3472 contains_scalar_p (type_p t
)
3480 return contains_scalar_p (t
->u
.a
.p
);
3482 /* Could also check for structures that have no non-pointer
3483 fields, but there aren't enough of those to worry about. */
3488 /* Mangle INPF and print it to F. */
3491 put_mangled_filename (outf_p f
, const input_file
*inpf
)
3493 /* The call to get_output_file_name may indirectly update fn since
3494 get_output_file_with_visibility caches its result inside, so we
3495 need the CONST_CAST. */
3496 const char *name
= get_output_file_name (CONST_CAST (input_file
*, inpf
));
3499 for (; *name
!= 0; name
++)
3500 if (ISALNUM (*name
))
3501 oprintf (f
, "%c", *name
);
3503 oprintf (f
, "%c", '_');
3506 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
3507 LASTNAME, and NAME are all strings to insert in various places in
3508 the resulting code. */
3511 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
3512 const char *tname
, const char *name
)
3516 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3517 if (fli2
->started_p
)
3519 oprintf (fli2
->f
, " %s\n", lastname
);
3520 oprintf (fli2
->f
, "};\n\n");
3523 for (fli2
= flp
; fli2
&& base_files
; fli2
= fli2
->next
)
3524 if (fli2
->started_p
)
3526 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
3529 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
3532 oprintf (base_files
[fnum
],
3533 "extern const struct %s gt_%s_", tname
, pfx
);
3534 put_mangled_filename (base_files
[fnum
], fli2
->file
);
3535 oprintf (base_files
[fnum
], "[];\n");
3541 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3542 oprintf (base_files
[fnum
],
3543 "EXPORTED_CONST struct %s * const %s[] = {\n", tname
, name
);
3547 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
3548 if (fli2
->started_p
)
3550 lang_bitmap bitmap
= get_lang_bitmap (fli2
->file
);
3553 fli2
->started_p
= 0;
3555 for (fnum
= 0; base_files
&& bitmap
!= 0; fnum
++, bitmap
>>= 1)
3558 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
3559 put_mangled_filename (base_files
[fnum
], fli2
->file
);
3560 oprintf (base_files
[fnum
], ",\n");
3566 for (fnum
= 0; base_files
&& fnum
< num_lang_dirs
; fnum
++)
3568 oprintf (base_files
[fnum
], " NULL\n");
3569 oprintf (base_files
[fnum
], "};\n");
3574 /* Write the first three fields (pointer, count and stride) for
3575 root NAME to F. V and LINE are as for write_root.
3577 Return true if the entry could be written; return false on error. */
3580 start_root_entry (outf_p f
, pair_p v
, const char *name
, struct fileloc
*line
)
3586 error_at_line (line
, "`%s' is too complex to be a root", name
);
3590 oprintf (f
, " {\n");
3591 oprintf (f
, " &%s,\n", name
);
3594 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3596 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
3597 else if (ap
== v
->type
)
3598 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
3600 oprintf (f
, " sizeof (%s", v
->name
);
3601 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3603 oprintf (f
, "),\n");
3607 /* A subroutine of write_root for writing the roots for field FIELD_NAME,
3608 which has type FIELD_TYPE. Parameters F to EMIT_PCH are the parameters
3612 write_field_root (outf_p f
, pair_p v
, type_p type
, const char *name
,
3613 int has_length
, struct fileloc
*line
, const char *if_marked
,
3614 bool emit_pch
, type_p field_type
, const char *field_name
)
3616 /* If the field reference is relative to V, rather than to some
3617 subcomponent of V, we can mark any subarrays with a single stride.
3618 We're effectively treating the field as a global variable in its
3620 if (v
&& type
== v
->type
)
3625 newv
.type
= field_type
;
3626 newv
.name
= ACONCAT ((v
->name
, ".", field_name
, NULL
));
3629 /* Otherwise, any arrays nested in the structure are too complex to
3631 else if (field_type
->kind
== TYPE_ARRAY
)
3633 write_root (f
, v
, field_type
, ACONCAT ((name
, ".", field_name
, NULL
)),
3634 has_length
, line
, if_marked
, emit_pch
);
3637 /* Write out to F the table entry and any marker routines needed to
3638 mark NAME as TYPE. V can be one of three values:
3640 - null, if NAME is too complex to represent using a single
3641 count and stride. In this case, it is an error for NAME to
3642 contain any gc-ed data.
3644 - the outermost array that contains NAME, if NAME is part of an array.
3646 - the C variable that contains NAME, if NAME is not part of an array.
3648 LINE is the line of the C source that declares the root variable.
3649 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
3650 is nonzero iff we are building the root table for hash table caches. */
3653 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
3654 struct fileloc
*line
, const char *if_marked
, bool emit_pch
)
3661 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
3664 const char *desc
= NULL
;
3667 for (o
= fld
->opt
; o
; o
= o
->next
)
3668 if (strcmp (o
->name
, "skip") == 0)
3670 else if (strcmp (o
->name
, "desc") == 0
3671 && o
->kind
== OPTION_STRING
)
3672 desc
= o
->info
.string
;
3673 else if (strcmp (o
->name
, "param_is") == 0)
3676 error_at_line (line
,
3677 "field `%s' of global `%s' has unknown option `%s'",
3678 fld
->name
, name
, o
->name
);
3682 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
3684 pair_p validf
= NULL
;
3687 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
3689 const char *tag
= NULL
;
3691 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
3692 if (strcmp (oo
->name
, "tag") == 0
3693 && oo
->kind
== OPTION_STRING
)
3694 tag
= oo
->info
.string
;
3695 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
3698 error_at_line (line
,
3699 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3700 name
, fld
->name
, validf
->name
,
3701 name
, fld
->name
, ufld
->name
, tag
);
3705 write_field_root (f
, v
, type
, name
, 0, line
, if_marked
,
3706 emit_pch
, validf
->type
,
3707 ACONCAT ((fld
->name
, ".",
3708 validf
->name
, NULL
)));
3711 error_at_line (line
,
3712 "global `%s.%s' has `desc' option but is not union",
3715 write_field_root (f
, v
, type
, name
, 0, line
, if_marked
,
3716 emit_pch
, fld
->type
, fld
->name
);
3724 newname
= xasprintf ("%s[0]", name
);
3725 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, if_marked
,
3735 if (!start_root_entry (f
, v
, name
, line
))
3740 if (!has_length
&& UNION_OR_STRUCT_P (tp
))
3742 oprintf (f
, " >_ggc_mx_%s,\n", tp
->u
.s
.tag
);
3744 oprintf (f
, " >_pch_nx_%s", tp
->u
.s
.tag
);
3746 oprintf (f
, " NULL");
3748 else if (!has_length
&& tp
->kind
== TYPE_PARAM_STRUCT
)
3750 oprintf (f
, " >_ggc_m_");
3751 output_mangled_typename (f
, tp
);
3754 oprintf (f
, ",\n >_pch_n_");
3755 output_mangled_typename (f
, tp
);
3758 oprintf (f
, ",\n NULL");
3761 && (tp
->kind
== TYPE_POINTER
|| UNION_OR_STRUCT_P (tp
)))
3763 oprintf (f
, " >_ggc_ma_%s,\n", name
);
3765 oprintf (f
, " >_pch_na_%s", name
);
3767 oprintf (f
, " NULL");
3771 error_at_line (line
,
3772 "global `%s' is pointer to unimplemented type",
3776 oprintf (f
, ",\n &%s", if_marked
);
3777 oprintf (f
, "\n },\n");
3783 if (!start_root_entry (f
, v
, name
, line
))
3786 oprintf (f
, " (gt_pointer_walker) >_ggc_m_S,\n");
3787 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
3788 oprintf (f
, " },\n");
3796 error_at_line (line
, "global `%s' is unimplemented type", name
);
3800 /* This generates a routine to walk an array. */
3803 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
3805 struct walk_type_data d
;
3808 memset (&d
, 0, sizeof (d
));
3814 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
3817 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
3819 if (wtd
->param_prefix
)
3821 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
3822 oprintf (f
, " (void *, void *, gt_pointer_operator, void *);\n");
3823 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3824 wtd
->param_prefix
, v
->name
);
3826 " ATTRIBUTE_UNUSED void *x_p,\n"
3827 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3828 " ATTRIBUTE_UNUSED void * cookie)\n");
3829 oprintf (d
.of
, "{\n");
3830 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3831 d
.process_field
= write_types_local_process_field
;
3832 walk_type (v
->type
, &d
);
3833 oprintf (f
, "}\n\n");
3837 oprintf (f
, "static void gt_%sa_%s (void *);\n", wtd
->prefix
, v
->name
);
3838 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3839 wtd
->prefix
, v
->name
);
3841 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3842 d
.process_field
= write_types_process_field
;
3843 walk_type (v
->type
, &d
);
3845 oprintf (f
, "}\n\n");
3848 /* Output a table describing the locations and types of VARIABLES. */
3851 write_roots (pair_p variables
, bool emit_pch
)
3854 struct flist
*flp
= NULL
;
3856 for (v
= variables
; v
; v
= v
->next
)
3859 get_output_file_with_visibility (CONST_CAST (input_file
*,
3862 const char *length
= NULL
;
3863 int deletable_p
= 0;
3865 for (o
= v
->opt
; o
; o
= o
->next
)
3866 if (strcmp (o
->name
, "length") == 0
3867 && o
->kind
== OPTION_STRING
)
3868 length
= o
->info
.string
;
3869 else if (strcmp (o
->name
, "deletable") == 0)
3871 else if (strcmp (o
->name
, "param_is") == 0)
3873 else if (strncmp (o
->name
, "param", 5) == 0
3874 && ISDIGIT (o
->name
[5]) && strcmp (o
->name
+ 6, "_is") == 0)
3876 else if (strcmp (o
->name
, "if_marked") == 0)
3879 error_at_line (&v
->line
,
3880 "global `%s' has unknown option `%s'",
3883 for (fli
= flp
; fli
; fli
= fli
->next
)
3884 if (fli
->f
== f
&& f
)
3888 fli
= XNEW (struct flist
);
3892 fli
->file
= v
->line
.file
;
3893 gcc_assert (fli
->file
);
3896 oprintf (f
, "\n/* GC roots. */\n\n");
3901 && v
->type
->kind
== TYPE_POINTER
3902 && (v
->type
->u
.p
->kind
== TYPE_POINTER
3903 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
3905 write_array (f
, v
, &ggc_wtd
);
3906 write_array (f
, v
, &pch_wtd
);
3910 for (v
= variables
; v
; v
= v
->next
)
3912 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
3919 for (o
= v
->opt
; o
; o
= o
->next
)
3920 if (strcmp (o
->name
, "length") == 0)
3922 else if (strcmp (o
->name
, "deletable") == 0
3923 || strcmp (o
->name
, "if_marked") == 0)
3929 for (fli
= flp
; fli
; fli
= fli
->next
)
3932 if (!fli
->started_p
)
3936 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3937 put_mangled_filename (f
, v
->line
.file
);
3938 oprintf (f
, "[] = {\n");
3941 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
, emit_pch
);
3944 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3947 for (v
= variables
; v
; v
= v
->next
)
3949 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
3955 for (o
= v
->opt
; o
; o
= o
->next
)
3956 if (strcmp (o
->name
, "deletable") == 0)
3958 else if (strcmp (o
->name
, "if_marked") == 0)
3964 for (fli
= flp
; fli
; fli
= fli
->next
)
3967 if (!fli
->started_p
)
3971 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3972 put_mangled_filename (f
, v
->line
.file
);
3973 oprintf (f
, "[] = {\n");
3976 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3980 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3981 "gt_ggc_deletable_rtab");
3983 for (v
= variables
; v
; v
= v
->next
)
3985 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
3988 const char *if_marked
= NULL
;
3992 for (o
= v
->opt
; o
; o
= o
->next
)
3993 if (strcmp (o
->name
, "length") == 0)
3995 else if (strcmp (o
->name
, "if_marked") == 0
3996 && o
->kind
== OPTION_STRING
)
3997 if_marked
= o
->info
.string
;
3998 if (if_marked
== NULL
)
4000 if (v
->type
->kind
!= TYPE_POINTER
4001 || v
->type
->u
.p
->kind
!= TYPE_PARAM_STRUCT
4002 || v
->type
->u
.p
->u
.param_struct
.stru
!= find_structure ("htab", 0))
4004 error_at_line (&v
->line
,
4005 "if_marked option used but not hash table");
4009 for (fli
= flp
; fli
; fli
= fli
->next
)
4012 if (!fli
->started_p
)
4016 oprintf (f
, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
4017 put_mangled_filename (f
, v
->line
.file
);
4018 oprintf (f
, "[] = {\n");
4021 write_root (f
, v
, v
->type
->u
.p
->u
.param_struct
.param
[0],
4022 v
->name
, length_p
, &v
->line
, if_marked
, emit_pch
);
4025 finish_root_table (flp
, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
4026 "gt_ggc_cache_rtab");
4031 for (v
= variables
; v
; v
= v
->next
)
4033 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4037 int if_marked_p
= 0;
4040 for (o
= v
->opt
; o
; o
= o
->next
)
4041 if (strcmp (o
->name
, "length") == 0)
4043 else if (strcmp (o
->name
, "if_marked") == 0)
4049 for (fli
= flp
; fli
; fli
= fli
->next
)
4052 if (!fli
->started_p
)
4056 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
4057 put_mangled_filename (f
, v
->line
.file
);
4058 oprintf (f
, "[] = {\n");
4061 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
, emit_pch
);
4064 finish_root_table (flp
, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4065 "gt_pch_cache_rtab");
4067 for (v
= variables
; v
; v
= v
->next
)
4069 outf_p f
= get_output_file_with_visibility (CONST_CAST (input_file
*,
4075 for (o
= v
->opt
; o
; o
= o
->next
)
4076 if (strcmp (o
->name
, "deletable") == 0
4077 || strcmp (o
->name
, "if_marked") == 0)
4083 if (!contains_scalar_p (v
->type
))
4086 for (fli
= flp
; fli
; fli
= fli
->next
)
4089 if (!fli
->started_p
)
4093 oprintf (f
, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
4094 put_mangled_filename (f
, v
->line
.file
);
4095 oprintf (f
, "[] = {\n");
4098 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
4102 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4103 "gt_pch_scalar_rtab");
4106 /* Record the definition of a generic VEC structure, as if we had expanded
4107 the macros in vec.h:
4109 typedef struct VEC_<type>_base GTY(()) {
4112 <type> GTY((length ("%h.num"))) vec[1];
4115 where the GTY(()) tags are only present if is_scalar is _false_. */
4118 note_def_vec (const char *type_name
, bool is_scalar
, struct fileloc
*pos
)
4123 type_p len_ty
= create_scalar_type ("unsigned");
4124 const char *name
= concat ("VEC_", type_name
, "_base", (char *) 0);
4128 t
= create_scalar_type (type_name
);
4133 t
= resolve_typedef (type_name
, pos
);
4134 o
= create_string_option (0, "length", "%h.num");
4136 /* We assemble the field list in reverse order. */
4137 fields
= create_field_at (0, create_array (t
, "1"), "vec", o
, pos
);
4138 fields
= create_field_at (fields
, len_ty
, "alloc", 0, pos
);
4139 fields
= create_field_at (fields
, len_ty
, "num", 0, pos
);
4141 do_typedef (name
, new_structure (name
, 0, pos
, fields
, 0), pos
);
4144 /* Record the definition of an allocation-specific VEC structure, as if
4145 we had expanded the macros in vec.h:
4147 typedef struct VEC_<type>_<astrat> {
4148 VEC_<type>_base base;
4149 } VEC_<type>_<astrat>;
4152 note_def_vec_alloc (const char *type
, const char *astrat
, struct fileloc
*pos
)
4154 const char *astratname
= concat ("VEC_", type
, "_", astrat
, (char *) 0);
4155 const char *basename
= concat ("VEC_", type
, "_base", (char *) 0);
4157 pair_p field
= create_field_at (0, resolve_typedef (basename
, pos
),
4160 do_typedef (astratname
, new_structure (astratname
, 0, pos
, field
, 0), pos
);
4163 /* Returns the specifier keyword for a string or union type S, empty string
4167 get_type_specifier (const type_p s
)
4169 if (s
->kind
== TYPE_STRUCT
|| s
->kind
== TYPE_LANG_STRUCT
)
4171 if (s
->kind
== TYPE_UNION
)
4176 /* TRUE if type S has the GTY variable_size annotation. */
4179 variable_size_p (const type_p s
)
4182 for (o
= s
->u
.s
.opt
; o
; o
= o
->next
)
4183 if (strcmp (o
->name
, "variable_size") == 0)
4191 { any_zone
, specific_zone
};
4193 /* Writes one typed allocator definition into output F for type
4194 identifier TYPE_NAME with optional type specifier TYPE_SPECIFIER.
4195 The allocator name will contain ALLOCATOR_TYPE. If VARIABLE_SIZE
4196 is true, the allocator will have an extra parameter specifying
4197 number of bytes to allocate. If QUANTITY is set to VECTOR, a
4198 vector allocator will be output, if ZONE is set to SPECIFIC_ZONE,
4199 the allocator will be zone-specific. */
4202 write_typed_alloc_def (outf_p f
,
4203 bool variable_size
, const char *type_specifier
,
4204 const char *type_name
, const char *allocator_type
,
4205 enum alloc_quantity quantity
, enum alloc_zone zone
)
4207 bool two_args
= variable_size
&& (quantity
== vector
);
4208 bool third_arg
= ((zone
== specific_zone
)
4209 && (variable_size
|| (quantity
== vector
)));
4210 gcc_assert (f
!= NULL
);
4211 oprintf (f
, "#define ggc_alloc_%s%s", allocator_type
, type_name
);
4212 oprintf (f
, "(%s%s%s%s%s) ",
4213 (variable_size
? "SIZE" : ""),
4214 (two_args
? ", " : ""),
4215 (quantity
== vector
) ? "n" : "",
4216 (third_arg
? ", " : ""), (zone
== specific_zone
) ? "z" : "");
4217 oprintf (f
, "((%s%s *)", type_specifier
, type_name
);
4218 oprintf (f
, "(ggc_internal_%salloc_stat (", allocator_type
);
4219 if (zone
== specific_zone
)
4222 oprintf (f
, "SIZE");
4224 oprintf (f
, "sizeof (%s%s)", type_specifier
, type_name
);
4225 if (quantity
== vector
)
4227 oprintf (f
, " MEM_STAT_INFO)))\n");
4230 /* Writes a typed allocator definition into output F for a struct or
4231 union S, with a given ALLOCATOR_TYPE and QUANTITY for ZONE. */
4234 write_typed_struct_alloc_def (outf_p f
,
4235 const type_p s
, const char *allocator_type
,
4236 enum alloc_quantity quantity
,
4237 enum alloc_zone zone
)
4239 gcc_assert (UNION_OR_STRUCT_P (s
));
4240 write_typed_alloc_def (f
, variable_size_p (s
), get_type_specifier (s
),
4241 s
->u
.s
.tag
, allocator_type
, quantity
, zone
);
4244 /* Writes a typed allocator definition into output F for a typedef P,
4245 with a given ALLOCATOR_TYPE and QUANTITY for ZONE. */
4248 write_typed_typedef_alloc_def (outf_p f
,
4249 const pair_p p
, const char *allocator_type
,
4250 enum alloc_quantity quantity
,
4251 enum alloc_zone zone
)
4253 write_typed_alloc_def (f
, variable_size_p (p
->type
), "", p
->name
,
4254 allocator_type
, quantity
, zone
);
4257 /* Writes typed allocator definitions into output F for the types in
4258 STRUCTURES and TYPEDEFS that are used by GC. */
4261 write_typed_alloc_defns (outf_p f
,
4262 const type_p structures
, const pair_p typedefs
)
4267 gcc_assert (f
!= NULL
);
4269 "\n/* Allocators for known structs and unions. */\n\n");
4270 for (s
= structures
; s
; s
= s
->next
)
4272 if (!USED_BY_TYPED_GC_P (s
))
4274 gcc_assert (UNION_OR_STRUCT_P (s
));
4275 /* In plugin mode onput output ggc_alloc macro definitions
4276 relevant to plugin input files. */
4277 if (nb_plugin_files
> 0
4278 && ((s
->u
.s
.line
.file
== NULL
) || !s
->u
.s
.line
.file
->inpisplugin
))
4280 write_typed_struct_alloc_def (f
, s
, "", single
, any_zone
);
4281 write_typed_struct_alloc_def (f
, s
, "cleared_", single
, any_zone
);
4282 write_typed_struct_alloc_def (f
, s
, "vec_", vector
, any_zone
);
4283 write_typed_struct_alloc_def (f
, s
, "cleared_vec_", vector
, any_zone
);
4284 write_typed_struct_alloc_def (f
, s
, "zone_", single
, specific_zone
);
4285 write_typed_struct_alloc_def (f
, s
, "zone_cleared_", single
,
4287 write_typed_struct_alloc_def (f
, s
, "zone_vec_", vector
, specific_zone
);
4288 write_typed_struct_alloc_def (f
, s
, "zone_cleared_vec_", vector
,
4292 oprintf (f
, "\n/* Allocators for known typedefs. */\n");
4293 for (p
= typedefs
; p
; p
= p
->next
)
4296 if (!USED_BY_TYPED_GC_P (s
) || (strcmp (p
->name
, s
->u
.s
.tag
) == 0))
4298 /* In plugin mode onput output ggc_alloc macro definitions
4299 relevant to plugin input files. */
4300 if (nb_plugin_files
> 0)
4302 struct fileloc
* filoc
= type_fileloc(s
);
4303 if (!filoc
|| !filoc
->file
->inpisplugin
)
4306 write_typed_typedef_alloc_def (f
, p
, "", single
, any_zone
);
4307 write_typed_typedef_alloc_def (f
, p
, "cleared_", single
, any_zone
);
4308 write_typed_typedef_alloc_def (f
, p
, "vec_", vector
, any_zone
);
4309 write_typed_typedef_alloc_def (f
, p
, "cleared_vec_", vector
, any_zone
);
4310 write_typed_typedef_alloc_def (f
, p
, "zone_", single
, specific_zone
);
4311 write_typed_typedef_alloc_def (f
, p
, "zone_cleared_", single
,
4313 write_typed_typedef_alloc_def (f
, p
, "zone_cleared_vec_", vector
,
4318 /* Prints not-as-ugly version of a typename of T to OF. Trades the uniquness
4319 guaranteee for somewhat increased readability. If name conflicts do happen,
4320 this funcion will have to be adjusted to be more like
4321 output_mangled_typename. */
4324 output_typename (outf_p of
, const_type_p t
)
4329 oprintf (of
, "str");
4332 oprintf (of
, "scalar");
4335 output_typename (of
, t
->u
.p
);
4339 case TYPE_LANG_STRUCT
:
4340 oprintf (of
, "%s", t
->u
.s
.tag
);
4342 case TYPE_PARAM_STRUCT
:
4345 for (i
= 0; i
< NUM_PARAM
; i
++)
4346 if (t
->u
.param_struct
.param
[i
] != NULL
)
4348 output_typename (of
, t
->u
.param_struct
.param
[i
]);
4351 output_typename (of
, t
->u
.param_struct
.stru
);
4359 /* Writes a typed GC allocator for type S that is suitable as a callback for
4360 the splay tree implementation in libiberty. */
4363 write_splay_tree_allocator_def (const_type_p s
)
4365 outf_p of
= get_output_file_with_visibility (NULL
);
4366 oprintf (of
, "void * ggc_alloc_splay_tree_");
4367 output_typename (of
, s
);
4368 oprintf (of
, " (int sz, void * nl)\n");
4369 oprintf (of
, "{\n");
4370 oprintf (of
, " return ggc_splay_alloc (");
4371 oprintf (of
, "gt_e_");
4372 output_mangled_typename (of
, s
);
4373 oprintf (of
, ", sz, nl);\n");
4374 oprintf (of
, "}\n\n");
4377 /* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks
4378 for the splay tree implementation in libiberty. */
4381 write_splay_tree_allocators (const_type_p param_structs
)
4385 oprintf (header_file
, "\n/* Splay tree callback allocators. */\n");
4386 for (s
= param_structs
; s
; s
= s
->next
)
4387 if (s
->gc_used
== GC_POINTED_TO
)
4389 oprintf (header_file
, "extern void * ggc_alloc_splay_tree_");
4390 output_typename (header_file
, s
);
4391 oprintf (header_file
, " (int, void *);\n");
4392 write_splay_tree_allocator_def (s
);
4396 static void dump_pair (int indent
, pair_p p
);
4397 static void dump_type (int indent
, type_p p
);
4398 static void dump_type_list (int indent
, type_p p
);
4402 /* Dumps the value of typekind KIND. */
4405 dump_typekind (int indent
, enum typekind kind
)
4407 printf ("%*ckind = ", indent
, ' ');
4411 printf ("TYPE_SCALAR");
4414 printf ("TYPE_STRING");
4417 printf ("TYPE_STRUCT");
4420 printf ("TYPE_UNION");
4423 printf ("TYPE_POINTER");
4426 printf ("TYPE_ARRAY");
4428 case TYPE_LANG_STRUCT
:
4429 printf ("TYPE_LANG_STRUCT");
4431 case TYPE_PARAM_STRUCT
:
4432 printf ("TYPE_PARAM_STRUCT");
4440 /* Dumps the value of GC_USED flag. */
4443 dump_gc_used (int indent
, enum gc_used_enum gc_used
)
4445 printf ("%*cgc_used = ", indent
, ' ');
4449 printf ("GC_UNUSED");
4454 case GC_MAYBE_POINTED_TO
:
4455 printf ("GC_MAYBE_POINTED_TO");
4458 printf ("GC_POINTED_TO");
4466 /* Dumps the type options OPT. */
4469 dump_options (int indent
, options_p opt
)
4472 printf ("%*coptions = ", indent
, ' ');
4479 printf ("%s:string %s ", o
->name
, o
->info
.string
);
4482 printf ("%s:type ", o
->name
);
4483 dump_type (indent
+1, o
->info
.type
);
4486 printf ("%s:nested ", o
->name
);
4496 /* Dumps the source file location in LINE. */
4499 dump_fileloc (int indent
, struct fileloc line
)
4501 printf ("%*cfileloc: file = %s, line = %d\n", indent
, ' ',
4502 get_input_file_name (line
.file
),
4506 /* Recursively dumps the struct, union, or a language-specific
4510 dump_type_u_s (int indent
, type_p t
)
4514 gcc_assert (t
->kind
== TYPE_STRUCT
|| t
->kind
== TYPE_UNION
4515 || t
->kind
== TYPE_LANG_STRUCT
);
4516 printf ("%*cu.s.tag = %s\n", indent
, ' ', t
->u
.s
.tag
);
4517 dump_fileloc (indent
, t
->u
.s
.line
);
4518 printf ("%*cu.s.fields =\n", indent
, ' ');
4519 fields
= t
->u
.s
.fields
;
4522 dump_pair (indent
+ INDENT
, fields
);
4523 fields
= fields
->next
;
4525 printf ("%*cend of fields of type %p\n", indent
, ' ', (void *) t
);
4526 dump_options (indent
, t
->u
.s
.opt
);
4527 printf ("%*cu.s.bitmap = %X\n", indent
, ' ', t
->u
.s
.bitmap
);
4528 if (t
->kind
== TYPE_LANG_STRUCT
)
4530 printf ("%*cu.s.lang_struct:\n", indent
, ' ');
4531 dump_type_list (indent
+ INDENT
, t
->u
.s
.lang_struct
);
4535 /* Recursively dumps the array T. */
4538 dump_type_u_a (int indent
, type_p t
)
4540 gcc_assert (t
->kind
== TYPE_ARRAY
);
4541 printf ("%*clen = %s, u.a.p:\n", indent
, ' ', t
->u
.a
.len
);
4542 dump_type_list (indent
+ INDENT
, t
->u
.a
.p
);
4545 /* Recursively dumps the parameterized struct T. */
4548 dump_type_u_param_struct (int indent
, type_p t
)
4551 gcc_assert (t
->kind
== TYPE_PARAM_STRUCT
);
4552 printf ("%*cu.param_struct.stru:\n", indent
, ' ');
4553 dump_type_list (indent
, t
->u
.param_struct
.stru
);
4554 dump_fileloc (indent
, t
->u
.param_struct
.line
);
4555 for (i
= 0; i
< NUM_PARAM
; i
++)
4557 if (t
->u
.param_struct
.param
[i
] == NULL
)
4559 printf ("%*cu.param_struct.param[%d]:\n", indent
, ' ', i
);
4560 dump_type (indent
+ INDENT
, t
->u
.param_struct
.param
[i
]);
4564 /* Recursively dumps the type list T. */
4567 dump_type_list (int indent
, type_p t
)
4572 dump_type (indent
, p
);
4577 static htab_t seen_types
;
4579 /* Recursively dumps the type T if it was not dumped previously. */
4582 dump_type (int indent
, type_p t
)
4586 printf ("%*cType at %p: ", indent
, ' ', (void *) t
);
4587 slot
= htab_find_slot (seen_types
, t
, INSERT
);
4590 printf ("already seen.\n");
4596 dump_typekind (indent
, t
->kind
);
4597 printf ("%*cpointer_to = %p\n", indent
+ INDENT
, ' ',
4598 (void *) t
->pointer_to
);
4599 dump_gc_used (indent
+ INDENT
, t
->gc_used
);
4603 printf ("%*cscalar_is_char = %s\n", indent
+ INDENT
, ' ',
4604 t
->u
.scalar_is_char
? "true" : "false");
4610 case TYPE_LANG_STRUCT
:
4611 dump_type_u_s (indent
+ INDENT
, t
);
4614 printf ("%*cp:\n", indent
+ INDENT
, ' ');
4615 dump_type (indent
+ INDENT
, t
->u
.p
);
4618 dump_type_u_a (indent
+ INDENT
, t
);
4620 case TYPE_PARAM_STRUCT
:
4621 dump_type_u_param_struct (indent
+ INDENT
, t
);
4626 printf ("%*cEnd of type at %p\n", indent
, ' ', (void *) t
);
4629 /* Dumps the pair P. */
4632 dump_pair (int indent
, pair_p p
)
4634 printf ("%*cpair: name = %s\n", indent
, ' ', p
->name
);
4635 dump_type (indent
, p
->type
);
4636 dump_fileloc (indent
, p
->line
);
4637 dump_options (indent
, p
->opt
);
4638 printf ("%*cEnd of pair %s\n", indent
, ' ', p
->name
);
4641 /* Dumps the list of pairs PP. */
4644 dump_pair_list (const char *name
, pair_p pp
)
4647 printf ("%s:\n", name
);
4648 for (p
= pp
; p
!= NULL
; p
= p
->next
)
4650 printf ("End of %s\n\n", name
);
4653 /* Dumps the STRUCTURES. */
4656 dump_structures (const char *name
, type_p structures
)
4658 printf ("%s:\n", name
);
4659 dump_type_list (0, structures
);
4660 printf ("End of %s\n\n", name
);
4663 /* Dumps the internal structures of gengtype. This is useful to debug
4664 gengtype itself, or to understand what it does, e.g. for plugin
4668 dump_everything (void)
4670 seen_types
= htab_create (100, htab_hash_pointer
, htab_eq_pointer
, NULL
);
4671 dump_pair_list ("typedefs", typedefs
);
4672 dump_structures ("structures", structures
);
4673 dump_structures ("param_structs", param_structs
);
4674 dump_pair_list ("variables", variables
);
4675 htab_delete (seen_types
);
4680 /* Option specification for getopt_long. */
4681 static const struct option gengtype_long_options
[] = {
4682 {"help", no_argument
, NULL
, 'h'},
4683 {"version", no_argument
, NULL
, 'V'},
4684 {"verbose", no_argument
, NULL
, 'v'},
4685 {"dump", no_argument
, NULL
, 'd'},
4686 {"debug", no_argument
, NULL
, 'D'},
4687 {"plugin", required_argument
, NULL
, 'P'},
4688 {"srcdir", required_argument
, NULL
, 'S'},
4689 {"backupdir", required_argument
, NULL
, 'B'},
4690 {"inputs", required_argument
, NULL
, 'I'},
4691 {"read-state", required_argument
, NULL
, 'r'},
4692 {"write-state", required_argument
, NULL
, 'w'},
4693 /* Terminating NULL placeholder. */
4694 {NULL
, no_argument
, NULL
, 0},
4701 printf ("Usage: %s\n", progname
);
4702 printf ("\t -h | --help " " \t# Give this help.\n");
4703 printf ("\t -D | --debug "
4704 " \t# Give debug output to debug %s itself.\n", progname
);
4705 printf ("\t -V | --version " " \t# Give version information.\n");
4706 printf ("\t -v | --verbose \t# Increase verbosity. Can be given several times.\n");
4707 printf ("\t -d | --dump " " \t# Dump state for debugging.\n");
4708 printf ("\t -P | --plugin <output-file> <plugin-src> ... "
4709 " \t# Generate for plugin.\n");
4710 printf ("\t -S | --srcdir <GCC-directory> "
4711 " \t# Specify the GCC source directory.\n");
4712 printf ("\t -B | --backupdir <directory> "
4713 " \t# Specify the backup directory for updated files.\n");
4714 printf ("\t -I | --inputs <input-list> "
4715 " \t# Specify the file with source files list.\n");
4716 printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n");
4717 printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n");
4721 print_version (void)
4723 printf ("%s %s%s\n", progname
, pkgversion_string
, version_string
);
4724 printf ("Report bugs: %s\n", bug_report_url
);
4727 /* Parse the program options using getopt_long... */
4729 parse_program_options (int argc
, char **argv
)
4732 while ((opt
= getopt_long (argc
, argv
, "hVvdP:S:B:I:w:r:D",
4733 gengtype_long_options
, NULL
)) >= 0)
4737 case 'h': /* --help */
4740 case 'V': /* --version */
4743 case 'd': /* --dump */
4746 case 'D': /* --debug */
4749 case 'v': /* --verbose */
4752 case 'P': /* --plugin */
4754 plugin_output_filename
= optarg
;
4756 fatal ("missing plugin output file name");
4758 case 'S': /* --srcdir */
4762 fatal ("missing source directory");
4763 srcdir_len
= strlen (srcdir
);
4765 case 'B': /* --backupdir */
4767 backup_dir
= optarg
;
4769 fatal ("missing backup directory");
4771 case 'I': /* --inputs */
4775 fatal ("missing input list");
4777 case 'r': /* --read-state */
4779 read_state_filename
= optarg
;
4781 fatal ("missing read state file");
4782 DBGPRINTF ("read state %s\n", optarg
);
4784 case 'w': /* --write-state */
4785 DBGPRINTF ("write state %s\n", optarg
);
4787 write_state_filename
= optarg
;
4789 fatal ("missing write state file");
4792 fprintf (stderr
, "%s: unknown flag '%c'\n", progname
, opt
);
4794 fatal ("unexpected flag");
4797 if (plugin_output_filename
)
4799 /* In plugin mode we require some input files. */
4802 fatal ("no source files given in plugin mode");
4803 nb_plugin_files
= argc
- optind
;
4804 plugin_files
= XNEWVEC (input_file
*, nb_plugin_files
);
4805 for (i
= 0; i
< (int) nb_plugin_files
; i
++)
4807 char *name
= argv
[i
+ optind
];
4808 plugin_files
[i
] = input_file_by_name (name
);
4815 /******* Manage input files. ******/
4817 /* Hash table of unique input file names. */
4818 static htab_t input_file_htab
;
4820 /* Find or allocate a new input_file by hash-consing it. */
4822 input_file_by_name (const char* name
)
4825 input_file
* f
= NULL
;
4829 namlen
= strlen (name
);
4830 f
= XCNEWVAR (input_file
, sizeof (input_file
)+namlen
+2);
4833 f
->inpisplugin
= false;
4834 strcpy (f
->inpname
, name
);
4835 slot
= htab_find_slot (input_file_htab
, f
, INSERT
);
4836 gcc_assert (slot
!= NULL
);
4839 /* Already known input file. */
4841 return (input_file
*)(*slot
);
4843 /* New input file. */
4848 /* Hash table support routines for input_file-s. */
4850 htab_hash_inputfile (const void *p
)
4852 const input_file
*inpf
= (const input_file
*) p
;
4854 return htab_hash_string (get_input_file_name (inpf
));
4858 htab_eq_inputfile (const void *x
, const void *y
)
4860 const input_file
*inpfx
= (const input_file
*) x
;
4861 const input_file
*inpfy
= (const input_file
*) y
;
4862 gcc_assert (inpfx
!= NULL
&& inpfy
!= NULL
);
4863 return !filename_cmp (get_input_file_name (inpfx
), get_input_file_name (inpfy
));
4868 main (int argc
, char **argv
)
4871 static struct fileloc pos
= { NULL
, 0 };
4872 outf_p output_header
;
4874 /* Mandatory common initializations. */
4875 progname
= "gengtype"; /* For fatal and messages. */
4876 /* Create the hash-table used to hash-cons input files. */
4878 htab_create (800, htab_hash_inputfile
, htab_eq_inputfile
, NULL
);
4879 /* Initialize our special input files. */
4880 this_file
= input_file_by_name (__FILE__
);
4881 system_h_file
= input_file_by_name ("system.h");
4882 /* Set the scalar_is_char union number for predefined scalar types. */
4883 scalar_nonchar
.u
.scalar_is_char
= FALSE
;
4884 scalar_char
.u
.scalar_is_char
= TRUE
;
4886 parse_program_options (argc
, argv
);
4891 time_t now
= (time_t) 0;
4893 DBGPRINTF ("gengtype started pid %d at %s",
4894 (int) getpid (), ctime (&now
));
4896 #endif /* ENABLE_CHECKING */
4898 /* Parse the input list and the input files. */
4899 DBGPRINTF ("inputlist %s", inputlist
);
4900 if (read_state_filename
)
4903 fatal ("input list %s cannot be given with a read state file %s",
4904 inputlist
, read_state_filename
);
4905 read_state (read_state_filename
);
4906 DBGPRINT_COUNT_TYPE ("structures after read_state", structures
);
4907 DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs
);
4911 /* These types are set up with #define or else outside of where
4912 we can see them. We should initialize them before calling
4914 #define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \
4916 POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos
));
4917 POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos
));
4918 POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos
));
4919 POS_HERE (do_scalar_typedef ("double_int", &pos
));
4920 POS_HERE (do_scalar_typedef ("uint64_t", &pos
));
4921 POS_HERE (do_scalar_typedef ("uint8", &pos
));
4922 POS_HERE (do_scalar_typedef ("jword", &pos
));
4923 POS_HERE (do_scalar_typedef ("JCF_u2", &pos
));
4924 POS_HERE (do_scalar_typedef ("void", &pos
));
4925 POS_HERE (do_typedef ("PTR",
4926 create_pointer (resolve_typedef ("void", &pos
)),
4929 read_input_list (inputlist
);
4930 for (i
= 0; i
< num_gt_files
; i
++)
4932 parse_file (get_input_file_name (gt_files
[i
]));
4933 DBGPRINTF ("parsed file #%d %s",
4934 (int) i
, get_input_file_name (gt_files
[i
]));
4936 if (verbosity_level
>= 1)
4937 printf ("%s parsed %d files with %d GTY types\n",
4938 progname
, (int) num_gt_files
, type_count
);
4940 DBGPRINT_COUNT_TYPE ("structures after parsing", structures
);
4941 DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs
);
4945 fatal ("either an input list or a read state file should be given");
4950 if (plugin_output_filename
)
4953 /* In plugin mode, we should have read a state file, and have
4954 given at least one plugin file. */
4955 if (!read_state_filename
)
4956 fatal ("No read state given in plugin mode for %s",
4957 plugin_output_filename
);
4959 if (nb_plugin_files
== 0 || !plugin_files
)
4960 fatal ("No plugin files given in plugin mode for %s",
4961 plugin_output_filename
);
4963 /* Parse our plugin files and augment the state. */
4964 for (ix
= 0; ix
< nb_plugin_files
; ix
++)
4966 input_file
* pluginput
= plugin_files
[ix
];
4967 pluginput
->inpisplugin
= true;
4968 parse_file (get_input_file_name (pluginput
));
4973 plugin_output
= create_file ("GCC", plugin_output_filename
);
4974 DBGPRINTF ("created plugin_output %p named %s",
4975 (void *) plugin_output
, plugin_output
->name
);
4978 { /* No plugin files, we are in normal mode. */
4980 fatal ("gengtype needs a source directory in normal mode");
4987 /* The call to set_gc_used may indirectly call find_param_structure
4988 hence enlarge the param_structs list of types. */
4989 set_gc_used (variables
);
4991 /* The state at this point is read from the state input file or by
4992 parsing source files and optionally augmented by parsing plugin
4993 source files. Write it now. */
4994 if (write_state_filename
)
4996 DBGPRINT_COUNT_TYPE ("structures before write_state", structures
);
4997 DBGPRINT_COUNT_TYPE ("param_structs before write_state", param_structs
);
5000 fatal ("didn't write state file %s after errors",
5001 write_state_filename
);
5003 DBGPRINTF ("before write_state %s", write_state_filename
);
5004 write_state (write_state_filename
);
5009 /* After having written the state file we return immediately to
5010 avoid generating any output file. */
5020 write_enum_defn (structures
, param_structs
);
5021 output_header
= plugin_output
? plugin_output
: header_file
;
5022 write_typed_alloc_defns (output_header
, structures
, typedefs
);
5023 DBGPRINT_COUNT_TYPE ("structures before write_types outputheader",
5025 DBGPRINT_COUNT_TYPE ("param_structs before write_types outputheader",
5028 write_types (output_header
, structures
, param_structs
, &ggc_wtd
);
5029 if (plugin_files
== NULL
)
5031 DBGPRINT_COUNT_TYPE ("structures before write_types headerfil",
5033 DBGPRINT_COUNT_TYPE ("param_structs before write_types headerfil",
5035 write_types (header_file
, structures
, param_structs
, &pch_wtd
);
5036 write_local (header_file
, structures
, param_structs
);
5038 write_splay_tree_allocators (param_structs
);
5039 write_roots (variables
, plugin_files
== NULL
);
5041 close_output_files ();
5046 /* Don't bother about free-ing any input or plugin file, etc. */