1 /* Process source files and output type information.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
24 #include "errors.h" /* for fatal */
25 #include "double-int.h"
27 /* Data types, macros, etc. used only in this file. */
29 /* Kinds of types we can understand. */
41 typedef unsigned lang_bitmap
;
43 /* A way to pass data through to the output end. */
51 /* Option data for the 'nested_ptr' option. */
52 struct nested_ptr_data
55 const char *convert_to
;
56 const char *convert_from
;
59 /* A name and a type. */
71 /* A description of a type. */
85 enum gc_used_enum gc_used
;
103 type_p param
[NUM_PARAM
];
110 ((x)->kind == TYPE_UNION || \
111 ((x)->kind == TYPE_LANG_STRUCT \
112 && (x)->u.s.lang_struct->kind == TYPE_UNION))
113 #define UNION_OR_STRUCT_P(x) \
114 ((x)->kind == TYPE_UNION \
115 || (x)->kind == TYPE_STRUCT \
116 || (x)->kind == TYPE_LANG_STRUCT)
118 /* Structure representing an output file. */
127 typedef struct outf
* outf_p
;
129 /* An output file, suitable for definitions, that can see declarations
130 made in INPUT_FILE and is linked into every language that uses
132 extern outf_p get_output_file_with_visibility
133 (const char *input_file
);
134 const char *get_output_file_name (const char *);
136 /* Print, like fprintf, to O. */
137 static void oprintf (outf_p o
, const char *S
, ...)
140 /* The list of output files. */
141 static outf_p output_files
;
143 /* The output header file that is included into pretty much every
145 static outf_p header_file
;
147 /* Source directory. */
148 static const char *srcdir
;
150 /* Length of srcdir name. */
151 static int srcdir_len
= 0;
153 static outf_p
create_file (const char *, const char *);
154 static const char * get_file_basename (const char *);
157 /* Nonzero iff an error has occurred. */
158 bool hit_error
= false;
160 static void gen_rtx_next (void);
161 static void write_rtx_next (void);
162 static void open_base_files (void);
163 static void close_output_files (void);
165 /* Report an error at POS, printing MSG. */
168 error_at_line (struct fileloc
*pos
, const char *msg
, ...)
174 fprintf (stderr
, "%s:%d: ", pos
->file
, pos
->line
);
175 vfprintf (stderr
, msg
, ap
);
176 fputc ('\n', stderr
);
182 /* asprintf, but produces fatal message on out-of-memory. */
184 xasprintf (const char *format
, ...)
190 va_start (ap
, format
);
191 n
= vasprintf (&result
, format
, ap
);
192 if (result
== NULL
|| n
< 0)
193 fatal ("out of memory");
199 /* Input file handling. */
201 /* Table of all input files. */
202 static const char **gt_files
;
203 static size_t num_gt_files
;
205 /* A number of places use the name of this file for a location for
206 things that we can't rely on the source to define. Make sure we
207 can still use pointer comparison on filenames. */
208 static const char this_file
[] = __FILE__
;
210 /* Vector of per-language directories. */
211 static const char **lang_dir_names
;
212 static size_t num_lang_dirs
;
214 /* An array of output files suitable for definitions. There is one
215 BASE_FILES entry for each language. */
216 static outf_p
*base_files
;
218 /* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
219 INPUT_FILE is used by <lang>.
221 This function should be written to assume that a file _is_ used
222 if the situation is unclear. If it wrongly assumes a file _is_ used,
223 a linker error will result. If it wrongly assumes a file _is not_ used,
224 some GC roots may be missed, which is a much harder-to-debug problem.
226 The relevant bitmap is stored immediately before the file's name in the
227 buffer set up by read_input_list. It may be unaligned, so we have to
228 read it byte-by-byte. */
231 get_lang_bitmap (const char *gtfile
)
234 if (gtfile
== this_file
)
235 /* Things defined in this file are universal. */
236 return (((lang_bitmap
)1) << num_lang_dirs
) - 1;
241 for (i
= -(int) sizeof (lang_bitmap
); i
< 0; i
++)
242 n
= (n
<< CHAR_BIT
) + (unsigned char)gtfile
[i
];
247 /* Set the bitmap returned by get_lang_bitmap. The only legitimate
248 caller of this function is read_input_list. */
250 set_lang_bitmap (char *gtfile
, lang_bitmap n
)
253 for (i
= -1; i
>= -(int) sizeof (lang_bitmap
); i
--)
255 gtfile
[i
] = n
& ((1U << CHAR_BIT
)-1);
260 /* Scan the input file, LIST, and determine how much space we need to
261 store strings in. Also, count the number of language directories
262 and files. The numbers returned are overestimates as they does not
263 consider repeated files. */
265 measure_input_list (FILE *list
)
272 while ((c
= getc (list
)) != EOF
)
281 /* Add space for a lang_bitmap before the input file name. */
282 n
+= sizeof (lang_bitmap
);
296 /* Read one input line from LIST to HEREP (which is updated). A
297 pointer to the string is returned via LINEP. If it was a language
298 subdirectory in square brackets, strip off the square brackets and
299 return true. Otherwise, leave space before the string for a
300 lang_bitmap, and return false. At EOF, returns false, does not
301 touch *HEREP, and sets *LINEP to NULL. POS is used for
304 read_input_line (FILE *list
, char **herep
, char **linep
,
318 /* No space for a lang_bitmap is necessary. Discard the '['. */
321 while (c
!= ']' && c
!= '\n' && c
!= EOF
)
330 c
= getc (list
); /* eat what should be a newline */
331 if (c
!= '\n' && c
!= EOF
)
332 error_at_line (pos
, "junk on line after language tag [%s]", line
);
335 error_at_line (pos
, "missing close bracket for language tag [%s", line
);
343 /* Leave space for a lang_bitmap. */
344 memset (here
, 0, sizeof (lang_bitmap
));
345 here
+= sizeof (lang_bitmap
);
352 while (c
!= EOF
&& c
!= '\n');
360 /* Read the list of input files from LIST and compute all of the
361 relevant tables. There is one file per line of the list. At
362 first, all the files on the list are language-generic, but
363 eventually a line will appear which is the name of a language
364 subdirectory in square brackets, like this: [cp]. All subsequent
365 files are specific to that language, until another language
366 subdirectory tag appears. Files can appear more than once, if
367 they apply to more than one language. */
369 read_input_list (const char *listname
)
371 FILE *list
= fopen (listname
, "r");
373 fatal ("cannot open %s: %s", listname
, strerror (errno
));
377 size_t bufsz
= measure_input_list (list
);
378 char *buf
= XNEWVEC (char, bufsz
);
380 char *committed
= buf
;
381 char *limit
= buf
+ bufsz
;
386 lang_bitmap curlangs
= (1 << num_lang_dirs
) - 1;
388 epos
.file
= listname
;
391 lang_dir_names
= XNEWVEC (const char *, num_lang_dirs
);
392 gt_files
= XNEWVEC (const char *, num_gt_files
);
399 is_language
= read_input_line (list
, &here
, &line
, &epos
);
400 gcc_assert (here
<= limit
);
403 else if (is_language
)
406 gcc_assert (langno
<= num_lang_dirs
);
407 for (i
= 0; i
< langno
; i
++)
408 if (strcmp (lang_dir_names
[i
], line
) == 0)
410 error_at_line (&epos
, "duplicate language tag [%s]", line
);
416 curlangs
= 1 << langno
;
417 lang_dir_names
[langno
++] = line
;
422 gcc_assert (nfiles
<= num_gt_files
);
423 for (i
= 0; i
< nfiles
; i
++)
424 if (strcmp (gt_files
[i
], line
) == 0)
426 /* Throw away the string we just read, and add the
427 current language to the existing string's bitmap. */
428 lang_bitmap bmap
= get_lang_bitmap (gt_files
[i
]);
430 error_at_line (&epos
, "file %s specified more than once "
431 "for language %s", line
, langno
== 0
433 : lang_dir_names
[langno
- 1]);
436 set_lang_bitmap ((char *)gt_files
[i
], bmap
);
441 set_lang_bitmap (line
, curlangs
);
442 gt_files
[nfiles
++] = line
;
445 /* Update the global counts now that we know accurately how many
446 things there are. (We do not bother resizing the arrays down.) */
447 num_lang_dirs
= langno
;
448 num_gt_files
= nfiles
;
451 /* Sanity check: any file that resides in a language subdirectory
452 (e.g. 'cp') ought to belong to the corresponding language.
453 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
454 (Can you even do that? Should you be allowed to?) */
457 for (f
= 0; f
< num_gt_files
; f
++)
459 lang_bitmap bitmap
= get_lang_bitmap (gt_files
[f
]);
460 const char *basename
= get_file_basename (gt_files
[f
]);
461 const char *slashpos
= strchr (basename
, '/');
466 for (l
= 0; l
< num_lang_dirs
; l
++)
467 if ((size_t)(slashpos
- basename
) == strlen (lang_dir_names
[l
])
468 && memcmp (basename
, lang_dir_names
[l
],
469 strlen (lang_dir_names
[l
])) == 0)
471 if (!(bitmap
& (1 << l
)))
472 error ("%s is in language directory '%s' but is not "
473 "tagged for that language",
474 basename
, lang_dir_names
[l
]);
482 fatal ("error reading %s: %s", listname
, strerror (errno
));
489 /* The one and only TYPE_STRING. */
491 static struct type string_type
= {
492 TYPE_STRING
, 0, 0, GC_USED
, {0}
495 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
496 set to appropriate values at the beginning of main. */
498 static struct type scalar_nonchar
= {
499 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
501 static struct type scalar_char
= {
502 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
505 /* Lists of various things. */
507 static pair_p typedefs
;
508 static type_p structures
;
509 static type_p param_structs
;
510 static pair_p variables
;
512 static type_p find_param_structure
513 (type_p t
, type_p param
[NUM_PARAM
]);
514 static type_p
adjust_field_tree_exp (type_p t
, options_p opt
);
515 static type_p
adjust_field_rtx_def (type_p t
, options_p opt
);
517 /* Define S as a typedef to T at POS. */
520 do_typedef (const char *s
, type_p t
, struct fileloc
*pos
)
524 /* temporary kludge - gengtype doesn't handle conditionals or
525 macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
526 is coming from this file (main() sets them up with safe dummy
528 if (!strcmp (s
, "CUMULATIVE_ARGS") && pos
->file
!= this_file
)
531 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
532 if (strcmp (p
->name
, s
) == 0)
536 error_at_line (pos
, "type `%s' previously defined", s
);
537 error_at_line (&p
->line
, "previously defined here");
542 p
= XNEW (struct pair
);
550 /* Define S as a typename of a scalar. Cannot be used to define
551 typedefs of 'char'. Note: is also used for pointer-to-function
552 typedefs (which are therefore not treated as pointers). */
555 do_scalar_typedef (const char *s
, struct fileloc
*pos
)
557 do_typedef (s
, &scalar_nonchar
, pos
);
560 /* Return the type previously defined for S. Use POS to report errors. */
563 resolve_typedef (const char *s
, struct fileloc
*pos
)
566 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
567 if (strcmp (p
->name
, s
) == 0)
569 error_at_line (pos
, "unidentified type `%s'", s
);
570 return &scalar_nonchar
; /* treat as "int" */
573 /* Create and return a new structure with tag NAME (or a union iff
574 ISUNION is nonzero), at POS with fields FIELDS and options O. */
577 new_structure (const char *name
, int isunion
, struct fileloc
*pos
,
578 pair_p fields
, options_p o
)
582 lang_bitmap bitmap
= get_lang_bitmap (pos
->file
);
584 /* temporary kludge - gengtype doesn't handle conditionals or
585 macros. Ignore any attempt to define struct location_s, unless
586 it is coming from this file (main() sets it up safely). */
587 if (!strcmp (name
, "location_s") && !isunion
588 && pos
->file
!= this_file
)
589 return find_structure (name
, 0);
591 for (si
= structures
; si
!= NULL
; si
= si
->next
)
592 if (strcmp (name
, si
->u
.s
.tag
) == 0
593 && UNION_P (si
) == isunion
)
596 if (si
->kind
== TYPE_LANG_STRUCT
)
600 for (si
= ls
->u
.s
.lang_struct
; si
!= NULL
; si
= si
->next
)
601 if (si
->u
.s
.bitmap
== bitmap
)
604 else if (si
->u
.s
.line
.file
!= NULL
&& si
->u
.s
.bitmap
!= bitmap
)
607 si
= XCNEW (struct type
);
608 memcpy (si
, ls
, sizeof (struct type
));
609 ls
->kind
= TYPE_LANG_STRUCT
;
610 ls
->u
.s
.lang_struct
= si
;
611 ls
->u
.s
.fields
= NULL
;
613 si
->pointer_to
= NULL
;
614 si
->u
.s
.lang_struct
= ls
;
619 if (ls
!= NULL
&& s
== NULL
)
621 s
= XCNEW (struct type
);
622 s
->next
= ls
->u
.s
.lang_struct
;
623 ls
->u
.s
.lang_struct
= s
;
624 s
->u
.s
.lang_struct
= ls
;
631 s
= XCNEW (struct type
);
632 s
->next
= structures
;
636 if (s
->u
.s
.line
.file
!= NULL
637 || (s
->u
.s
.lang_struct
&& (s
->u
.s
.lang_struct
->u
.s
.bitmap
& bitmap
)))
639 error_at_line (pos
, "duplicate definition of '%s %s'",
640 isunion
? "union" : "struct", s
->u
.s
.tag
);
641 error_at_line (&s
->u
.s
.line
, "previous definition here");
644 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
647 s
->u
.s
.fields
= fields
;
649 s
->u
.s
.bitmap
= bitmap
;
650 if (s
->u
.s
.lang_struct
)
651 s
->u
.s
.lang_struct
->u
.s
.bitmap
|= bitmap
;
653 /* Reset location_s's location to input.h so that we know where to
654 write out its mark routine. */
655 if (!strcmp (name
, "location_s") && !isunion
656 && pos
->file
== this_file
)
659 for (n
= 0; n
< num_gt_files
; n
++)
660 if (!strcmp (gt_files
[n
] + strlen (gt_files
[n
]) - strlen ("input.h"),
663 s
->u
.s
.line
.file
= gt_files
[n
];
671 /* Return the previously-defined structure with tag NAME (or a union
672 iff ISUNION is nonzero), or a new empty structure or union if none
673 was defined previously. */
676 find_structure (const char *name
, int isunion
)
680 for (s
= structures
; s
!= NULL
; s
= s
->next
)
681 if (strcmp (name
, s
->u
.s
.tag
) == 0
682 && UNION_P (s
) == isunion
)
685 s
= XCNEW (struct type
);
686 s
->next
= structures
;
688 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
694 /* Return the previously-defined parameterized structure for structure
695 T and parameters PARAM, or a new parameterized empty structure or
696 union if none was defined previously. */
699 find_param_structure (type_p t
, type_p param
[NUM_PARAM
])
703 for (res
= param_structs
; res
; res
= res
->next
)
704 if (res
->u
.param_struct
.stru
== t
705 && memcmp (res
->u
.param_struct
.param
, param
,
706 sizeof (type_p
) * NUM_PARAM
) == 0)
710 res
= XCNEW (struct type
);
711 res
->kind
= TYPE_PARAM_STRUCT
;
712 res
->next
= param_structs
;
714 res
->u
.param_struct
.stru
= t
;
715 memcpy (res
->u
.param_struct
.param
, param
, sizeof (type_p
) * NUM_PARAM
);
720 /* Return a scalar type with name NAME. */
723 create_scalar_type (const char *name
)
725 if (!strcmp (name
, "char") || !strcmp (name
, "unsigned char"))
728 return &scalar_nonchar
;
731 /* Return a pointer to T. */
734 create_pointer (type_p t
)
738 type_p r
= XCNEW (struct type
);
739 r
->kind
= TYPE_POINTER
;
743 return t
->pointer_to
;
746 /* Return an array of length LEN. */
749 create_array (type_p t
, const char *len
)
753 v
= XCNEW (struct type
);
754 v
->kind
= TYPE_ARRAY
;
760 /* Return an options structure with name NAME and info INFO. NEXT is the
761 next option in the chain. */
764 create_option (options_p next
, const char *name
, const void *info
)
766 options_p o
= XNEW (struct options
);
769 o
->info
= (const char*) info
;
773 /* Return an options structure for a "nested_ptr" option. */
775 create_nested_ptr_option (options_p next
, type_p t
,
776 const char *to
, const char *from
)
778 struct nested_ptr_data
*d
= XNEW (struct nested_ptr_data
);
780 d
->type
= adjust_field_type (t
, 0);
782 d
->convert_from
= from
;
783 return create_option (next
, "nested_ptr", d
);
786 /* Add a variable named S of type T with options O defined at POS,
790 note_variable (const char *s
, type_p t
, options_p o
, struct fileloc
*pos
)
793 n
= XNEW (struct pair
);
802 /* Most-general structure field creator. */
804 create_field_all (pair_p next
, type_p type
, const char *name
, options_p opt
,
805 const char *file
, int line
)
809 field
= XNEW (struct pair
);
814 field
->line
.file
= file
;
815 field
->line
.line
= line
;
819 /* Create a field that came from the source code we are scanning,
820 i.e. we have a 'struct fileloc', and possibly options; also,
821 adjust_field_type should be called. */
823 create_field_at (pair_p next
, type_p type
, const char *name
, options_p opt
,
826 return create_field_all (next
, adjust_field_type (type
, opt
),
827 name
, opt
, pos
->file
, pos
->line
);
830 /* Create a fake field with the given type and name. NEXT is the next
831 field in the chain. */
832 #define create_field(next,type,name) \
833 create_field_all(next,type,name, 0, this_file, __LINE__)
835 /* Like create_field, but the field is only valid when condition COND
839 create_optional_field_ (pair_p next
, type_p type
, const char *name
,
840 const char *cond
, int line
)
846 /* Create a fake union type with a single nameless field of type TYPE.
847 The field has a tag of "1". This allows us to make the presence
848 of a field of type TYPE depend on some boolean "desc" being true. */
849 union_fields
= create_field (NULL
, type
, "");
850 union_fields
->opt
= create_option (union_fields
->opt
, "dot", "");
851 union_fields
->opt
= create_option (union_fields
->opt
, "tag", "1");
852 union_type
= new_structure (xasprintf ("%s_%d", "fake_union", id
++), 1,
853 &lexer_line
, union_fields
, NULL
);
855 /* Create the field and give it the new fake union type. Add a "desc"
856 tag that specifies the condition under which the field is valid. */
857 return create_field_all (next
, union_type
, name
,
858 create_option (0, "desc", cond
),
861 #define create_optional_field(next,type,name,cond) \
862 create_optional_field_(next,type,name,cond,__LINE__)
864 /* Reverse a linked list of 'struct pair's in place. */
866 nreverse_pairs (pair_p list
)
868 pair_p prev
= 0, p
, next
;
869 for (p
= list
; p
; p
= next
)
879 /* We don't care how long a CONST_DOUBLE is. */
880 #define CONST_DOUBLE_FORMAT "ww"
881 /* We don't want to see codes that are only for generator files. */
882 #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. */
908 #define DEF_INSN_NOTE(NAME) NAME,
909 #include "insn-notes.def"
915 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
916 default field for line number notes. */
917 static const char *const note_insn_name
[NOTE_INSN_MAX
+1] = {
918 #define DEF_INSN_NOTE(NAME) #NAME,
919 #include "insn-notes.def"
923 #undef CONST_DOUBLE_FORMAT
924 #define GENERATOR_FILE
926 /* Generate the contents of the rtx_next array. This really doesn't belong
927 in gengtype at all, but it's needed for adjust_field_rtx_def. */
933 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
937 rtx_next_new
[i
] = -1;
938 if (strncmp (rtx_format
[i
], "iuu", 3) == 0)
940 else if (i
== COND_EXEC
|| i
== SET
|| i
== EXPR_LIST
|| i
== INSN_LIST
)
943 for (k
= strlen (rtx_format
[i
]) - 1; k
>= 0; k
--)
944 if (rtx_format
[i
][k
] == 'e' || rtx_format
[i
][k
] == 'u')
949 /* Write out the contents of the rtx_next array. */
951 write_rtx_next (void)
953 outf_p f
= get_output_file_with_visibility (NULL
);
956 oprintf (f
, "\n/* Used to implement the RTX_NEXT macro. */\n");
957 oprintf (f
, "const unsigned char rtx_next[NUM_RTX_CODE] = {\n");
958 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
959 if (rtx_next_new
[i
] == -1)
960 oprintf (f
, " 0,\n");
963 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n",
968 /* Handle `special("rtx_def")'. This is a special case for field
969 `fld' of struct rtx_def, which is an array of unions whose values
970 are based in a complex way on the type of RTL. */
973 adjust_field_rtx_def (type_p t
, options_p
ARG_UNUSED (opt
))
978 type_p rtx_tp
, rtvec_tp
, tree_tp
, mem_attrs_tp
, note_union_tp
, scalar_tp
;
979 type_p bitmap_tp
, basic_block_tp
, reg_attrs_tp
, constant_tp
, symbol_union_tp
;
981 if (t
->kind
!= TYPE_UNION
)
983 error_at_line (&lexer_line
,
984 "special `rtx_def' must be applied to a union");
988 nodot
= create_option (NULL
, "dot", "");
990 rtx_tp
= create_pointer (find_structure ("rtx_def", 0));
991 rtvec_tp
= create_pointer (find_structure ("rtvec_def", 0));
992 tree_tp
= create_pointer (find_structure ("tree_node", 1));
993 mem_attrs_tp
= create_pointer (find_structure ("mem_attrs", 0));
994 reg_attrs_tp
= create_pointer (find_structure ("reg_attrs", 0));
995 bitmap_tp
= create_pointer (find_structure ("bitmap_element_def", 0));
996 basic_block_tp
= create_pointer (find_structure ("basic_block_def", 0));
997 constant_tp
= create_pointer (find_structure ("constant_descriptor_rtx", 0));
998 scalar_tp
= &scalar_nonchar
; /* rtunion int */
1001 pair_p note_flds
= NULL
;
1004 for (c
= 0; c
<= NOTE_INSN_MAX
; c
++)
1009 note_flds
= create_field (note_flds
, &string_type
, "rt_str");
1012 case NOTE_INSN_BLOCK_BEG
:
1013 case NOTE_INSN_BLOCK_END
:
1014 note_flds
= create_field (note_flds
, tree_tp
, "rt_tree");
1017 case NOTE_INSN_VAR_LOCATION
:
1018 note_flds
= create_field (note_flds
, rtx_tp
, "rt_rtx");
1022 note_flds
= create_field (note_flds
, scalar_tp
, "rt_int");
1025 /* NOTE_INSN_MAX is used as the default field for line
1027 if (c
== NOTE_INSN_MAX
)
1028 note_flds
->opt
= create_option (nodot
, "default", "");
1030 note_flds
->opt
= create_option (nodot
, "tag", note_insn_name
[c
]);
1032 note_union_tp
= new_structure ("rtx_def_note_subunion", 1,
1033 &lexer_line
, note_flds
, NULL
);
1035 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1039 sym_flds
= create_field (NULL
, tree_tp
, "rt_tree");
1040 sym_flds
->opt
= create_option (nodot
, "default", "");
1042 sym_flds
= create_field (sym_flds
, constant_tp
, "rt_constant");
1043 sym_flds
->opt
= create_option (nodot
, "tag", "1");
1045 symbol_union_tp
= new_structure ("rtx_def_symbol_subunion", 1,
1046 &lexer_line
, sym_flds
, NULL
);
1048 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1050 pair_p subfields
= NULL
;
1051 size_t aindex
, nmindex
;
1056 for (aindex
= 0; aindex
< strlen (rtx_format
[i
]); aindex
++)
1059 const char *subname
;
1061 switch (rtx_format
[i
][aindex
])
1072 if (i
== MEM
&& aindex
== 1)
1073 t
= mem_attrs_tp
, subname
= "rt_mem";
1074 else if (i
== JUMP_INSN
&& aindex
== 8)
1075 t
= rtx_tp
, subname
= "rt_rtx";
1076 else if (i
== CODE_LABEL
&& aindex
== 4)
1077 t
= scalar_tp
, subname
= "rt_int";
1078 else if (i
== CODE_LABEL
&& aindex
== 5)
1079 t
= rtx_tp
, subname
= "rt_rtx";
1080 else if (i
== LABEL_REF
1081 && (aindex
== 1 || aindex
== 2))
1082 t
= rtx_tp
, subname
= "rt_rtx";
1083 else if (i
== NOTE
&& aindex
== 4)
1084 t
= note_union_tp
, subname
= "";
1085 else if (i
== NOTE
&& aindex
== 5)
1086 t
= scalar_tp
, subname
= "rt_int";
1087 else if (i
== NOTE
&& aindex
>= 7)
1088 t
= scalar_tp
, subname
= "rt_int";
1089 else if (i
== ADDR_DIFF_VEC
&& aindex
== 4)
1090 t
= scalar_tp
, subname
= "rt_int";
1091 else if (i
== VALUE
&& aindex
== 0)
1092 t
= scalar_tp
, subname
= "rt_int";
1093 else if (i
== REG
&& aindex
== 1)
1094 t
= scalar_tp
, subname
= "rt_int";
1095 else if (i
== REG
&& aindex
== 2)
1096 t
= reg_attrs_tp
, subname
= "rt_reg";
1097 else if (i
== SCRATCH
&& aindex
== 0)
1098 t
= scalar_tp
, subname
= "rt_int";
1099 else if (i
== SYMBOL_REF
&& aindex
== 1)
1100 t
= scalar_tp
, subname
= "rt_int";
1101 else if (i
== SYMBOL_REF
&& aindex
== 2)
1102 t
= symbol_union_tp
, subname
= "";
1103 else if (i
== BARRIER
&& aindex
>= 3)
1104 t
= scalar_tp
, subname
= "rt_int";
1107 error_at_line (&lexer_line
,
1108 "rtx type `%s' has `0' in position %lu, can't handle",
1109 rtx_name
[i
], (unsigned long) aindex
);
1131 subname
= "rt_rtvec";
1136 subname
= "rt_tree";
1150 error_at_line (&lexer_line
,
1151 "rtx type `%s' has `%c' in position %lu, can't handle",
1152 rtx_name
[i
], rtx_format
[i
][aindex
],
1153 (unsigned long)aindex
);
1159 subfields
= create_field (subfields
, t
,
1160 xasprintf (".fld[%lu].%s",
1161 (unsigned long) aindex
,
1163 subfields
->opt
= nodot
;
1164 if (t
== note_union_tp
)
1165 subfields
->opt
= create_option (subfields
->opt
, "desc",
1167 if (t
== symbol_union_tp
)
1168 subfields
->opt
= create_option (subfields
->opt
, "desc",
1169 "CONSTANT_POOL_ADDRESS_P (&%0)");
1172 if (i
== SYMBOL_REF
)
1174 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds. */
1175 type_p field_tp
= find_structure ("block_symbol", 0);
1177 = create_optional_field (subfields
, field_tp
, "block_sym",
1178 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1181 sname
= xasprintf ("rtx_def_%s", rtx_name
[i
]);
1182 substruct
= new_structure (sname
, 0, &lexer_line
, subfields
, NULL
);
1184 ftag
= xstrdup (rtx_name
[i
]);
1185 for (nmindex
= 0; nmindex
< strlen (ftag
); nmindex
++)
1186 ftag
[nmindex
] = TOUPPER (ftag
[nmindex
]);
1188 flds
= create_field (flds
, substruct
, "");
1189 flds
->opt
= create_option (nodot
, "tag", ftag
);
1192 return new_structure ("rtx_def_subunion", 1, &lexer_line
, flds
, nodot
);
1195 /* Handle `special("tree_exp")'. This is a special case for
1196 field `operands' of struct tree_exp, which although it claims to contain
1197 pointers to trees, actually sometimes contains pointers to RTL too.
1198 Passed T, the old type of the field, and OPT its options. Returns
1199 a new type for the field. */
1202 adjust_field_tree_exp (type_p t
, options_p opt ATTRIBUTE_UNUSED
)
1207 if (t
->kind
!= TYPE_ARRAY
)
1209 error_at_line (&lexer_line
,
1210 "special `tree_exp' must be applied to an array");
1211 return &string_type
;
1214 nodot
= create_option (NULL
, "dot", "");
1216 flds
= create_field (NULL
, t
, "");
1217 flds
->opt
= create_option (nodot
, "length",
1218 "TREE_OPERAND_LENGTH ((tree) &%0)");
1219 flds
->opt
= create_option (flds
->opt
, "default", "");
1221 return new_structure ("tree_exp_subunion", 1, &lexer_line
, flds
, nodot
);
1224 /* Perform any special processing on a type T, about to become the type
1225 of a field. Return the appropriate type for the field.
1227 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1228 - Similarly for arrays of pointer-to-char;
1229 - Converts structures for which a parameter is provided to
1231 - Handles "special" options.
1235 adjust_field_type (type_p t
, options_p opt
)
1238 const int pointer_p
= t
->kind
== TYPE_POINTER
;
1239 type_p params
[NUM_PARAM
];
1243 for (i
= 0; i
< NUM_PARAM
; i
++)
1246 for (; opt
; opt
= opt
->next
)
1247 if (strcmp (opt
->name
, "length") == 0)
1249 else if (strcmp (opt
->name
, "param_is") == 0
1250 || (strncmp (opt
->name
, "param", 5) == 0
1251 && ISDIGIT (opt
->name
[5])
1252 && strcmp (opt
->name
+ 6, "_is") == 0))
1254 int num
= ISDIGIT (opt
->name
[5]) ? opt
->name
[5] - '0' : 0;
1256 if (! UNION_OR_STRUCT_P (t
)
1257 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
1259 error_at_line (&lexer_line
,
1260 "option `%s' may only be applied to structures or structure pointers",
1266 if (params
[num
] != NULL
)
1267 error_at_line (&lexer_line
, "duplicate `%s' option", opt
->name
);
1268 if (! ISDIGIT (opt
->name
[5]))
1269 params
[num
] = create_pointer ((type_p
) opt
->info
);
1271 params
[num
] = (type_p
) opt
->info
;
1273 else if (strcmp (opt
->name
, "special") == 0)
1275 const char *special_name
= opt
->info
;
1276 if (strcmp (special_name
, "tree_exp") == 0)
1277 t
= adjust_field_tree_exp (t
, opt
);
1278 else if (strcmp (special_name
, "rtx_def") == 0)
1279 t
= adjust_field_rtx_def (t
, opt
);
1281 error_at_line (&lexer_line
, "unknown special `%s'", special_name
);
1290 realt
= find_param_structure (t
, params
);
1291 t
= pointer_p
? create_pointer (realt
) : realt
;
1296 && t
->u
.p
->kind
== TYPE_SCALAR
1297 && t
->u
.p
->u
.scalar_is_char
)
1298 return &string_type
;
1299 if (t
->kind
== TYPE_ARRAY
&& t
->u
.a
.p
->kind
== TYPE_POINTER
1300 && t
->u
.a
.p
->u
.p
->kind
== TYPE_SCALAR
1301 && t
->u
.a
.p
->u
.p
->u
.scalar_is_char
)
1302 return create_array (&string_type
, t
->u
.a
.len
);
1308 static void set_gc_used_type (type_p
, enum gc_used_enum
, type_p
*);
1309 static void set_gc_used (pair_p
);
1311 /* Handle OPT for set_gc_used_type. */
1314 process_gc_options (options_p opt
, enum gc_used_enum level
, int *maybe_undef
,
1315 int *pass_param
, int *length
, int *skip
, type_p
*nested_ptr
)
1318 for (o
= opt
; o
; o
= o
->next
)
1319 if (strcmp (o
->name
, "ptr_alias") == 0 && level
== GC_POINTED_TO
)
1320 set_gc_used_type ((type_p
) o
->info
, GC_POINTED_TO
, NULL
);
1321 else if (strcmp (o
->name
, "maybe_undef") == 0)
1323 else if (strcmp (o
->name
, "use_params") == 0)
1325 else if (strcmp (o
->name
, "length") == 0)
1327 else if (strcmp (o
->name
, "skip") == 0)
1329 else if (strcmp (o
->name
, "nested_ptr") == 0)
1330 *nested_ptr
= ((const struct nested_ptr_data
*) o
->info
)->type
;
1333 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1336 set_gc_used_type (type_p t
, enum gc_used_enum level
, type_p param
[NUM_PARAM
])
1338 if (t
->gc_used
>= level
)
1352 process_gc_options (t
->u
.s
.opt
, level
, &dummy
, &dummy
, &dummy
, &dummy
,
1355 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
1357 int maybe_undef
= 0;
1361 type_p nested_ptr
= NULL
;
1362 process_gc_options (f
->opt
, level
, &maybe_undef
, &pass_param
,
1363 &length
, &skip
, &nested_ptr
);
1365 if (nested_ptr
&& f
->type
->kind
== TYPE_POINTER
)
1366 set_gc_used_type (nested_ptr
, GC_POINTED_TO
,
1367 pass_param
? param
: NULL
);
1368 else if (length
&& f
->type
->kind
== TYPE_POINTER
)
1369 set_gc_used_type (f
->type
->u
.p
, GC_USED
, NULL
);
1370 else if (maybe_undef
&& f
->type
->kind
== TYPE_POINTER
)
1371 set_gc_used_type (f
->type
->u
.p
, GC_MAYBE_POINTED_TO
, NULL
);
1372 else if (pass_param
&& f
->type
->kind
== TYPE_POINTER
&& param
)
1373 set_gc_used_type (find_param_structure (f
->type
->u
.p
, param
),
1374 GC_POINTED_TO
, NULL
);
1376 ; /* target type is not used through this field */
1378 set_gc_used_type (f
->type
, GC_USED
, pass_param
? param
: NULL
);
1384 set_gc_used_type (t
->u
.p
, GC_POINTED_TO
, NULL
);
1388 set_gc_used_type (t
->u
.a
.p
, GC_USED
, param
);
1391 case TYPE_LANG_STRUCT
:
1392 for (t
= t
->u
.s
.lang_struct
; t
; t
= t
->next
)
1393 set_gc_used_type (t
, level
, param
);
1396 case TYPE_PARAM_STRUCT
:
1399 for (i
= 0; i
< NUM_PARAM
; i
++)
1400 if (t
->u
.param_struct
.param
[i
] != 0)
1401 set_gc_used_type (t
->u
.param_struct
.param
[i
], GC_USED
, NULL
);
1403 if (t
->u
.param_struct
.stru
->gc_used
== GC_POINTED_TO
)
1404 level
= GC_POINTED_TO
;
1407 t
->u
.param_struct
.stru
->gc_used
= GC_UNUSED
;
1408 set_gc_used_type (t
->u
.param_struct
.stru
, level
,
1409 t
->u
.param_struct
.param
);
1417 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1420 set_gc_used (pair_p variables
)
1423 for (p
= variables
; p
; p
= p
->next
)
1424 set_gc_used_type (p
->type
, GC_USED
, NULL
);
1427 /* File mapping routines. For each input file, there is one output .c file
1428 (but some output files have many input files), and there is one .h file
1429 for the whole build. */
1431 /* Output file handling. */
1433 /* Create and return an outf_p for a new file for NAME, to be called
1437 create_file (const char *name
, const char *oname
)
1439 static const char *const hdr
[] = {
1440 " Copyright (C) 2004, 2007 Free Software Foundation, Inc.\n",
1442 "This file is part of GCC.\n",
1444 "GCC is free software; you can redistribute it and/or modify it under\n",
1445 "the terms of the GNU General Public License as published by the Free\n",
1446 "Software Foundation; either version 3, or (at your option) any later\n",
1449 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1450 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1451 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1452 "for more details.\n",
1454 "You should have received a copy of the GNU General Public License\n",
1455 "along with GCC; see the file COPYING3. If not see\n",
1456 "<http://www.gnu.org/licenses/>. */\n",
1458 "/* This file is machine generated. Do not edit. */\n"
1463 f
= XCNEW (struct outf
);
1464 f
->next
= output_files
;
1468 oprintf (f
, "/* Type information for %s.\n", name
);
1469 for (i
= 0; i
< ARRAY_SIZE (hdr
); i
++)
1470 oprintf (f
, "%s", hdr
[i
]);
1474 /* Print, like fprintf, to O.
1475 N.B. You might think this could be implemented more efficiently
1476 with vsnprintf(). Unfortunately, there are C libraries that
1477 provide that function but without the C99 semantics for its return
1478 value, making it impossible to know how much space is required. */
1480 oprintf (outf_p o
, const char *format
, ...)
1486 va_start (ap
, format
);
1487 slength
= vasprintf (&s
, format
, ap
);
1488 if (s
== NULL
|| (int)slength
< 0)
1489 fatal ("out of memory");
1492 if (o
->bufused
+ slength
> o
->buflength
)
1494 size_t new_len
= o
->buflength
;
1499 } while (o
->bufused
+ slength
>= new_len
);
1500 o
->buf
= XRESIZEVEC (char, o
->buf
, new_len
);
1501 o
->buflength
= new_len
;
1503 memcpy (o
->buf
+ o
->bufused
, s
, slength
);
1504 o
->bufused
+= slength
;
1508 /* Open the global header file and the language-specific header files. */
1511 open_base_files (void)
1515 header_file
= create_file ("GCC", "gtype-desc.h");
1517 base_files
= XNEWVEC (outf_p
, num_lang_dirs
);
1519 for (i
= 0; i
< num_lang_dirs
; i
++)
1520 base_files
[i
] = create_file (lang_dir_names
[i
],
1521 xasprintf ("gtype-%s.h", lang_dir_names
[i
]));
1523 /* gtype-desc.c is a little special, so we create it here. */
1525 /* The order of files here matters very much. */
1526 static const char *const ifiles
[] = {
1527 "config.h", "system.h", "coretypes.h", "tm.h", "varray.h",
1528 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1529 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1530 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1531 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1532 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1533 "cfglayout.h", "except.h", "output.h", "cfgloop.h", NULL
1535 const char *const *ifp
;
1536 outf_p gtype_desc_c
;
1538 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1539 for (ifp
= ifiles
; *ifp
; ifp
++)
1540 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1542 /* Make sure we handle "cfun" specially. */
1543 oprintf (gtype_desc_c
, "\n/* See definition in function.h. */\n");
1544 oprintf (gtype_desc_c
, "#undef cfun\n");
1548 /* Determine the pathname to F relative to $(srcdir). */
1551 get_file_basename (const char *f
)
1553 const char *basename
;
1556 basename
= strrchr (f
, '/');
1563 for (i
= 0; i
< num_lang_dirs
; i
++)
1569 s1
= basename
- strlen (lang_dir_names
[i
]) - 1;
1570 s2
= lang_dir_names
[i
];
1573 if (l1
>= l2
&& IS_DIR_SEPARATOR (s1
[-1]) && !memcmp (s1
, s2
, l2
))
1576 if ((basename
- f
- 1) != srcdir_len
)
1577 fatal ("filename `%s' should be preceded by $srcdir", f
);
1585 /* An output file, suitable for definitions, that can see declarations
1586 made in INPUT_FILE and is linked into every language that uses
1590 get_output_file_with_visibility (const char *input_file
)
1594 const char *basename
;
1595 const char *for_name
;
1596 const char *output_name
;
1598 /* This can happen when we need a file with visibility on a
1599 structure that we've never seen. We have to just hope that it's
1600 globally visible. */
1601 if (input_file
== NULL
)
1602 input_file
= "system.h";
1604 /* Determine the output file name. */
1605 basename
= get_file_basename (input_file
);
1607 len
= strlen (basename
);
1608 if ((len
> 2 && memcmp (basename
+len
-2, ".c", 2) == 0)
1609 || (len
> 2 && memcmp (basename
+len
-2, ".y", 2) == 0)
1610 || (len
> 3 && memcmp (basename
+len
-3, ".in", 3) == 0))
1614 output_name
= s
= xasprintf ("gt-%s", basename
);
1615 for (; *s
!= '.'; s
++)
1616 if (! ISALNUM (*s
) && *s
!= '-')
1618 memcpy (s
, ".h", sizeof (".h"));
1619 for_name
= basename
;
1621 /* Some headers get used by more than one front-end; hence, it
1622 would be inappropriate to spew them out to a single gtype-<lang>.h
1623 (and gengtype doesn't know how to direct spewage into multiple
1624 gtype-<lang>.h headers at this time). Instead, we pair up these
1625 headers with source files (and their special purpose gt-*.h headers). */
1626 else if (strcmp (basename
, "c-common.h") == 0)
1627 output_name
= "gt-c-common.h", for_name
= "c-common.c";
1628 else if (strcmp (basename
, "c-tree.h") == 0)
1629 output_name
= "gt-c-decl.h", for_name
= "c-decl.c";
1630 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1631 && strcmp (basename
+ 3, "cp-tree.h") == 0)
1632 output_name
= "gt-cp-tree.h", for_name
= "cp/tree.c";
1633 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1634 && strcmp (basename
+ 3, "decl.h") == 0)
1635 output_name
= "gt-cp-decl.h", for_name
= "cp/decl.c";
1636 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1637 && strcmp (basename
+ 3, "name-lookup.h") == 0)
1638 output_name
= "gt-cp-name-lookup.h", for_name
= "cp/name-lookup.c";
1639 else if (strncmp (basename
, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename
[4])
1640 && strcmp (basename
+ 5, "objc-act.h") == 0)
1641 output_name
= "gt-objc-objc-act.h", for_name
= "objc/objc-act.c";
1646 for (i
= 0; i
< num_lang_dirs
; i
++)
1647 if (memcmp (basename
, lang_dir_names
[i
], strlen (lang_dir_names
[i
])) == 0
1648 && basename
[strlen(lang_dir_names
[i
])] == '/')
1649 return base_files
[i
];
1651 output_name
= "gtype-desc.c";
1655 /* Look through to see if we've ever seen this output filename before. */
1656 for (r
= output_files
; r
; r
= r
->next
)
1657 if (strcmp (r
->name
, output_name
) == 0)
1660 /* If not, create it. */
1661 r
= create_file (for_name
, output_name
);
1666 /* The name of an output file, suitable for definitions, that can see
1667 declarations made in INPUT_FILE and is linked into every language
1668 that uses INPUT_FILE. */
1671 get_output_file_name (const char *input_file
)
1673 return get_output_file_with_visibility (input_file
)->name
;
1676 /* Copy the output to its final destination,
1677 but don't unnecessarily change modification times. */
1680 close_output_files (void)
1684 for (of
= output_files
; of
; of
= of
->next
)
1688 newfile
= fopen (of
->name
, "r");
1689 if (newfile
!= NULL
)
1694 for (i
= 0; i
< of
->bufused
; i
++)
1697 ch
= fgetc (newfile
);
1698 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
1701 no_write_p
= i
== of
->bufused
&& fgetc (newfile
) == EOF
;
1708 newfile
= fopen (of
->name
, "w");
1709 if (newfile
== NULL
)
1710 fatal ("opening output file %s: %s", of
->name
, strerror (errno
));
1711 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
1712 fatal ("writing output file %s: %s", of
->name
, strerror (errno
));
1713 if (fclose (newfile
) != 0)
1714 fatal ("closing output file %s: %s", of
->name
, strerror (errno
));
1725 struct walk_type_data
;
1727 /* For scalars and strings, given the item in 'val'.
1728 For structures, given a pointer to the item in 'val'.
1729 For misc. pointers, given the item in 'val'.
1731 typedef void (*process_field_fn
)
1732 (type_p f
, const struct walk_type_data
*p
);
1733 typedef void (*func_name_fn
)
1734 (type_p s
, const struct walk_type_data
*p
);
1736 /* Parameters for write_types. */
1738 struct write_types_data
1741 const char *param_prefix
;
1742 const char *subfield_marker_routine
;
1743 const char *marker_routine
;
1744 const char *reorder_note_routine
;
1745 const char *comment
;
1746 int skip_hooks
; /* skip hook generation if non zero */
1749 static void output_escaped_param (struct walk_type_data
*d
,
1750 const char *, const char *);
1751 static void output_mangled_typename (outf_p
, const_type_p
);
1752 static void walk_type (type_p t
, struct walk_type_data
*d
);
1753 static void write_func_for_structure
1754 (type_p orig_s
, type_p s
, type_p
* param
,
1755 const struct write_types_data
*wtd
);
1756 static void write_types_process_field
1757 (type_p f
, const struct walk_type_data
*d
);
1758 static void write_types (type_p structures
,
1759 type_p param_structs
,
1760 const struct write_types_data
*wtd
);
1761 static void write_types_local_process_field
1762 (type_p f
, const struct walk_type_data
*d
);
1763 static void write_local_func_for_structure
1764 (type_p orig_s
, type_p s
, type_p
* param
);
1765 static void write_local (type_p structures
,
1766 type_p param_structs
);
1767 static void write_enum_defn (type_p structures
, type_p param_structs
);
1768 static int contains_scalar_p (type_p t
);
1769 static void put_mangled_filename (outf_p
, const char *);
1770 static void finish_root_table (struct flist
*flp
, const char *pfx
,
1771 const char *tname
, const char *lastname
,
1773 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
1774 struct fileloc
*, const char *);
1775 static void write_array (outf_p f
, pair_p v
,
1776 const struct write_types_data
*wtd
);
1777 static void write_roots (pair_p
);
1779 /* Parameters for walk_type. */
1781 struct walk_type_data
1783 process_field_fn process_field
;
1788 const char *prev_val
[4];
1791 struct fileloc
*line
;
1796 const char *reorder_fn
;
1798 bool fn_wants_lvalue
;
1801 /* Print a mangled name representing T to OF. */
1804 output_mangled_typename (outf_p of
, const_type_p t
)
1808 else switch (t
->kind
)
1812 output_mangled_typename (of
, t
->u
.p
);
1822 case TYPE_LANG_STRUCT
:
1823 oprintf (of
, "%lu%s", (unsigned long) strlen (t
->u
.s
.tag
), t
->u
.s
.tag
);
1825 case TYPE_PARAM_STRUCT
:
1828 for (i
= 0; i
< NUM_PARAM
; i
++)
1829 if (t
->u
.param_struct
.param
[i
] != NULL
)
1830 output_mangled_typename (of
, t
->u
.param_struct
.param
[i
]);
1831 output_mangled_typename (of
, t
->u
.param_struct
.stru
);
1839 /* Print PARAM to D->OF processing escapes. D->VAL references the
1840 current object, D->PREV_VAL the object containing the current
1841 object, ONAME is the name of the option and D->LINE is used to
1842 print error messages. */
1845 output_escaped_param (struct walk_type_data
*d
, const char *param
,
1850 for (p
= param
; *p
; p
++)
1852 oprintf (d
->of
, "%c", *p
);
1856 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
1859 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
1862 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
1866 const char *pp
= d
->val
+ strlen (d
->val
);
1867 while (pp
[-1] == ']')
1870 oprintf (d
->of
, "%s", pp
);
1874 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
1879 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
1880 which is of type T. Write code to D->OF to constrain execution (at
1881 the point that D->PROCESS_FIELD is called) to the appropriate
1882 cases. Call D->PROCESS_FIELD on subobjects before calling it on
1883 pointers to those objects. D->PREV_VAL lists the objects
1884 containing the current object, D->OPT is a list of options to
1885 apply, D->INDENT is the current indentation level, D->LINE is used
1886 to print error messages, D->BITMAP indicates which languages to
1887 print the structure for, and D->PARAM is the current parameter
1888 (from an enclosing param_is option). */
1891 walk_type (type_p t
, struct walk_type_data
*d
)
1893 const char *length
= NULL
;
1894 const char *desc
= NULL
;
1895 int maybe_undef_p
= 0;
1896 int use_param_num
= -1;
1897 int use_params_p
= 0;
1899 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
1901 d
->needs_cast_p
= false;
1902 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
1903 if (strcmp (oo
->name
, "length") == 0)
1905 else if (strcmp (oo
->name
, "maybe_undef") == 0)
1907 else if (strncmp (oo
->name
, "use_param", 9) == 0
1908 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
1909 use_param_num
= oo
->name
[9] == '\0' ? 0 : oo
->name
[9] - '0';
1910 else if (strcmp (oo
->name
, "use_params") == 0)
1912 else if (strcmp (oo
->name
, "desc") == 0)
1914 else if (strcmp (oo
->name
, "mark_hook") == 0)
1916 else if (strcmp (oo
->name
, "nested_ptr") == 0)
1917 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
;
1918 else if (strcmp (oo
->name
, "dot") == 0)
1920 else if (strcmp (oo
->name
, "tag") == 0)
1922 else if (strcmp (oo
->name
, "special") == 0)
1924 else if (strcmp (oo
->name
, "skip") == 0)
1926 else if (strcmp (oo
->name
, "default") == 0)
1928 else if (strcmp (oo
->name
, "descbits") == 0)
1930 else if (strcmp (oo
->name
, "param_is") == 0)
1932 else if (strncmp (oo
->name
, "param", 5) == 0
1933 && ISDIGIT (oo
->name
[5])
1934 && strcmp (oo
->name
+ 6, "_is") == 0)
1936 else if (strcmp (oo
->name
, "chain_next") == 0)
1938 else if (strcmp (oo
->name
, "chain_prev") == 0)
1940 else if (strcmp (oo
->name
, "reorder") == 0)
1943 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
1950 int pointer_p
= t
->kind
== TYPE_POINTER
;
1954 if (! UNION_OR_STRUCT_P (t
))
1955 error_at_line (d
->line
, "`use_params' option on unimplemented type");
1957 t
= find_param_structure (t
, d
->param
);
1959 t
= create_pointer (t
);
1962 if (use_param_num
!= -1)
1964 if (d
->param
!= NULL
&& d
->param
[use_param_num
] != NULL
)
1966 type_p nt
= d
->param
[use_param_num
];
1968 if (t
->kind
== TYPE_ARRAY
)
1969 nt
= create_array (nt
, t
->u
.a
.len
);
1970 else if (length
!= NULL
&& t
->kind
== TYPE_POINTER
)
1971 nt
= create_pointer (nt
);
1972 d
->needs_cast_p
= (t
->kind
!= TYPE_POINTER
1973 && (nt
->kind
== TYPE_POINTER
1974 || nt
->kind
== TYPE_STRING
));
1978 error_at_line (d
->line
, "no parameter defined for `%s'",
1983 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
1985 error_at_line (d
->line
,
1986 "field `%s' has invalid option `maybe_undef_p'\n",
1995 d
->process_field (t
, d
);
2001 && t
->u
.p
->u
.s
.line
.file
== NULL
)
2003 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2009 if (! UNION_OR_STRUCT_P (t
->u
.p
)
2010 && t
->u
.p
->kind
!= TYPE_PARAM_STRUCT
)
2012 error_at_line (d
->line
,
2013 "field `%s' is pointer to unimplemented type",
2020 const char *oldprevval2
= d
->prev_val
[2];
2022 if (! UNION_OR_STRUCT_P (nested_ptr_d
->type
))
2024 error_at_line (d
->line
,
2025 "field `%s' has invalid "
2026 "option `nested_ptr'\n",
2031 d
->prev_val
[2] = d
->val
;
2032 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2034 d
->val
= xasprintf ("x%d", d
->counter
++);
2035 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2036 (nested_ptr_d
->type
->kind
== TYPE_UNION
2037 ? "union" : "struct"),
2038 nested_ptr_d
->type
->u
.s
.tag
,
2039 d
->fn_wants_lvalue
? "" : "const ",
2041 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2042 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2044 oprintf (d
->of
, ";\n");
2046 d
->process_field (nested_ptr_d
->type
, d
);
2048 if (d
->fn_wants_lvalue
)
2050 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2052 d
->prev_val
[2] = d
->val
;
2053 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2055 oprintf (d
->of
, ";\n");
2059 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2060 d
->val
= d
->prev_val
[2];
2061 d
->prev_val
[2] = oldprevval2
;
2064 d
->process_field (t
->u
.p
, d
);
2068 int loopcounter
= d
->counter
++;
2069 const char *oldval
= d
->val
;
2070 const char *oldprevval3
= d
->prev_val
[3];
2073 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2075 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2076 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
, "",
2077 loopcounter
, loopcounter
);
2078 output_escaped_param (d
, length
, "length");
2079 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2081 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2083 d
->prev_val
[3] = oldval
;
2084 walk_type (t
->u
.p
, d
);
2087 d
->prev_val
[3] = oldprevval3
;
2090 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2091 d
->process_field(t
, d
);
2093 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2100 int loopcounter
= d
->counter
++;
2101 const char *oldval
= d
->val
;
2104 /* If it's an array of scalars, we optimize by not generating
2106 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2109 /* When walking an array, compute the length and store it in a
2110 local variable before walking the array elements, instead of
2111 recomputing the length expression each time through the loop.
2112 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2113 where the length is stored in the first array element,
2114 because otherwise that operand can get overwritten on the
2116 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2118 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2119 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2120 d
->indent
, "", loopcounter
);
2122 output_escaped_param (d
, length
, "length");
2124 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2125 oprintf (d
->of
, ");\n");
2127 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2129 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2131 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2133 walk_type (t
->u
.a
.p
, d
);
2138 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2140 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2148 const char *oldval
= d
->val
;
2149 const char *oldprevval1
= d
->prev_val
[1];
2150 const char *oldprevval2
= d
->prev_val
[2];
2151 const int union_p
= t
->kind
== TYPE_UNION
;
2152 int seen_default_p
= 0;
2155 if (! t
->u
.s
.line
.file
)
2156 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2158 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2160 error_at_line (d
->line
,
2161 "structure `%s' defined for mismatching languages",
2163 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2166 /* Some things may also be defined in the structure's options. */
2167 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2168 if (! desc
&& strcmp (o
->name
, "desc") == 0)
2171 d
->prev_val
[2] = oldval
;
2172 d
->prev_val
[1] = oldprevval2
;
2177 error_at_line (d
->line
, "missing `desc' option for union `%s'",
2181 oprintf (d
->of
, "%*sswitch (", d
->indent
, "");
2182 output_escaped_param (d
, desc
, "desc");
2183 oprintf (d
->of
, ")\n");
2185 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2187 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
2190 const char *dot
= ".";
2191 const char *tagid
= NULL
;
2194 int use_param_p
= 0;
2197 d
->reorder_fn
= NULL
;
2198 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2199 if (strcmp (oo
->name
, "dot") == 0)
2201 else if (strcmp (oo
->name
, "tag") == 0)
2203 else if (strcmp (oo
->name
, "skip") == 0)
2205 else if (strcmp (oo
->name
, "default") == 0)
2207 else if (strcmp (oo
->name
, "reorder") == 0)
2208 d
->reorder_fn
= oo
->info
;
2209 else if (strncmp (oo
->name
, "use_param", 9) == 0
2210 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2216 if (union_p
&& tagid
)
2218 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
2221 else if (union_p
&& default_p
)
2223 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2227 else if (! union_p
&& (default_p
|| tagid
))
2228 error_at_line (d
->line
,
2229 "can't use `%s' outside a union on field `%s'",
2230 default_p
? "default" : "tag", f
->name
);
2231 else if (union_p
&& ! (default_p
|| tagid
)
2232 && f
->type
->kind
== TYPE_SCALAR
)
2235 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2236 d
->line
->file
, d
->line
->line
, f
->name
);
2239 else if (union_p
&& ! (default_p
|| tagid
))
2240 error_at_line (d
->line
,
2241 "field `%s' is missing `tag' or `default' option",
2245 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
2247 d
->used_length
= false;
2249 if (union_p
&& use_param_p
&& d
->param
== NULL
)
2250 oprintf (d
->of
, "%*sgcc_unreachable ();\n", d
->indent
, "");
2252 walk_type (f
->type
, d
);
2258 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2262 d
->reorder_fn
= NULL
;
2265 d
->prev_val
[1] = oldprevval1
;
2266 d
->prev_val
[2] = oldprevval2
;
2268 if (union_p
&& ! seen_default_p
)
2270 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2271 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
2275 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2281 case TYPE_LANG_STRUCT
:
2284 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
2285 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
2288 error_at_line (d
->line
, "structure `%s' differs between languages",
2295 case TYPE_PARAM_STRUCT
:
2297 type_p
*oldparam
= d
->param
;
2299 d
->param
= t
->u
.param_struct
.param
;
2300 walk_type (t
->u
.param_struct
.stru
, d
);
2301 d
->param
= oldparam
;
2310 /* process_field routine for marking routines. */
2313 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
2315 const struct write_types_data
*wtd
;
2316 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
2317 wtd
= (const struct write_types_data
*) d
->cookie
;
2322 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
2323 wtd
->subfield_marker_routine
, cast
, d
->val
);
2324 if (wtd
->param_prefix
)
2326 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
2329 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
2330 output_mangled_typename (d
->of
, d
->orig_s
);
2333 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
2335 if (f
->u
.p
->kind
== TYPE_PARAM_STRUCT
2336 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2338 oprintf (d
->of
, ", gt_e_");
2339 output_mangled_typename (d
->of
, f
);
2341 else if (UNION_OR_STRUCT_P (f
)
2342 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2344 oprintf (d
->of
, ", gt_ggc_e_");
2345 output_mangled_typename (d
->of
, f
);
2348 oprintf (d
->of
, ", gt_types_enum_last");
2350 oprintf (d
->of
, ");\n");
2351 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2352 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
2353 wtd
->reorder_note_routine
, cast
, d
->val
,
2354 d
->prev_val
[3], d
->reorder_fn
);
2358 if (wtd
->param_prefix
== NULL
)
2363 case TYPE_LANG_STRUCT
:
2364 case TYPE_PARAM_STRUCT
:
2365 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
2366 output_mangled_typename (d
->of
, f
);
2367 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
2368 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2369 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
2370 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
2382 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2385 output_type_enum (outf_p of
, type_p s
)
2387 if (s
->kind
== TYPE_PARAM_STRUCT
&& s
->u
.s
.line
.file
!= NULL
)
2389 oprintf (of
, ", gt_e_");
2390 output_mangled_typename (of
, s
);
2392 else if (UNION_OR_STRUCT_P (s
) && s
->u
.s
.line
.file
!= NULL
)
2394 oprintf (of
, ", gt_ggc_e_");
2395 output_mangled_typename (of
, s
);
2398 oprintf (of
, ", gt_types_enum_last");
2401 /* For S, a structure that's part of ORIG_S, and using parameters
2402 PARAM, write out a routine that:
2403 - Takes a parameter, a void * but actually of type *S
2404 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2405 field of S or its substructures and (in some cases) things
2406 that are pointed to by S.
2410 write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2411 const struct write_types_data
*wtd
)
2413 const char *fn
= s
->u
.s
.line
.file
;
2415 const char *chain_next
= NULL
;
2416 const char *chain_prev
= NULL
;
2417 const char *mark_hook_name
= NULL
;
2419 struct walk_type_data d
;
2421 /* This is a hack, and not the good kind either. */
2422 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2423 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2424 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2425 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2427 memset (&d
, 0, sizeof (d
));
2428 d
.of
= get_output_file_with_visibility (fn
);
2430 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2431 if (strcmp (opt
->name
, "chain_next") == 0)
2432 chain_next
= opt
->info
;
2433 else if (strcmp (opt
->name
, "chain_prev") == 0)
2434 chain_prev
= opt
->info
;
2435 else if (strcmp (opt
->name
, "mark_hook") == 0)
2436 mark_hook_name
= opt
->info
;
2438 if (chain_prev
!= NULL
&& chain_next
== NULL
)
2439 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
2441 d
.process_field
= write_types_process_field
;
2445 d
.line
= &s
->u
.s
.line
;
2446 d
.bitmap
= s
->u
.s
.bitmap
;
2448 d
.prev_val
[0] = "*x";
2449 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2450 d
.prev_val
[3] = "x";
2453 oprintf (d
.of
, "\n");
2454 oprintf (d
.of
, "void\n");
2456 oprintf (d
.of
, "gt_%sx_%s", wtd
->prefix
, orig_s
->u
.s
.tag
);
2459 oprintf (d
.of
, "gt_%s_", wtd
->prefix
);
2460 output_mangled_typename (d
.of
, orig_s
);
2462 oprintf (d
.of
, " (void *x_p)\n");
2463 oprintf (d
.of
, "{\n");
2464 oprintf (d
.of
, " %s %s * %sx = (%s %s *)x_p;\n",
2465 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2466 chain_next
== NULL
? "const " : "",
2467 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2468 if (chain_next
!= NULL
)
2469 oprintf (d
.of
, " %s %s * xlimit = x;\n",
2470 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2471 if (chain_next
== NULL
)
2473 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
2474 if (wtd
->param_prefix
)
2476 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
2477 output_mangled_typename (d
.of
, orig_s
);
2478 output_type_enum (d
.of
, orig_s
);
2480 oprintf (d
.of
, "))\n");
2484 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2485 if (wtd
->param_prefix
)
2487 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2488 output_mangled_typename (d
.of
, orig_s
);
2489 output_type_enum (d
.of
, orig_s
);
2491 oprintf (d
.of
, "))\n");
2492 if (mark_hook_name
&& !wtd
->skip_hooks
)
2494 oprintf (d
.of
, " {\n");
2495 oprintf (d
.of
, " %s (xlimit);\n ", mark_hook_name
);
2497 oprintf (d
.of
, " xlimit = (");
2498 d
.prev_val
[2] = "*xlimit";
2499 output_escaped_param (&d
, chain_next
, "chain_next");
2500 oprintf (d
.of
, ");\n");
2501 if (mark_hook_name
&& !wtd
->skip_hooks
)
2502 oprintf (d
.of
, " }\n");
2503 if (chain_prev
!= NULL
)
2505 oprintf (d
.of
, " if (x != xlimit)\n");
2506 oprintf (d
.of
, " for (;;)\n");
2507 oprintf (d
.of
, " {\n");
2508 oprintf (d
.of
, " %s %s * const xprev = (",
2509 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2511 d
.prev_val
[2] = "*x";
2512 output_escaped_param (&d
, chain_prev
, "chain_prev");
2513 oprintf (d
.of
, ");\n");
2514 oprintf (d
.of
, " if (xprev == NULL) break;\n");
2515 oprintf (d
.of
, " x = xprev;\n");
2516 oprintf (d
.of
, " (void) %s (xprev",
2517 wtd
->marker_routine
);
2518 if (wtd
->param_prefix
)
2520 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
2521 output_mangled_typename (d
.of
, orig_s
);
2522 output_type_enum (d
.of
, orig_s
);
2524 oprintf (d
.of
, ");\n");
2525 oprintf (d
.of
, " }\n");
2527 oprintf (d
.of
, " while (x != xlimit)\n");
2529 oprintf (d
.of
, " {\n");
2530 if (mark_hook_name
&& chain_next
== NULL
&& !wtd
->skip_hooks
)
2532 oprintf (d
.of
, " %s (x);\n", mark_hook_name
);
2534 d
.prev_val
[2] = "*x";
2538 if (chain_next
!= NULL
)
2540 oprintf (d
.of
, " x = (");
2541 output_escaped_param (&d
, chain_next
, "chain_next");
2542 oprintf (d
.of
, ");\n");
2545 oprintf (d
.of
, " }\n");
2546 oprintf (d
.of
, "}\n");
2549 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
2552 write_types (type_p structures
, type_p param_structs
,
2553 const struct write_types_data
*wtd
)
2557 oprintf (header_file
, "\n/* %s*/\n", wtd
->comment
);
2558 for (s
= structures
; s
; s
= s
->next
)
2559 if (s
->gc_used
== GC_POINTED_TO
2560 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2564 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2565 && s
->u
.s
.line
.file
== NULL
)
2568 oprintf (header_file
, "#define gt_%s_", wtd
->prefix
);
2569 output_mangled_typename (header_file
, s
);
2570 oprintf (header_file
, "(X) do { \\\n");
2571 oprintf (header_file
,
2572 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
2574 oprintf (header_file
,
2577 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2578 if (strcmp (opt
->name
, "ptr_alias") == 0)
2580 const_type_p
const t
= (const_type_p
) opt
->info
;
2581 if (t
->kind
== TYPE_STRUCT
2582 || t
->kind
== TYPE_UNION
2583 || t
->kind
== TYPE_LANG_STRUCT
)
2584 oprintf (header_file
,
2585 "#define gt_%sx_%s gt_%sx_%s\n",
2586 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t
->u
.s
.tag
);
2588 error_at_line (&s
->u
.s
.line
,
2589 "structure alias is not a structure");
2595 /* Declare the marker procedure only once. */
2596 oprintf (header_file
,
2597 "extern void gt_%sx_%s (void *);\n",
2598 wtd
->prefix
, s
->u
.s
.tag
);
2600 if (s
->u
.s
.line
.file
== NULL
)
2602 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2607 if (s
->kind
== TYPE_LANG_STRUCT
)
2610 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2611 write_func_for_structure (s
, ss
, NULL
, wtd
);
2614 write_func_for_structure (s
, s
, NULL
, wtd
);
2617 for (s
= param_structs
; s
; s
= s
->next
)
2618 if (s
->gc_used
== GC_POINTED_TO
)
2620 type_p
* param
= s
->u
.param_struct
.param
;
2621 type_p stru
= s
->u
.param_struct
.stru
;
2623 /* Declare the marker procedure. */
2624 oprintf (header_file
, "extern void gt_%s_", wtd
->prefix
);
2625 output_mangled_typename (header_file
, s
);
2626 oprintf (header_file
, " (void *);\n");
2628 if (stru
->u
.s
.line
.file
== NULL
)
2630 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2635 if (stru
->kind
== TYPE_LANG_STRUCT
)
2638 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2639 write_func_for_structure (s
, ss
, param
, wtd
);
2642 write_func_for_structure (s
, stru
, param
, wtd
);
2646 static const struct write_types_data ggc_wtd
=
2648 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
2649 "GC marker procedures. ",
2653 static const struct write_types_data pch_wtd
=
2655 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
2656 "gt_pch_note_reorder",
2657 "PCH type-walking procedures. ",
2661 /* Write out the local pointer-walking routines. */
2663 /* process_field routine for local pointer-walking. */
2666 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
2673 case TYPE_LANG_STRUCT
:
2674 case TYPE_PARAM_STRUCT
:
2676 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
2678 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
2689 /* For S, a structure that's part of ORIG_S, and using parameters
2690 PARAM, write out a routine that:
2691 - Is of type gt_note_pointers
2692 - Calls PROCESS_FIELD on each field of S or its substructures.
2696 write_local_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
)
2698 const char *fn
= s
->u
.s
.line
.file
;
2700 struct walk_type_data d
;
2702 /* This is a hack, and not the good kind either. */
2703 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2704 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2705 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2706 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2708 memset (&d
, 0, sizeof (d
));
2709 d
.of
= get_output_file_with_visibility (fn
);
2711 d
.process_field
= write_types_local_process_field
;
2713 d
.line
= &s
->u
.s
.line
;
2714 d
.bitmap
= s
->u
.s
.bitmap
;
2716 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
2717 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2718 d
.prev_val
[3] = "x";
2720 d
.fn_wants_lvalue
= true;
2722 oprintf (d
.of
, "\n");
2723 oprintf (d
.of
, "void\n");
2724 oprintf (d
.of
, "gt_pch_p_");
2725 output_mangled_typename (d
.of
, orig_s
);
2726 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
2728 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2729 "\tATTRIBUTE_UNUSED void *cookie)\n");
2730 oprintf (d
.of
, "{\n");
2731 oprintf (d
.of
, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
2732 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2733 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2736 oprintf (d
.of
, "}\n");
2739 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
2742 write_local (type_p structures
, type_p param_structs
)
2746 oprintf (header_file
, "\n/* Local pointer-walking routines. */\n");
2747 for (s
= structures
; s
; s
= s
->next
)
2748 if (s
->gc_used
== GC_POINTED_TO
2749 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2753 if (s
->u
.s
.line
.file
== NULL
)
2756 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2757 if (strcmp (opt
->name
, "ptr_alias") == 0)
2759 const_type_p
const t
= (const_type_p
) opt
->info
;
2760 if (t
->kind
== TYPE_STRUCT
2761 || t
->kind
== TYPE_UNION
2762 || t
->kind
== TYPE_LANG_STRUCT
)
2764 oprintf (header_file
, "#define gt_pch_p_");
2765 output_mangled_typename (header_file
, s
);
2766 oprintf (header_file
, " gt_pch_p_");
2767 output_mangled_typename (header_file
, t
);
2768 oprintf (header_file
, "\n");
2771 error_at_line (&s
->u
.s
.line
,
2772 "structure alias is not a structure");
2778 /* Declare the marker procedure only once. */
2779 oprintf (header_file
, "extern void gt_pch_p_");
2780 output_mangled_typename (header_file
, s
);
2781 oprintf (header_file
,
2782 "\n (void *, void *, gt_pointer_operator, void *);\n");
2784 if (s
->kind
== TYPE_LANG_STRUCT
)
2787 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2788 write_local_func_for_structure (s
, ss
, NULL
);
2791 write_local_func_for_structure (s
, s
, NULL
);
2794 for (s
= param_structs
; s
; s
= s
->next
)
2795 if (s
->gc_used
== GC_POINTED_TO
)
2797 type_p
* param
= s
->u
.param_struct
.param
;
2798 type_p stru
= s
->u
.param_struct
.stru
;
2800 /* Declare the marker procedure. */
2801 oprintf (header_file
, "extern void gt_pch_p_");
2802 output_mangled_typename (header_file
, s
);
2803 oprintf (header_file
,
2804 "\n (void *, void *, gt_pointer_operator, void *);\n");
2806 if (stru
->u
.s
.line
.file
== NULL
)
2808 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2813 if (stru
->kind
== TYPE_LANG_STRUCT
)
2816 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2817 write_local_func_for_structure (s
, ss
, param
);
2820 write_local_func_for_structure (s
, stru
, param
);
2824 /* Write out the 'enum' definition for gt_types_enum. */
2827 write_enum_defn (type_p structures
, type_p param_structs
)
2831 oprintf (header_file
, "\n/* Enumeration of types known. */\n");
2832 oprintf (header_file
, "enum gt_types_enum {\n");
2833 for (s
= structures
; s
; s
= s
->next
)
2834 if (s
->gc_used
== GC_POINTED_TO
2835 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2837 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2838 && s
->u
.s
.line
.file
== NULL
)
2841 oprintf (header_file
, " gt_ggc_e_");
2842 output_mangled_typename (header_file
, s
);
2843 oprintf (header_file
, ", \n");
2845 for (s
= param_structs
; s
; s
= s
->next
)
2846 if (s
->gc_used
== GC_POINTED_TO
)
2848 oprintf (header_file
, " gt_e_");
2849 output_mangled_typename (header_file
, s
);
2850 oprintf (header_file
, ", \n");
2852 oprintf (header_file
, " gt_types_enum_last\n");
2853 oprintf (header_file
, "};\n");
2856 /* Might T contain any non-pointer elements? */
2859 contains_scalar_p (type_p t
)
2867 return contains_scalar_p (t
->u
.a
.p
);
2869 /* Could also check for structures that have no non-pointer
2870 fields, but there aren't enough of those to worry about. */
2875 /* Mangle FN and print it to F. */
2878 put_mangled_filename (outf_p f
, const char *fn
)
2880 const char *name
= get_output_file_name (fn
);
2881 for (; *name
!= 0; name
++)
2882 if (ISALNUM (*name
))
2883 oprintf (f
, "%c", *name
);
2885 oprintf (f
, "%c", '_');
2888 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
2889 LASTNAME, and NAME are all strings to insert in various places in
2890 the resulting code. */
2893 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
2894 const char *tname
, const char *name
)
2898 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
2899 if (fli2
->started_p
)
2901 oprintf (fli2
->f
, " %s\n", lastname
);
2902 oprintf (fli2
->f
, "};\n\n");
2905 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
2906 if (fli2
->started_p
)
2908 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
2911 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
2914 oprintf (base_files
[fnum
],
2915 "extern const struct %s gt_%s_",
2917 put_mangled_filename (base_files
[fnum
], fli2
->name
);
2918 oprintf (base_files
[fnum
], "[];\n");
2924 for (fnum
= 0; fnum
< num_lang_dirs
; fnum
++)
2925 oprintf (base_files
[fnum
],
2926 "const struct %s * const %s[] = {\n",
2931 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
2932 if (fli2
->started_p
)
2934 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
2937 fli2
->started_p
= 0;
2939 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
2942 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
2943 put_mangled_filename (base_files
[fnum
], fli2
->name
);
2944 oprintf (base_files
[fnum
], ",\n");
2950 for (fnum
= 0; fnum
< num_lang_dirs
; fnum
++)
2952 oprintf (base_files
[fnum
], " NULL\n");
2953 oprintf (base_files
[fnum
], "};\n");
2958 /* Write out to F the table entry and any marker routines needed to
2959 mark NAME as TYPE. The original variable is V, at LINE.
2960 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
2961 is nonzero iff we are building the root table for hash table caches. */
2964 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
2965 struct fileloc
*line
, const char *if_marked
)
2972 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
2975 const char *desc
= NULL
;
2978 for (o
= fld
->opt
; o
; o
= o
->next
)
2979 if (strcmp (o
->name
, "skip") == 0)
2981 else if (strcmp (o
->name
, "desc") == 0)
2983 else if (strcmp (o
->name
, "param_is") == 0)
2986 error_at_line (line
,
2987 "field `%s' of global `%s' has unknown option `%s'",
2988 fld
->name
, name
, o
->name
);
2992 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
2994 pair_p validf
= NULL
;
2997 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
2999 const char *tag
= NULL
;
3002 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
3003 if (strcmp (oo
->name
, "tag") == 0)
3005 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
3008 error_at_line (line
,
3009 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3010 name
, fld
->name
, validf
->name
,
3011 name
, fld
->name
, ufld
->name
,
3018 newname
= xasprintf ("%s.%s.%s",
3019 name
, fld
->name
, validf
->name
);
3020 write_root (f
, v
, validf
->type
, newname
, 0, line
,
3026 error_at_line (line
,
3027 "global `%s.%s' has `desc' option but is not union",
3032 newname
= xasprintf ("%s.%s", name
, fld
->name
);
3033 write_root (f
, v
, fld
->type
, newname
, 0, line
, if_marked
);
3043 newname
= xasprintf ("%s[0]", name
);
3044 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, if_marked
);
3053 oprintf (f
, " {\n");
3054 oprintf (f
, " &%s,\n", name
);
3057 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3059 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
3060 else if (ap
== v
->type
)
3061 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
3063 oprintf (f
, " sizeof (%s", v
->name
);
3064 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3066 oprintf (f
, "),\n");
3070 if (! has_length
&& UNION_OR_STRUCT_P (tp
))
3072 oprintf (f
, " >_ggc_mx_%s,\n", tp
->u
.s
.tag
);
3073 oprintf (f
, " >_pch_nx_%s", tp
->u
.s
.tag
);
3075 else if (! has_length
&& tp
->kind
== TYPE_PARAM_STRUCT
)
3077 oprintf (f
, " >_ggc_m_");
3078 output_mangled_typename (f
, tp
);
3079 oprintf (f
, ",\n >_pch_n_");
3080 output_mangled_typename (f
, tp
);
3083 && (tp
->kind
== TYPE_POINTER
|| UNION_OR_STRUCT_P (tp
)))
3085 oprintf (f
, " >_ggc_ma_%s,\n", name
);
3086 oprintf (f
, " >_pch_na_%s", name
);
3090 error_at_line (line
,
3091 "global `%s' is pointer to unimplemented type",
3095 oprintf (f
, ",\n &%s", if_marked
);
3096 oprintf (f
, "\n },\n");
3102 oprintf (f
, " {\n");
3103 oprintf (f
, " &%s,\n", name
);
3104 oprintf (f
, " 1, \n");
3105 oprintf (f
, " sizeof (%s),\n", v
->name
);
3106 oprintf (f
, " >_ggc_m_S,\n");
3107 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
3108 oprintf (f
, " },\n");
3116 error_at_line (line
,
3117 "global `%s' is unimplemented type",
3122 /* This generates a routine to walk an array. */
3125 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
3127 struct walk_type_data d
;
3130 memset (&d
, 0, sizeof (d
));
3136 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
3139 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
3141 if (wtd
->param_prefix
)
3143 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
3145 " (void *, void *, gt_pointer_operator, void *);\n");
3146 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3147 wtd
->param_prefix
, v
->name
);
3149 " ATTRIBUTE_UNUSED void *x_p,\n"
3150 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3151 " ATTRIBUTE_UNUSED void * cookie)\n");
3152 oprintf (d
.of
, "{\n");
3153 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3154 d
.process_field
= write_types_local_process_field
;
3155 walk_type (v
->type
, &d
);
3156 oprintf (f
, "}\n\n");
3160 oprintf (f
, "static void gt_%sa_%s (void *);\n",
3161 wtd
->prefix
, v
->name
);
3162 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3163 wtd
->prefix
, v
->name
);
3165 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3166 d
.process_field
= write_types_process_field
;
3167 walk_type (v
->type
, &d
);
3169 oprintf (f
, "}\n\n");
3172 /* Output a table describing the locations and types of VARIABLES. */
3175 write_roots (pair_p variables
)
3178 struct flist
*flp
= NULL
;
3180 for (v
= variables
; v
; v
= v
->next
)
3182 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3184 const char *length
= NULL
;
3185 int deletable_p
= 0;
3188 for (o
= v
->opt
; o
; o
= o
->next
)
3189 if (strcmp (o
->name
, "length") == 0)
3191 else if (strcmp (o
->name
, "deletable") == 0)
3193 else if (strcmp (o
->name
, "param_is") == 0)
3195 else if (strncmp (o
->name
, "param", 5) == 0
3196 && ISDIGIT (o
->name
[5])
3197 && strcmp (o
->name
+ 6, "_is") == 0)
3199 else if (strcmp (o
->name
, "if_marked") == 0)
3202 error_at_line (&v
->line
,
3203 "global `%s' has unknown option `%s'",
3206 for (fli
= flp
; fli
; fli
= fli
->next
)
3211 fli
= XNEW (struct flist
);
3215 fli
->name
= v
->line
.file
;
3218 oprintf (f
, "\n/* GC roots. */\n\n");
3223 && v
->type
->kind
== TYPE_POINTER
3224 && (v
->type
->u
.p
->kind
== TYPE_POINTER
3225 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
3227 write_array (f
, v
, &ggc_wtd
);
3228 write_array (f
, v
, &pch_wtd
);
3232 for (v
= variables
; v
; v
= v
->next
)
3234 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3240 for (o
= v
->opt
; o
; o
= o
->next
)
3241 if (strcmp (o
->name
, "length") == 0)
3243 else if (strcmp (o
->name
, "deletable") == 0
3244 || strcmp (o
->name
, "if_marked") == 0)
3250 for (fli
= flp
; fli
; fli
= fli
->next
)
3253 if (! fli
->started_p
)
3257 oprintf (f
, "const struct ggc_root_tab gt_ggc_r_");
3258 put_mangled_filename (f
, v
->line
.file
);
3259 oprintf (f
, "[] = {\n");
3262 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3265 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3268 for (v
= variables
; v
; v
= v
->next
)
3270 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3275 for (o
= v
->opt
; o
; o
= o
->next
)
3276 if (strcmp (o
->name
, "deletable") == 0)
3278 else if (strcmp (o
->name
, "if_marked") == 0)
3284 for (fli
= flp
; fli
; fli
= fli
->next
)
3287 if (! fli
->started_p
)
3291 oprintf (f
, "const struct ggc_root_tab gt_ggc_rd_");
3292 put_mangled_filename (f
, v
->line
.file
);
3293 oprintf (f
, "[] = {\n");
3296 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3300 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3301 "gt_ggc_deletable_rtab");
3303 for (v
= variables
; v
; v
= v
->next
)
3305 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3307 const char *if_marked
= NULL
;
3311 for (o
= v
->opt
; o
; o
= o
->next
)
3312 if (strcmp (o
->name
, "length") == 0)
3314 else if (strcmp (o
->name
, "if_marked") == 0)
3315 if_marked
= o
->info
;
3317 if (if_marked
== NULL
)
3320 if (v
->type
->kind
!= TYPE_POINTER
3321 || v
->type
->u
.p
->kind
!= TYPE_PARAM_STRUCT
3322 || v
->type
->u
.p
->u
.param_struct
.stru
!= find_structure ("htab", 0))
3324 error_at_line (&v
->line
, "if_marked option used but not hash table");
3328 for (fli
= flp
; fli
; fli
= fli
->next
)
3331 if (! fli
->started_p
)
3335 oprintf (f
, "const struct ggc_cache_tab gt_ggc_rc_");
3336 put_mangled_filename (f
, v
->line
.file
);
3337 oprintf (f
, "[] = {\n");
3340 write_root (f
, v
, v
->type
->u
.p
->u
.param_struct
.param
[0],
3341 v
->name
, length_p
, &v
->line
, if_marked
);
3344 finish_root_table (flp
, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
3345 "gt_ggc_cache_rtab");
3347 for (v
= variables
; v
; v
= v
->next
)
3349 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3352 int if_marked_p
= 0;
3355 for (o
= v
->opt
; o
; o
= o
->next
)
3356 if (strcmp (o
->name
, "length") == 0)
3358 else if (strcmp (o
->name
, "if_marked") == 0)
3364 for (fli
= flp
; fli
; fli
= fli
->next
)
3367 if (! fli
->started_p
)
3371 oprintf (f
, "const struct ggc_root_tab gt_pch_rc_");
3372 put_mangled_filename (f
, v
->line
.file
);
3373 oprintf (f
, "[] = {\n");
3376 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3379 finish_root_table (flp
, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3380 "gt_pch_cache_rtab");
3382 for (v
= variables
; v
; v
= v
->next
)
3384 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3389 for (o
= v
->opt
; o
; o
= o
->next
)
3390 if (strcmp (o
->name
, "deletable") == 0
3391 || strcmp (o
->name
, "if_marked") == 0)
3397 if (! contains_scalar_p (v
->type
))
3400 for (fli
= flp
; fli
; fli
= fli
->next
)
3403 if (! fli
->started_p
)
3407 oprintf (f
, "const struct ggc_root_tab gt_pch_rs_");
3408 put_mangled_filename (f
, v
->line
.file
);
3409 oprintf (f
, "[] = {\n");
3412 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3416 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3417 "gt_pch_scalar_rtab");
3420 /* Record the definition of a generic VEC structure, as if we had expanded
3421 the macros in vec.h:
3423 typedef struct VEC_<type>_base GTY(()) {
3426 <type> GTY((length ("%h.num"))) vec[1];
3429 where the GTY(()) tags are only present if is_scalar is _false_. */
3432 note_def_vec (const char *typename
, bool is_scalar
, struct fileloc
*pos
)
3437 type_p len_ty
= create_scalar_type ("unsigned");
3438 const char *name
= concat ("VEC_", typename
, "_base", (char *)0);
3442 t
= create_scalar_type (typename
);
3447 t
= resolve_typedef (typename
, pos
);
3448 o
= create_option (0, "length", "%h.num");
3451 /* We assemble the field list in reverse order. */
3452 fields
= create_field_at (0, create_array (t
, "1"), "vec", o
, pos
);
3453 fields
= create_field_at (fields
, len_ty
, "alloc", 0, pos
);
3454 fields
= create_field_at (fields
, len_ty
, "num", 0, pos
);
3456 do_typedef (name
, new_structure (name
, 0, pos
, fields
, 0), pos
);
3459 /* Record the definition of an allocation-specific VEC structure, as if
3460 we had expanded the macros in vec.h:
3462 typedef struct VEC_<type>_<astrat> {
3463 VEC_<type>_base base;
3464 } VEC_<type>_<astrat>;
3467 note_def_vec_alloc (const char *type
, const char *astrat
, struct fileloc
*pos
)
3469 const char *astratname
= concat ("VEC_", type
, "_", astrat
, (char *)0);
3470 const char *basename
= concat ("VEC_", type
, "_base", (char *)0);
3472 pair_p field
= create_field_at (0, resolve_typedef (basename
, pos
),
3475 do_typedef (astratname
, new_structure (astratname
, 0, pos
, field
, 0), pos
);
3480 main (int argc
, char **argv
)
3483 static struct fileloc pos
= { this_file
, 0 };
3485 /* fatal uses this */
3486 progname
= "gengtype";
3489 fatal ("usage: gengtype srcdir input-list");
3492 srcdir_len
= strlen (srcdir
);
3494 read_input_list (argv
[2]);
3498 scalar_char
.u
.scalar_is_char
= true;
3499 scalar_nonchar
.u
.scalar_is_char
= false;
3502 /* These types are set up with #define or else outside of where
3504 pos
.line
= __LINE__
+ 1;
3505 do_scalar_typedef ("CUMULATIVE_ARGS", &pos
); pos
.line
++;
3506 do_scalar_typedef ("REAL_VALUE_TYPE", &pos
); pos
.line
++;
3507 do_scalar_typedef ("FIXED_VALUE_TYPE", &pos
); pos
.line
++;
3508 do_scalar_typedef ("double_int", &pos
); pos
.line
++;
3509 do_scalar_typedef ("uint8", &pos
); pos
.line
++;
3510 do_scalar_typedef ("jword", &pos
); pos
.line
++;
3511 do_scalar_typedef ("JCF_u2", &pos
); pos
.line
++;
3512 do_scalar_typedef ("void", &pos
); pos
.line
++;
3513 do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos
)), &pos
);
3515 for (i
= 0; i
< num_gt_files
; i
++)
3516 parse_file (gt_files
[i
]);
3521 set_gc_used (variables
);
3524 write_enum_defn (structures
, param_structs
);
3525 write_types (structures
, param_structs
, &ggc_wtd
);
3526 write_types (structures
, param_structs
, &pch_wtd
);
3527 write_local (structures
, param_structs
);
3528 write_roots (variables
);
3530 close_output_files ();