1 /* Process source files and output type information.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
25 #include "errors.h" /* for fatal */
26 #include "double-int.h"
28 /* Data types, macros, etc. used only in this file. */
30 /* Kinds of types we can understand. */
42 typedef unsigned lang_bitmap
;
44 /* A way to pass data through to the output end. */
52 /* Option data for the 'nested_ptr' option. */
53 struct nested_ptr_data
56 const char *convert_to
;
57 const char *convert_from
;
60 /* A name and a type. */
72 /* A description of a type. */
86 enum gc_used_enum gc_used
;
104 type_p param
[NUM_PARAM
];
111 ((x)->kind == TYPE_UNION || \
112 ((x)->kind == TYPE_LANG_STRUCT \
113 && (x)->u.s.lang_struct->kind == TYPE_UNION))
114 #define UNION_OR_STRUCT_P(x) \
115 ((x)->kind == TYPE_UNION \
116 || (x)->kind == TYPE_STRUCT \
117 || (x)->kind == TYPE_LANG_STRUCT)
119 /* Structure representing an output file. */
128 typedef struct outf
* outf_p
;
130 /* An output file, suitable for definitions, that can see declarations
131 made in INPUT_FILE and is linked into every language that uses
133 extern outf_p get_output_file_with_visibility
134 (const char *input_file
);
135 const char *get_output_file_name (const char *);
137 /* Print, like fprintf, to O. */
138 static void oprintf (outf_p o
, const char *S
, ...)
141 /* The list of output files. */
142 static outf_p output_files
;
144 /* The output header file that is included into pretty much every
146 static outf_p header_file
;
148 /* Source directory. */
149 static const char *srcdir
;
151 /* Length of srcdir name. */
152 static int srcdir_len
= 0;
154 static outf_p
create_file (const char *, const char *);
155 static const char * get_file_basename (const char *);
158 /* Nonzero iff an error has occurred. */
159 bool hit_error
= false;
161 static void gen_rtx_next (void);
162 static void write_rtx_next (void);
163 static void open_base_files (void);
164 static void close_output_files (void);
166 /* Report an error at POS, printing MSG. */
169 error_at_line (struct fileloc
*pos
, const char *msg
, ...)
175 fprintf (stderr
, "%s:%d: ", pos
->file
, pos
->line
);
176 vfprintf (stderr
, msg
, ap
);
177 fputc ('\n', stderr
);
183 /* asprintf, but produces fatal message on out-of-memory. */
185 xasprintf (const char *format
, ...)
191 va_start (ap
, format
);
192 n
= vasprintf (&result
, format
, ap
);
193 if (result
== NULL
|| n
< 0)
194 fatal ("out of memory");
200 /* Input file handling. */
202 /* Table of all input files. */
203 static const char **gt_files
;
204 static size_t num_gt_files
;
206 /* A number of places use the name of this file for a location for
207 things that we can't rely on the source to define. Make sure we
208 can still use pointer comparison on filenames. */
209 static const char this_file
[] = __FILE__
;
211 /* Vector of per-language directories. */
212 static const char **lang_dir_names
;
213 static size_t num_lang_dirs
;
215 /* An array of output files suitable for definitions. There is one
216 BASE_FILES entry for each language. */
217 static outf_p
*base_files
;
219 /* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
220 INPUT_FILE is used by <lang>.
222 This function should be written to assume that a file _is_ used
223 if the situation is unclear. If it wrongly assumes a file _is_ used,
224 a linker error will result. If it wrongly assumes a file _is not_ used,
225 some GC roots may be missed, which is a much harder-to-debug problem.
227 The relevant bitmap is stored immediately before the file's name in the
228 buffer set up by read_input_list. It may be unaligned, so we have to
229 read it byte-by-byte. */
232 get_lang_bitmap (const char *gtfile
)
235 if (gtfile
== this_file
)
236 /* Things defined in this file are universal. */
237 return (((lang_bitmap
)1) << num_lang_dirs
) - 1;
242 for (i
= -(int) sizeof (lang_bitmap
); i
< 0; i
++)
243 n
= (n
<< CHAR_BIT
) + (unsigned char)gtfile
[i
];
248 /* Set the bitmap returned by get_lang_bitmap. The only legitimate
249 caller of this function is read_input_list. */
251 set_lang_bitmap (char *gtfile
, lang_bitmap n
)
254 for (i
= -1; i
>= -(int) sizeof (lang_bitmap
); i
--)
256 gtfile
[i
] = n
& ((1U << CHAR_BIT
)-1);
261 /* Scan the input file, LIST, and determine how much space we need to
262 store strings in. Also, count the number of language directories
263 and files. The numbers returned are overestimates as they does not
264 consider repeated files. */
266 measure_input_list (FILE *list
)
273 while ((c
= getc (list
)) != EOF
)
282 /* Add space for a lang_bitmap before the input file name. */
283 n
+= sizeof (lang_bitmap
);
297 /* Read one input line from LIST to HEREP (which is updated). A
298 pointer to the string is returned via LINEP. If it was a language
299 subdirectory in square brackets, strip off the square brackets and
300 return true. Otherwise, leave space before the string for a
301 lang_bitmap, and return false. At EOF, returns false, does not
302 touch *HEREP, and sets *LINEP to NULL. POS is used for
305 read_input_line (FILE *list
, char **herep
, char **linep
,
319 /* No space for a lang_bitmap is necessary. Discard the '['. */
322 while (c
!= ']' && c
!= '\n' && c
!= EOF
)
331 c
= getc (list
); /* eat what should be a newline */
332 if (c
!= '\n' && c
!= EOF
)
333 error_at_line (pos
, "junk on line after language tag [%s]", line
);
336 error_at_line (pos
, "missing close bracket for language tag [%s", line
);
344 /* Leave space for a lang_bitmap. */
345 memset (here
, 0, sizeof (lang_bitmap
));
346 here
+= sizeof (lang_bitmap
);
353 while (c
!= EOF
&& c
!= '\n');
361 /* Read the list of input files from LIST and compute all of the
362 relevant tables. There is one file per line of the list. At
363 first, all the files on the list are language-generic, but
364 eventually a line will appear which is the name of a language
365 subdirectory in square brackets, like this: [cp]. All subsequent
366 files are specific to that language, until another language
367 subdirectory tag appears. Files can appear more than once, if
368 they apply to more than one language. */
370 read_input_list (const char *listname
)
372 FILE *list
= fopen (listname
, "r");
374 fatal ("cannot open %s: %s", listname
, strerror (errno
));
378 size_t bufsz
= measure_input_list (list
);
379 char *buf
= XNEWVEC (char, bufsz
);
381 char *committed
= buf
;
382 char *limit
= buf
+ bufsz
;
387 lang_bitmap curlangs
= (1 << num_lang_dirs
) - 1;
389 epos
.file
= listname
;
392 lang_dir_names
= XNEWVEC (const char *, num_lang_dirs
);
393 gt_files
= XNEWVEC (const char *, num_gt_files
);
400 is_language
= read_input_line (list
, &here
, &line
, &epos
);
401 gcc_assert (here
<= limit
);
404 else if (is_language
)
407 gcc_assert (langno
<= num_lang_dirs
);
408 for (i
= 0; i
< langno
; i
++)
409 if (strcmp (lang_dir_names
[i
], line
) == 0)
411 error_at_line (&epos
, "duplicate language tag [%s]", line
);
417 curlangs
= 1 << langno
;
418 lang_dir_names
[langno
++] = line
;
423 gcc_assert (nfiles
<= num_gt_files
);
424 for (i
= 0; i
< nfiles
; i
++)
425 if (strcmp (gt_files
[i
], line
) == 0)
427 /* Throw away the string we just read, and add the
428 current language to the existing string's bitmap. */
429 lang_bitmap bmap
= get_lang_bitmap (gt_files
[i
]);
431 error_at_line (&epos
, "file %s specified more than once "
432 "for language %s", line
, langno
== 0
434 : lang_dir_names
[langno
- 1]);
437 set_lang_bitmap ((char *)gt_files
[i
], bmap
);
442 set_lang_bitmap (line
, curlangs
);
443 gt_files
[nfiles
++] = line
;
446 /* Update the global counts now that we know accurately how many
447 things there are. (We do not bother resizing the arrays down.) */
448 num_lang_dirs
= langno
;
449 num_gt_files
= nfiles
;
452 /* Sanity check: any file that resides in a language subdirectory
453 (e.g. 'cp') ought to belong to the corresponding language.
454 ??? Still true if for instance ObjC++ is enabled and C++ isn't?
455 (Can you even do that? Should you be allowed to?) */
458 for (f
= 0; f
< num_gt_files
; f
++)
460 lang_bitmap bitmap
= get_lang_bitmap (gt_files
[f
]);
461 const char *basename
= get_file_basename (gt_files
[f
]);
462 const char *slashpos
= strchr (basename
, '/');
467 for (l
= 0; l
< num_lang_dirs
; l
++)
468 if ((size_t)(slashpos
- basename
) == strlen (lang_dir_names
[l
])
469 && memcmp (basename
, lang_dir_names
[l
],
470 strlen (lang_dir_names
[l
])) == 0)
472 if (!(bitmap
& (1 << l
)))
473 error ("%s is in language directory '%s' but is not "
474 "tagged for that language",
475 basename
, lang_dir_names
[l
]);
483 fatal ("error reading %s: %s", listname
, strerror (errno
));
490 /* The one and only TYPE_STRING. */
492 static struct type string_type
= {
493 TYPE_STRING
, 0, 0, GC_USED
, {0}
496 /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are
497 set to appropriate values at the beginning of main. */
499 static struct type scalar_nonchar
= {
500 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
502 static struct type scalar_char
= {
503 TYPE_SCALAR
, 0, 0, GC_USED
, {0}
506 /* Lists of various things. */
508 static pair_p typedefs
;
509 static type_p structures
;
510 static type_p param_structs
;
511 static pair_p variables
;
513 static type_p find_param_structure
514 (type_p t
, type_p param
[NUM_PARAM
]);
515 static type_p
adjust_field_tree_exp (type_p t
, options_p opt
);
516 static type_p
adjust_field_rtx_def (type_p t
, options_p opt
);
518 /* Define S as a typedef to T at POS. */
521 do_typedef (const char *s
, type_p t
, struct fileloc
*pos
)
525 /* temporary kludge - gengtype doesn't handle conditionals or macros.
526 Ignore any attempt to typedef CUMULATIVE_ARGS, location_t,
527 expanded_location, or source_locus, unless it is coming from
528 this file (main() sets them up with safe dummy definitions). */
529 if ((!strcmp (s
, "CUMULATIVE_ARGS")
530 || !strcmp (s
, "location_t")
531 || !strcmp (s
, "source_locus")
532 || !strcmp (s
, "source_location")
533 || !strcmp (s
, "expanded_location"))
534 && pos
->file
!= this_file
)
537 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
538 if (strcmp (p
->name
, s
) == 0)
542 error_at_line (pos
, "type `%s' previously defined", s
);
543 error_at_line (&p
->line
, "previously defined here");
548 p
= XNEW (struct pair
);
556 /* Define S as a typename of a scalar. Cannot be used to define
557 typedefs of 'char'. Note: is also used for pointer-to-function
558 typedefs (which are therefore not treated as pointers). */
561 do_scalar_typedef (const char *s
, struct fileloc
*pos
)
563 do_typedef (s
, &scalar_nonchar
, pos
);
566 /* Return the type previously defined for S. Use POS to report errors. */
569 resolve_typedef (const char *s
, struct fileloc
*pos
)
572 for (p
= typedefs
; p
!= NULL
; p
= p
->next
)
573 if (strcmp (p
->name
, s
) == 0)
575 error_at_line (pos
, "unidentified type `%s'", s
);
576 return &scalar_nonchar
; /* treat as "int" */
579 /* Create and return a new structure with tag NAME (or a union iff
580 ISUNION is nonzero), at POS with fields FIELDS and options O. */
583 new_structure (const char *name
, int isunion
, struct fileloc
*pos
,
584 pair_p fields
, options_p o
)
588 lang_bitmap bitmap
= get_lang_bitmap (pos
->file
);
590 /* temporary kludge - gengtype doesn't handle conditionals or
591 macros. Ignore any attempt to define struct location_s, unless
592 it is coming from this file (main() sets it up safely). */
593 if (!strcmp (name
, "location_s") && !isunion
594 && pos
->file
!= this_file
)
595 return find_structure (name
, 0);
597 for (si
= structures
; si
!= NULL
; si
= si
->next
)
598 if (strcmp (name
, si
->u
.s
.tag
) == 0
599 && UNION_P (si
) == isunion
)
602 if (si
->kind
== TYPE_LANG_STRUCT
)
606 for (si
= ls
->u
.s
.lang_struct
; si
!= NULL
; si
= si
->next
)
607 if (si
->u
.s
.bitmap
== bitmap
)
610 else if (si
->u
.s
.line
.file
!= NULL
&& si
->u
.s
.bitmap
!= bitmap
)
613 si
= XCNEW (struct type
);
614 memcpy (si
, ls
, sizeof (struct type
));
615 ls
->kind
= TYPE_LANG_STRUCT
;
616 ls
->u
.s
.lang_struct
= si
;
617 ls
->u
.s
.fields
= NULL
;
619 si
->pointer_to
= NULL
;
620 si
->u
.s
.lang_struct
= ls
;
625 if (ls
!= NULL
&& s
== NULL
)
627 s
= XCNEW (struct type
);
628 s
->next
= ls
->u
.s
.lang_struct
;
629 ls
->u
.s
.lang_struct
= s
;
630 s
->u
.s
.lang_struct
= ls
;
637 s
= XCNEW (struct type
);
638 s
->next
= structures
;
642 if (s
->u
.s
.line
.file
!= NULL
643 || (s
->u
.s
.lang_struct
&& (s
->u
.s
.lang_struct
->u
.s
.bitmap
& bitmap
)))
645 error_at_line (pos
, "duplicate definition of '%s %s'",
646 isunion
? "union" : "struct", s
->u
.s
.tag
);
647 error_at_line (&s
->u
.s
.line
, "previous definition here");
650 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
653 s
->u
.s
.fields
= fields
;
655 s
->u
.s
.bitmap
= bitmap
;
656 if (s
->u
.s
.lang_struct
)
657 s
->u
.s
.lang_struct
->u
.s
.bitmap
|= bitmap
;
659 /* Reset location_s's location to input.h so that we know where to
660 write out its mark routine. */
661 if (!strcmp (name
, "location_s") && !isunion
662 && pos
->file
== this_file
)
665 for (n
= 0; n
< num_gt_files
; n
++)
666 if (!strcmp (gt_files
[n
] + strlen (gt_files
[n
]) - strlen ("input.h"),
669 s
->u
.s
.line
.file
= gt_files
[n
];
677 /* Return the previously-defined structure with tag NAME (or a union
678 iff ISUNION is nonzero), or a new empty structure or union if none
679 was defined previously. */
682 find_structure (const char *name
, int isunion
)
686 for (s
= structures
; s
!= NULL
; s
= s
->next
)
687 if (strcmp (name
, s
->u
.s
.tag
) == 0
688 && UNION_P (s
) == isunion
)
691 s
= XCNEW (struct type
);
692 s
->next
= structures
;
694 s
->kind
= isunion
? TYPE_UNION
: TYPE_STRUCT
;
700 /* Return the previously-defined parameterized structure for structure
701 T and parameters PARAM, or a new parameterized empty structure or
702 union if none was defined previously. */
705 find_param_structure (type_p t
, type_p param
[NUM_PARAM
])
709 for (res
= param_structs
; res
; res
= res
->next
)
710 if (res
->u
.param_struct
.stru
== t
711 && memcmp (res
->u
.param_struct
.param
, param
,
712 sizeof (type_p
) * NUM_PARAM
) == 0)
716 res
= XCNEW (struct type
);
717 res
->kind
= TYPE_PARAM_STRUCT
;
718 res
->next
= param_structs
;
720 res
->u
.param_struct
.stru
= t
;
721 memcpy (res
->u
.param_struct
.param
, param
, sizeof (type_p
) * NUM_PARAM
);
726 /* Return a scalar type with name NAME. */
729 create_scalar_type (const char *name
)
731 if (!strcmp (name
, "char") || !strcmp (name
, "unsigned char"))
734 return &scalar_nonchar
;
737 /* Return a pointer to T. */
740 create_pointer (type_p t
)
744 type_p r
= XCNEW (struct type
);
745 r
->kind
= TYPE_POINTER
;
749 return t
->pointer_to
;
752 /* Return an array of length LEN. */
755 create_array (type_p t
, const char *len
)
759 v
= XCNEW (struct type
);
760 v
->kind
= TYPE_ARRAY
;
766 /* Return an options structure with name NAME and info INFO. NEXT is the
767 next option in the chain. */
770 create_option (options_p next
, const char *name
, const void *info
)
772 options_p o
= XNEW (struct options
);
775 o
->info
= (const char*) info
;
779 /* Return an options structure for a "nested_ptr" option. */
781 create_nested_ptr_option (options_p next
, type_p t
,
782 const char *to
, const char *from
)
784 struct nested_ptr_data
*d
= XNEW (struct nested_ptr_data
);
786 d
->type
= adjust_field_type (t
, 0);
788 d
->convert_from
= from
;
789 return create_option (next
, "nested_ptr", d
);
792 /* Add a variable named S of type T with options O defined at POS,
796 note_variable (const char *s
, type_p t
, options_p o
, struct fileloc
*pos
)
799 n
= XNEW (struct pair
);
808 /* Most-general structure field creator. */
810 create_field_all (pair_p next
, type_p type
, const char *name
, options_p opt
,
811 const char *file
, int line
)
815 field
= XNEW (struct pair
);
820 field
->line
.file
= file
;
821 field
->line
.line
= line
;
825 /* Create a field that came from the source code we are scanning,
826 i.e. we have a 'struct fileloc', and possibly options; also,
827 adjust_field_type should be called. */
829 create_field_at (pair_p next
, type_p type
, const char *name
, options_p opt
,
832 return create_field_all (next
, adjust_field_type (type
, opt
),
833 name
, opt
, pos
->file
, pos
->line
);
836 /* Create a fake field with the given type and name. NEXT is the next
837 field in the chain. */
838 #define create_field(next,type,name) \
839 create_field_all(next,type,name, 0, this_file, __LINE__)
841 /* Like create_field, but the field is only valid when condition COND
845 create_optional_field_ (pair_p next
, type_p type
, const char *name
,
846 const char *cond
, int line
)
852 /* Create a fake union type with a single nameless field of type TYPE.
853 The field has a tag of "1". This allows us to make the presence
854 of a field of type TYPE depend on some boolean "desc" being true. */
855 union_fields
= create_field (NULL
, type
, "");
856 union_fields
->opt
= create_option (union_fields
->opt
, "dot", "");
857 union_fields
->opt
= create_option (union_fields
->opt
, "tag", "1");
858 union_type
= new_structure (xasprintf ("%s_%d", "fake_union", id
++), 1,
859 &lexer_line
, union_fields
, NULL
);
861 /* Create the field and give it the new fake union type. Add a "desc"
862 tag that specifies the condition under which the field is valid. */
863 return create_field_all (next
, union_type
, name
,
864 create_option (0, "desc", cond
),
867 #define create_optional_field(next,type,name,cond) \
868 create_optional_field_(next,type,name,cond,__LINE__)
870 /* Reverse a linked list of 'struct pair's in place. */
872 nreverse_pairs (pair_p list
)
874 pair_p prev
= 0, p
, next
;
875 for (p
= list
; p
; p
= next
)
885 /* We don't care how long a CONST_DOUBLE is. */
886 #define CONST_DOUBLE_FORMAT "ww"
887 /* We don't want to see codes that are only for generator files. */
888 #undef GENERATOR_FILE
891 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
897 static const char * const rtx_name
[NUM_RTX_CODE
] = {
898 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
903 static const char * const rtx_format
[NUM_RTX_CODE
] = {
904 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
909 static int rtx_next_new
[NUM_RTX_CODE
];
911 /* We also need codes and names for insn notes (not register notes).
912 Note that we do *not* bias the note values here. */
914 #define DEF_INSN_NOTE(NAME) NAME,
915 #include "insn-notes.def"
921 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
922 default field for line number notes. */
923 static const char *const note_insn_name
[NOTE_INSN_MAX
+1] = {
924 #define DEF_INSN_NOTE(NAME) #NAME,
925 #include "insn-notes.def"
929 #undef CONST_DOUBLE_FORMAT
930 #define GENERATOR_FILE
932 /* Generate the contents of the rtx_next array. This really doesn't belong
933 in gengtype at all, but it's needed for adjust_field_rtx_def. */
939 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
943 rtx_next_new
[i
] = -1;
944 if (strncmp (rtx_format
[i
], "iuu", 3) == 0)
946 else if (i
== COND_EXEC
|| i
== SET
|| i
== EXPR_LIST
|| i
== INSN_LIST
)
949 for (k
= strlen (rtx_format
[i
]) - 1; k
>= 0; k
--)
950 if (rtx_format
[i
][k
] == 'e' || rtx_format
[i
][k
] == 'u')
955 /* Write out the contents of the rtx_next array. */
957 write_rtx_next (void)
959 outf_p f
= get_output_file_with_visibility (NULL
);
962 oprintf (f
, "\n/* Used to implement the RTX_NEXT macro. */\n");
963 oprintf (f
, "const unsigned char rtx_next[NUM_RTX_CODE] = {\n");
964 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
965 if (rtx_next_new
[i
] == -1)
966 oprintf (f
, " 0,\n");
969 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n",
974 /* Handle `special("rtx_def")'. This is a special case for field
975 `fld' of struct rtx_def, which is an array of unions whose values
976 are based in a complex way on the type of RTL. */
979 adjust_field_rtx_def (type_p t
, options_p
ARG_UNUSED (opt
))
984 type_p rtx_tp
, rtvec_tp
, tree_tp
, mem_attrs_tp
, note_union_tp
, scalar_tp
;
985 type_p bitmap_tp
, basic_block_tp
, reg_attrs_tp
, constant_tp
, symbol_union_tp
;
987 if (t
->kind
!= TYPE_UNION
)
989 error_at_line (&lexer_line
,
990 "special `rtx_def' must be applied to a union");
994 nodot
= create_option (NULL
, "dot", "");
996 rtx_tp
= create_pointer (find_structure ("rtx_def", 0));
997 rtvec_tp
= create_pointer (find_structure ("rtvec_def", 0));
998 tree_tp
= create_pointer (find_structure ("tree_node", 1));
999 mem_attrs_tp
= create_pointer (find_structure ("mem_attrs", 0));
1000 reg_attrs_tp
= create_pointer (find_structure ("reg_attrs", 0));
1001 bitmap_tp
= create_pointer (find_structure ("bitmap_element_def", 0));
1002 basic_block_tp
= create_pointer (find_structure ("basic_block_def", 0));
1003 constant_tp
= create_pointer (find_structure ("constant_descriptor_rtx", 0));
1004 scalar_tp
= &scalar_nonchar
; /* rtunion int */
1007 pair_p note_flds
= NULL
;
1010 for (c
= 0; c
<= NOTE_INSN_MAX
; c
++)
1015 note_flds
= create_field (note_flds
, &string_type
, "rt_str");
1018 case NOTE_INSN_BLOCK_BEG
:
1019 case NOTE_INSN_BLOCK_END
:
1020 note_flds
= create_field (note_flds
, tree_tp
, "rt_tree");
1023 case NOTE_INSN_VAR_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
)
1034 note_flds
->opt
= create_option (nodot
, "default", "");
1036 note_flds
->opt
= create_option (nodot
, "tag", note_insn_name
[c
]);
1038 note_union_tp
= new_structure ("rtx_def_note_subunion", 1,
1039 &lexer_line
, note_flds
, NULL
);
1041 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
1045 sym_flds
= create_field (NULL
, tree_tp
, "rt_tree");
1046 sym_flds
->opt
= create_option (nodot
, "default", "");
1048 sym_flds
= create_field (sym_flds
, constant_tp
, "rt_constant");
1049 sym_flds
->opt
= create_option (nodot
, "tag", "1");
1051 symbol_union_tp
= new_structure ("rtx_def_symbol_subunion", 1,
1052 &lexer_line
, sym_flds
, NULL
);
1054 for (i
= 0; i
< NUM_RTX_CODE
; i
++)
1056 pair_p subfields
= NULL
;
1057 size_t aindex
, nmindex
;
1062 for (aindex
= 0; aindex
< strlen (rtx_format
[i
]); aindex
++)
1065 const char *subname
;
1067 switch (rtx_format
[i
][aindex
])
1078 if (i
== MEM
&& aindex
== 1)
1079 t
= mem_attrs_tp
, subname
= "rt_mem";
1080 else if (i
== JUMP_INSN
&& aindex
== 8)
1081 t
= rtx_tp
, subname
= "rt_rtx";
1082 else if (i
== CODE_LABEL
&& aindex
== 4)
1083 t
= scalar_tp
, subname
= "rt_int";
1084 else if (i
== CODE_LABEL
&& aindex
== 5)
1085 t
= rtx_tp
, subname
= "rt_rtx";
1086 else if (i
== LABEL_REF
1087 && (aindex
== 1 || aindex
== 2))
1088 t
= rtx_tp
, subname
= "rt_rtx";
1089 else if (i
== NOTE
&& aindex
== 4)
1090 t
= note_union_tp
, subname
= "";
1091 else if (i
== NOTE
&& aindex
== 5)
1092 t
= scalar_tp
, subname
= "rt_int";
1093 else if (i
== NOTE
&& aindex
>= 7)
1094 t
= scalar_tp
, subname
= "rt_int";
1095 else if (i
== ADDR_DIFF_VEC
&& aindex
== 4)
1096 t
= scalar_tp
, subname
= "rt_int";
1097 else if (i
== VALUE
&& aindex
== 0)
1098 t
= scalar_tp
, subname
= "rt_int";
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";
1113 error_at_line (&lexer_line
,
1114 "rtx type `%s' has `0' in position %lu, can't handle",
1115 rtx_name
[i
], (unsigned long) aindex
);
1137 subname
= "rt_rtvec";
1142 subname
= "rt_tree";
1156 error_at_line (&lexer_line
,
1157 "rtx type `%s' has `%c' in position %lu, can't handle",
1158 rtx_name
[i
], rtx_format
[i
][aindex
],
1159 (unsigned long)aindex
);
1165 subfields
= create_field (subfields
, t
,
1166 xasprintf (".fld[%lu].%s",
1167 (unsigned long) aindex
,
1169 subfields
->opt
= nodot
;
1170 if (t
== note_union_tp
)
1171 subfields
->opt
= create_option (subfields
->opt
, "desc",
1173 if (t
== symbol_union_tp
)
1174 subfields
->opt
= create_option (subfields
->opt
, "desc",
1175 "CONSTANT_POOL_ADDRESS_P (&%0)");
1178 if (i
== SYMBOL_REF
)
1180 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds. */
1181 type_p field_tp
= find_structure ("block_symbol", 0);
1183 = create_optional_field (subfields
, field_tp
, "block_sym",
1184 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1187 sname
= xasprintf ("rtx_def_%s", rtx_name
[i
]);
1188 substruct
= new_structure (sname
, 0, &lexer_line
, subfields
, NULL
);
1190 ftag
= xstrdup (rtx_name
[i
]);
1191 for (nmindex
= 0; nmindex
< strlen (ftag
); nmindex
++)
1192 ftag
[nmindex
] = TOUPPER (ftag
[nmindex
]);
1194 flds
= create_field (flds
, substruct
, "");
1195 flds
->opt
= create_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_option (NULL
, "dot", "");
1222 flds
= create_field (NULL
, t
, "");
1223 flds
->opt
= create_option (nodot
, "length",
1224 "TREE_OPERAND_LENGTH ((tree) &%0)");
1225 flds
->opt
= create_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))
1260 int num
= ISDIGIT (opt
->name
[5]) ? opt
->name
[5] - '0' : 0;
1262 if (! UNION_OR_STRUCT_P (t
)
1263 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
1265 error_at_line (&lexer_line
,
1266 "option `%s' may only be applied to structures or structure pointers",
1272 if (params
[num
] != NULL
)
1273 error_at_line (&lexer_line
, "duplicate `%s' option", opt
->name
);
1274 if (! ISDIGIT (opt
->name
[5]))
1275 params
[num
] = create_pointer ((type_p
) opt
->info
);
1277 params
[num
] = (type_p
) opt
->info
;
1279 else if (strcmp (opt
->name
, "special") == 0)
1281 const char *special_name
= opt
->info
;
1282 if (strcmp (special_name
, "tree_exp") == 0)
1283 t
= adjust_field_tree_exp (t
, opt
);
1284 else if (strcmp (special_name
, "rtx_def") == 0)
1285 t
= adjust_field_rtx_def (t
, opt
);
1287 error_at_line (&lexer_line
, "unknown special `%s'", special_name
);
1296 realt
= find_param_structure (t
, params
);
1297 t
= pointer_p
? create_pointer (realt
) : realt
;
1302 && t
->u
.p
->kind
== TYPE_SCALAR
1303 && 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
, type_p
*nested_ptr
)
1324 for (o
= opt
; o
; o
= o
->next
)
1325 if (strcmp (o
->name
, "ptr_alias") == 0 && level
== GC_POINTED_TO
)
1326 set_gc_used_type ((type_p
) o
->info
, GC_POINTED_TO
, NULL
);
1327 else if (strcmp (o
->name
, "maybe_undef") == 0)
1329 else if (strcmp (o
->name
, "use_params") == 0)
1331 else if (strcmp (o
->name
, "length") == 0)
1333 else if (strcmp (o
->name
, "skip") == 0)
1335 else if (strcmp (o
->name
, "nested_ptr") == 0)
1336 *nested_ptr
= ((const struct nested_ptr_data
*) o
->info
)->type
;
1339 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
1342 set_gc_used_type (type_p t
, enum gc_used_enum level
, type_p param
[NUM_PARAM
])
1344 if (t
->gc_used
>= level
)
1358 process_gc_options (t
->u
.s
.opt
, level
, &dummy
, &dummy
, &dummy
, &dummy
,
1361 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
1363 int maybe_undef
= 0;
1367 type_p nested_ptr
= NULL
;
1368 process_gc_options (f
->opt
, level
, &maybe_undef
, &pass_param
,
1369 &length
, &skip
, &nested_ptr
);
1371 if (nested_ptr
&& f
->type
->kind
== TYPE_POINTER
)
1372 set_gc_used_type (nested_ptr
, GC_POINTED_TO
,
1373 pass_param
? param
: NULL
);
1374 else if (length
&& f
->type
->kind
== TYPE_POINTER
)
1375 set_gc_used_type (f
->type
->u
.p
, GC_USED
, NULL
);
1376 else if (maybe_undef
&& f
->type
->kind
== TYPE_POINTER
)
1377 set_gc_used_type (f
->type
->u
.p
, GC_MAYBE_POINTED_TO
, NULL
);
1378 else if (pass_param
&& f
->type
->kind
== TYPE_POINTER
&& param
)
1379 set_gc_used_type (find_param_structure (f
->type
->u
.p
, param
),
1380 GC_POINTED_TO
, NULL
);
1382 ; /* target type is not used through this field */
1384 set_gc_used_type (f
->type
, GC_USED
, pass_param
? param
: NULL
);
1390 set_gc_used_type (t
->u
.p
, GC_POINTED_TO
, NULL
);
1394 set_gc_used_type (t
->u
.a
.p
, GC_USED
, param
);
1397 case TYPE_LANG_STRUCT
:
1398 for (t
= t
->u
.s
.lang_struct
; t
; t
= t
->next
)
1399 set_gc_used_type (t
, level
, param
);
1402 case TYPE_PARAM_STRUCT
:
1405 for (i
= 0; i
< NUM_PARAM
; i
++)
1406 if (t
->u
.param_struct
.param
[i
] != 0)
1407 set_gc_used_type (t
->u
.param_struct
.param
[i
], GC_USED
, NULL
);
1409 if (t
->u
.param_struct
.stru
->gc_used
== GC_POINTED_TO
)
1410 level
= GC_POINTED_TO
;
1413 t
->u
.param_struct
.stru
->gc_used
= GC_UNUSED
;
1414 set_gc_used_type (t
->u
.param_struct
.stru
, level
,
1415 t
->u
.param_struct
.param
);
1423 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
1426 set_gc_used (pair_p variables
)
1429 for (p
= variables
; p
; p
= p
->next
)
1430 set_gc_used_type (p
->type
, GC_USED
, NULL
);
1433 /* File mapping routines. For each input file, there is one output .c file
1434 (but some output files have many input files), and there is one .h file
1435 for the whole build. */
1437 /* Output file handling. */
1439 /* Create and return an outf_p for a new file for NAME, to be called
1443 create_file (const char *name
, const char *oname
)
1445 static const char *const hdr
[] = {
1446 " Copyright (C) 2004 Free Software Foundation, Inc.\n",
1448 "This file is part of GCC.\n",
1450 "GCC is free software; you can redistribute it and/or modify it under\n",
1451 "the terms of the GNU General Public License as published by the Free\n",
1452 "Software Foundation; either version 2, or (at your option) any later\n",
1455 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1456 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1457 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1458 "for more details.\n",
1460 "You should have received a copy of the GNU General Public License\n",
1461 "along with GCC; see the file COPYING. If not, write to the Free\n",
1462 "Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA\n",
1463 "02110-1301, USA. */\n",
1465 "/* This file is machine generated. Do not edit. */\n"
1470 f
= XCNEW (struct outf
);
1471 f
->next
= output_files
;
1475 oprintf (f
, "/* Type information for %s.\n", name
);
1476 for (i
= 0; i
< ARRAY_SIZE (hdr
); i
++)
1477 oprintf (f
, "%s", hdr
[i
]);
1481 /* Print, like fprintf, to O.
1482 N.B. You might think this could be implemented more efficiently
1483 with vsnprintf(). Unfortunately, there are C libraries that
1484 provide that function but without the C99 semantics for its return
1485 value, making it impossible to know how much space is required. */
1487 oprintf (outf_p o
, const char *format
, ...)
1493 va_start (ap
, format
);
1494 slength
= vasprintf (&s
, format
, ap
);
1495 if (s
== NULL
|| (int)slength
< 0)
1496 fatal ("out of memory");
1499 if (o
->bufused
+ slength
> o
->buflength
)
1501 size_t new_len
= o
->buflength
;
1506 } while (o
->bufused
+ slength
>= new_len
);
1507 o
->buf
= XRESIZEVEC (char, o
->buf
, new_len
);
1508 o
->buflength
= new_len
;
1510 memcpy (o
->buf
+ o
->bufused
, s
, slength
);
1511 o
->bufused
+= slength
;
1515 /* Open the global header file and the language-specific header files. */
1518 open_base_files (void)
1522 header_file
= create_file ("GCC", "gtype-desc.h");
1524 base_files
= XNEWVEC (outf_p
, num_lang_dirs
);
1526 for (i
= 0; i
< num_lang_dirs
; i
++)
1527 base_files
[i
] = create_file (lang_dir_names
[i
],
1528 xasprintf ("gtype-%s.h", lang_dir_names
[i
]));
1530 /* gtype-desc.c is a little special, so we create it here. */
1532 /* The order of files here matters very much. */
1533 static const char *const ifiles
[] = {
1534 "config.h", "system.h", "coretypes.h", "tm.h", "varray.h",
1535 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1536 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1537 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1538 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1539 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1540 "cfglayout.h", "except.h", "output.h", "cfgloop.h", NULL
1542 const char *const *ifp
;
1543 outf_p gtype_desc_c
;
1545 gtype_desc_c
= create_file ("GCC", "gtype-desc.c");
1546 for (ifp
= ifiles
; *ifp
; ifp
++)
1547 oprintf (gtype_desc_c
, "#include \"%s\"\n", *ifp
);
1551 /* Determine the pathname to F relative to $(srcdir). */
1554 get_file_basename (const char *f
)
1556 const char *basename
;
1559 basename
= strrchr (f
, '/');
1566 for (i
= 0; i
< num_lang_dirs
; i
++)
1572 s1
= basename
- strlen (lang_dir_names
[i
]) - 1;
1573 s2
= lang_dir_names
[i
];
1576 if (l1
>= l2
&& IS_DIR_SEPARATOR (s1
[-1]) && !memcmp (s1
, s2
, l2
))
1579 if ((basename
- f
- 1) != srcdir_len
)
1580 fatal ("filename `%s' should be preceded by $srcdir", f
);
1588 /* An output file, suitable for definitions, that can see declarations
1589 made in INPUT_FILE and is linked into every language that uses
1593 get_output_file_with_visibility (const char *input_file
)
1597 const char *basename
;
1598 const char *for_name
;
1599 const char *output_name
;
1601 /* This can happen when we need a file with visibility on a
1602 structure that we've never seen. We have to just hope that it's
1603 globally visible. */
1604 if (input_file
== NULL
)
1605 input_file
= "system.h";
1607 /* Determine the output file name. */
1608 basename
= get_file_basename (input_file
);
1610 len
= strlen (basename
);
1611 if ((len
> 2 && memcmp (basename
+len
-2, ".c", 2) == 0)
1612 || (len
> 2 && memcmp (basename
+len
-2, ".y", 2) == 0)
1613 || (len
> 3 && memcmp (basename
+len
-3, ".in", 3) == 0))
1617 output_name
= s
= xasprintf ("gt-%s", basename
);
1618 for (; *s
!= '.'; s
++)
1619 if (! ISALNUM (*s
) && *s
!= '-')
1621 memcpy (s
, ".h", sizeof (".h"));
1622 for_name
= basename
;
1624 /* Some headers get used by more than one front-end; hence, it
1625 would be inappropriate to spew them out to a single gtype-<lang>.h
1626 (and gengtype doesn't know how to direct spewage into multiple
1627 gtype-<lang>.h headers at this time). Instead, we pair up these
1628 headers with source files (and their special purpose gt-*.h headers). */
1629 else if (strcmp (basename
, "c-common.h") == 0)
1630 output_name
= "gt-c-common.h", for_name
= "c-common.c";
1631 else if (strcmp (basename
, "c-tree.h") == 0)
1632 output_name
= "gt-c-decl.h", for_name
= "c-decl.c";
1633 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1634 && strcmp (basename
+ 3, "cp-tree.h") == 0)
1635 output_name
= "gt-cp-tree.h", for_name
= "cp/tree.c";
1636 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1637 && strcmp (basename
+ 3, "decl.h") == 0)
1638 output_name
= "gt-cp-decl.h", for_name
= "cp/decl.c";
1639 else if (strncmp (basename
, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename
[2])
1640 && strcmp (basename
+ 3, "name-lookup.h") == 0)
1641 output_name
= "gt-cp-name-lookup.h", for_name
= "cp/name-lookup.c";
1642 else if (strncmp (basename
, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename
[4])
1643 && strcmp (basename
+ 5, "objc-act.h") == 0)
1644 output_name
= "gt-objc-objc-act.h", for_name
= "objc/objc-act.c";
1649 for (i
= 0; i
< num_lang_dirs
; i
++)
1650 if (memcmp (basename
, lang_dir_names
[i
], strlen (lang_dir_names
[i
])) == 0
1651 && basename
[strlen(lang_dir_names
[i
])] == '/')
1652 return base_files
[i
];
1654 output_name
= "gtype-desc.c";
1658 /* Look through to see if we've ever seen this output filename before. */
1659 for (r
= output_files
; r
; r
= r
->next
)
1660 if (strcmp (r
->name
, output_name
) == 0)
1663 /* If not, create it. */
1664 r
= create_file (for_name
, output_name
);
1669 /* The name of an output file, suitable for definitions, that can see
1670 declarations made in INPUT_FILE and is linked into every language
1671 that uses INPUT_FILE. */
1674 get_output_file_name (const char *input_file
)
1676 return get_output_file_with_visibility (input_file
)->name
;
1679 /* Copy the output to its final destination,
1680 but don't unnecessarily change modification times. */
1683 close_output_files (void)
1687 for (of
= output_files
; of
; of
= of
->next
)
1691 newfile
= fopen (of
->name
, "r");
1692 if (newfile
!= NULL
)
1697 for (i
= 0; i
< of
->bufused
; i
++)
1700 ch
= fgetc (newfile
);
1701 if (ch
== EOF
|| ch
!= (unsigned char) of
->buf
[i
])
1704 no_write_p
= i
== of
->bufused
&& fgetc (newfile
) == EOF
;
1711 newfile
= fopen (of
->name
, "w");
1712 if (newfile
== NULL
)
1713 fatal ("opening output file %s: %s", of
->name
, strerror (errno
));
1714 if (fwrite (of
->buf
, 1, of
->bufused
, newfile
) != of
->bufused
)
1715 fatal ("writing output file %s: %s", of
->name
, strerror (errno
));
1716 if (fclose (newfile
) != 0)
1717 fatal ("closing output file %s: %s", of
->name
, strerror (errno
));
1728 struct walk_type_data
;
1730 /* For scalars and strings, given the item in 'val'.
1731 For structures, given a pointer to the item in 'val'.
1732 For misc. pointers, given the item in 'val'.
1734 typedef void (*process_field_fn
)
1735 (type_p f
, const struct walk_type_data
*p
);
1736 typedef void (*func_name_fn
)
1737 (type_p s
, const struct walk_type_data
*p
);
1739 /* Parameters for write_types. */
1741 struct write_types_data
1744 const char *param_prefix
;
1745 const char *subfield_marker_routine
;
1746 const char *marker_routine
;
1747 const char *reorder_note_routine
;
1748 const char *comment
;
1749 int skip_hooks
; /* skip hook generation if non zero */
1752 static void output_escaped_param (struct walk_type_data
*d
,
1753 const char *, const char *);
1754 static void output_mangled_typename (outf_p
, type_p
);
1755 static void walk_type (type_p t
, struct walk_type_data
*d
);
1756 static void write_func_for_structure
1757 (type_p orig_s
, type_p s
, type_p
* param
,
1758 const struct write_types_data
*wtd
);
1759 static void write_types_process_field
1760 (type_p f
, const struct walk_type_data
*d
);
1761 static void write_types (type_p structures
,
1762 type_p param_structs
,
1763 const struct write_types_data
*wtd
);
1764 static void write_types_local_process_field
1765 (type_p f
, const struct walk_type_data
*d
);
1766 static void write_local_func_for_structure
1767 (type_p orig_s
, type_p s
, type_p
* param
);
1768 static void write_local (type_p structures
,
1769 type_p param_structs
);
1770 static void write_enum_defn (type_p structures
, type_p param_structs
);
1771 static int contains_scalar_p (type_p t
);
1772 static void put_mangled_filename (outf_p
, const char *);
1773 static void finish_root_table (struct flist
*flp
, const char *pfx
,
1774 const char *tname
, const char *lastname
,
1776 static void write_root (outf_p
, pair_p
, type_p
, const char *, int,
1777 struct fileloc
*, const char *);
1778 static void write_array (outf_p f
, pair_p v
,
1779 const struct write_types_data
*wtd
);
1780 static void write_roots (pair_p
);
1782 /* Parameters for walk_type. */
1784 struct walk_type_data
1786 process_field_fn process_field
;
1791 const char *prev_val
[4];
1794 struct fileloc
*line
;
1799 const char *reorder_fn
;
1801 bool fn_wants_lvalue
;
1804 /* Print a mangled name representing T to OF. */
1807 output_mangled_typename (outf_p of
, type_p t
)
1811 else switch (t
->kind
)
1815 output_mangled_typename (of
, t
->u
.p
);
1825 case TYPE_LANG_STRUCT
:
1826 oprintf (of
, "%lu%s", (unsigned long) strlen (t
->u
.s
.tag
), t
->u
.s
.tag
);
1828 case TYPE_PARAM_STRUCT
:
1831 for (i
= 0; i
< NUM_PARAM
; i
++)
1832 if (t
->u
.param_struct
.param
[i
] != NULL
)
1833 output_mangled_typename (of
, t
->u
.param_struct
.param
[i
]);
1834 output_mangled_typename (of
, t
->u
.param_struct
.stru
);
1842 /* Print PARAM to D->OF processing escapes. D->VAL references the
1843 current object, D->PREV_VAL the object containing the current
1844 object, ONAME is the name of the option and D->LINE is used to
1845 print error messages. */
1848 output_escaped_param (struct walk_type_data
*d
, const char *param
,
1853 for (p
= param
; *p
; p
++)
1855 oprintf (d
->of
, "%c", *p
);
1859 oprintf (d
->of
, "(%s)", d
->prev_val
[2]);
1862 oprintf (d
->of
, "(%s)", d
->prev_val
[0]);
1865 oprintf (d
->of
, "(%s)", d
->prev_val
[1]);
1869 const char *pp
= d
->val
+ strlen (d
->val
);
1870 while (pp
[-1] == ']')
1873 oprintf (d
->of
, "%s", pp
);
1877 error_at_line (d
->line
, "`%s' option contains bad escape %c%c",
1882 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
1883 which is of type T. Write code to D->OF to constrain execution (at
1884 the point that D->PROCESS_FIELD is called) to the appropriate
1885 cases. Call D->PROCESS_FIELD on subobjects before calling it on
1886 pointers to those objects. D->PREV_VAL lists the objects
1887 containing the current object, D->OPT is a list of options to
1888 apply, D->INDENT is the current indentation level, D->LINE is used
1889 to print error messages, D->BITMAP indicates which languages to
1890 print the structure for, and D->PARAM is the current parameter
1891 (from an enclosing param_is option). */
1894 walk_type (type_p t
, struct walk_type_data
*d
)
1896 const char *length
= NULL
;
1897 const char *desc
= NULL
;
1898 int maybe_undef_p
= 0;
1899 int use_param_num
= -1;
1900 int use_params_p
= 0;
1902 const struct nested_ptr_data
*nested_ptr_d
= NULL
;
1904 d
->needs_cast_p
= false;
1905 for (oo
= d
->opt
; oo
; oo
= oo
->next
)
1906 if (strcmp (oo
->name
, "length") == 0)
1908 else if (strcmp (oo
->name
, "maybe_undef") == 0)
1910 else if (strncmp (oo
->name
, "use_param", 9) == 0
1911 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
1912 use_param_num
= oo
->name
[9] == '\0' ? 0 : oo
->name
[9] - '0';
1913 else if (strcmp (oo
->name
, "use_params") == 0)
1915 else if (strcmp (oo
->name
, "desc") == 0)
1917 else if (strcmp (oo
->name
, "mark_hook") == 0)
1919 else if (strcmp (oo
->name
, "nested_ptr") == 0)
1920 nested_ptr_d
= (const struct nested_ptr_data
*) oo
->info
;
1921 else if (strcmp (oo
->name
, "dot") == 0)
1923 else if (strcmp (oo
->name
, "tag") == 0)
1925 else if (strcmp (oo
->name
, "special") == 0)
1927 else if (strcmp (oo
->name
, "skip") == 0)
1929 else if (strcmp (oo
->name
, "default") == 0)
1931 else if (strcmp (oo
->name
, "descbits") == 0)
1933 else if (strcmp (oo
->name
, "param_is") == 0)
1935 else if (strncmp (oo
->name
, "param", 5) == 0
1936 && ISDIGIT (oo
->name
[5])
1937 && strcmp (oo
->name
+ 6, "_is") == 0)
1939 else if (strcmp (oo
->name
, "chain_next") == 0)
1941 else if (strcmp (oo
->name
, "chain_prev") == 0)
1943 else if (strcmp (oo
->name
, "reorder") == 0)
1946 error_at_line (d
->line
, "unknown option `%s'\n", oo
->name
);
1953 int pointer_p
= t
->kind
== TYPE_POINTER
;
1957 if (! UNION_OR_STRUCT_P (t
))
1958 error_at_line (d
->line
, "`use_params' option on unimplemented type");
1960 t
= find_param_structure (t
, d
->param
);
1962 t
= create_pointer (t
);
1965 if (use_param_num
!= -1)
1967 if (d
->param
!= NULL
&& d
->param
[use_param_num
] != NULL
)
1969 type_p nt
= d
->param
[use_param_num
];
1971 if (t
->kind
== TYPE_ARRAY
)
1972 nt
= create_array (nt
, t
->u
.a
.len
);
1973 else if (length
!= NULL
&& t
->kind
== TYPE_POINTER
)
1974 nt
= create_pointer (nt
);
1975 d
->needs_cast_p
= (t
->kind
!= TYPE_POINTER
1976 && (nt
->kind
== TYPE_POINTER
1977 || nt
->kind
== TYPE_STRING
));
1981 error_at_line (d
->line
, "no parameter defined for `%s'",
1986 && (t
->kind
!= TYPE_POINTER
|| ! UNION_OR_STRUCT_P (t
->u
.p
)))
1988 error_at_line (d
->line
,
1989 "field `%s' has invalid option `maybe_undef_p'\n",
1998 d
->process_field (t
, d
);
2004 && t
->u
.p
->u
.s
.line
.file
== NULL
)
2006 oprintf (d
->of
, "%*sgcc_assert (!%s);\n", d
->indent
, "", d
->val
);
2012 if (! UNION_OR_STRUCT_P (t
->u
.p
)
2013 && t
->u
.p
->kind
!= TYPE_PARAM_STRUCT
)
2015 error_at_line (d
->line
,
2016 "field `%s' is pointer to unimplemented type",
2023 const char *oldprevval2
= d
->prev_val
[2];
2025 if (! UNION_OR_STRUCT_P (nested_ptr_d
->type
))
2027 error_at_line (d
->line
,
2028 "field `%s' has invalid "
2029 "option `nested_ptr'\n",
2034 d
->prev_val
[2] = d
->val
;
2035 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2037 d
->val
= xasprintf ("x%d", d
->counter
++);
2038 oprintf (d
->of
, "%*s%s %s * %s%s =\n", d
->indent
, "",
2039 (nested_ptr_d
->type
->kind
== TYPE_UNION
2040 ? "union" : "struct"),
2041 nested_ptr_d
->type
->u
.s
.tag
,
2042 d
->fn_wants_lvalue
? "" : "const ",
2044 oprintf (d
->of
, "%*s", d
->indent
+ 2, "");
2045 output_escaped_param (d
, nested_ptr_d
->convert_from
,
2047 oprintf (d
->of
, ";\n");
2049 d
->process_field (nested_ptr_d
->type
, d
);
2051 if (d
->fn_wants_lvalue
)
2053 oprintf (d
->of
, "%*s%s = ", d
->indent
, "",
2055 d
->prev_val
[2] = d
->val
;
2056 output_escaped_param (d
, nested_ptr_d
->convert_to
,
2058 oprintf (d
->of
, ";\n");
2062 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2063 d
->val
= d
->prev_val
[2];
2064 d
->prev_val
[2] = oldprevval2
;
2067 d
->process_field (t
->u
.p
, d
);
2071 int loopcounter
= d
->counter
++;
2072 const char *oldval
= d
->val
;
2073 const char *oldprevval3
= d
->prev_val
[3];
2076 oprintf (d
->of
, "%*sif (%s != NULL) {\n", d
->indent
, "", d
->val
);
2078 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2079 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != (size_t)(", d
->indent
, "",
2080 loopcounter
, loopcounter
);
2081 output_escaped_param (d
, length
, "length");
2082 oprintf (d
->of
, "); i%d++) {\n", loopcounter
);
2084 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2086 d
->prev_val
[3] = oldval
;
2087 walk_type (t
->u
.p
, d
);
2090 d
->prev_val
[3] = oldprevval3
;
2093 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2094 d
->process_field(t
, d
);
2096 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2103 int loopcounter
= d
->counter
++;
2104 const char *oldval
= d
->val
;
2107 /* If it's an array of scalars, we optimize by not generating
2109 if (t
->u
.a
.p
->kind
== TYPE_SCALAR
)
2112 /* When walking an array, compute the length and store it in a
2113 local variable before walking the array elements, instead of
2114 recomputing the length expression each time through the loop.
2115 This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2116 where the length is stored in the first array element,
2117 because otherwise that operand can get overwritten on the
2119 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2121 oprintf (d
->of
, "%*ssize_t i%d;\n", d
->indent
, "", loopcounter
);
2122 oprintf (d
->of
, "%*ssize_t l%d = (size_t)(",
2123 d
->indent
, "", loopcounter
);
2125 output_escaped_param (d
, length
, "length");
2127 oprintf (d
->of
, "%s", t
->u
.a
.len
);
2128 oprintf (d
->of
, ");\n");
2130 oprintf (d
->of
, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2132 loopcounter
, loopcounter
, loopcounter
, loopcounter
);
2134 d
->val
= newval
= xasprintf ("%s[i%d]", oldval
, loopcounter
);
2136 walk_type (t
->u
.a
.p
, d
);
2141 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2143 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2151 const char *oldval
= d
->val
;
2152 const char *oldprevval1
= d
->prev_val
[1];
2153 const char *oldprevval2
= d
->prev_val
[2];
2154 const int union_p
= t
->kind
== TYPE_UNION
;
2155 int seen_default_p
= 0;
2158 if (! t
->u
.s
.line
.file
)
2159 error_at_line (d
->line
, "incomplete structure `%s'", t
->u
.s
.tag
);
2161 if ((d
->bitmap
& t
->u
.s
.bitmap
) != d
->bitmap
)
2163 error_at_line (d
->line
,
2164 "structure `%s' defined for mismatching languages",
2166 error_at_line (&t
->u
.s
.line
, "one structure defined here");
2169 /* Some things may also be defined in the structure's options. */
2170 for (o
= t
->u
.s
.opt
; o
; o
= o
->next
)
2171 if (! desc
&& strcmp (o
->name
, "desc") == 0)
2174 d
->prev_val
[2] = oldval
;
2175 d
->prev_val
[1] = oldprevval2
;
2180 error_at_line (d
->line
, "missing `desc' option for union `%s'",
2184 oprintf (d
->of
, "%*sswitch (", d
->indent
, "");
2185 output_escaped_param (d
, desc
, "desc");
2186 oprintf (d
->of
, ")\n");
2188 oprintf (d
->of
, "%*s{\n", d
->indent
, "");
2190 for (f
= t
->u
.s
.fields
; f
; f
= f
->next
)
2193 const char *dot
= ".";
2194 const char *tagid
= NULL
;
2197 int use_param_p
= 0;
2200 d
->reorder_fn
= NULL
;
2201 for (oo
= f
->opt
; oo
; oo
= oo
->next
)
2202 if (strcmp (oo
->name
, "dot") == 0)
2204 else if (strcmp (oo
->name
, "tag") == 0)
2206 else if (strcmp (oo
->name
, "skip") == 0)
2208 else if (strcmp (oo
->name
, "default") == 0)
2210 else if (strcmp (oo
->name
, "reorder") == 0)
2211 d
->reorder_fn
= oo
->info
;
2212 else if (strncmp (oo
->name
, "use_param", 9) == 0
2213 && (oo
->name
[9] == '\0' || ISDIGIT (oo
->name
[9])))
2219 if (union_p
&& tagid
)
2221 oprintf (d
->of
, "%*scase %s:\n", d
->indent
, "", tagid
);
2224 else if (union_p
&& default_p
)
2226 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2230 else if (! union_p
&& (default_p
|| tagid
))
2231 error_at_line (d
->line
,
2232 "can't use `%s' outside a union on field `%s'",
2233 default_p
? "default" : "tag", f
->name
);
2234 else if (union_p
&& ! (default_p
|| tagid
)
2235 && f
->type
->kind
== TYPE_SCALAR
)
2238 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2239 d
->line
->file
, d
->line
->line
, f
->name
);
2242 else if (union_p
&& ! (default_p
|| tagid
))
2243 error_at_line (d
->line
,
2244 "field `%s' is missing `tag' or `default' option",
2248 d
->val
= newval
= xasprintf ("%s%s%s", oldval
, dot
, f
->name
);
2250 d
->used_length
= false;
2252 if (union_p
&& use_param_p
&& d
->param
== NULL
)
2253 oprintf (d
->of
, "%*sgcc_unreachable ();\n", d
->indent
, "");
2255 walk_type (f
->type
, d
);
2261 oprintf (d
->of
, "%*sbreak;\n", d
->indent
, "");
2265 d
->reorder_fn
= NULL
;
2268 d
->prev_val
[1] = oldprevval1
;
2269 d
->prev_val
[2] = oldprevval2
;
2271 if (union_p
&& ! seen_default_p
)
2273 oprintf (d
->of
, "%*sdefault:\n", d
->indent
, "");
2274 oprintf (d
->of
, "%*s break;\n", d
->indent
, "");
2278 oprintf (d
->of
, "%*s}\n", d
->indent
, "");
2284 case TYPE_LANG_STRUCT
:
2287 for (nt
= t
->u
.s
.lang_struct
; nt
; nt
= nt
->next
)
2288 if ((d
->bitmap
& nt
->u
.s
.bitmap
) == d
->bitmap
)
2291 error_at_line (d
->line
, "structure `%s' differs between languages",
2298 case TYPE_PARAM_STRUCT
:
2300 type_p
*oldparam
= d
->param
;
2302 d
->param
= t
->u
.param_struct
.param
;
2303 walk_type (t
->u
.param_struct
.stru
, d
);
2304 d
->param
= oldparam
;
2313 /* process_field routine for marking routines. */
2316 write_types_process_field (type_p f
, const struct walk_type_data
*d
)
2318 const struct write_types_data
*wtd
;
2319 const char *cast
= d
->needs_cast_p
? "(void *)" : "";
2320 wtd
= (const struct write_types_data
*) d
->cookie
;
2325 oprintf (d
->of
, "%*s%s (%s%s", d
->indent
, "",
2326 wtd
->subfield_marker_routine
, cast
, d
->val
);
2327 if (wtd
->param_prefix
)
2329 oprintf (d
->of
, ", %s", d
->prev_val
[3]);
2332 oprintf (d
->of
, ", gt_%s_", wtd
->param_prefix
);
2333 output_mangled_typename (d
->of
, d
->orig_s
);
2336 oprintf (d
->of
, ", gt_%sa_%s", wtd
->param_prefix
, d
->prev_val
[0]);
2338 if (f
->u
.p
->kind
== TYPE_PARAM_STRUCT
2339 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2341 oprintf (d
->of
, ", gt_e_");
2342 output_mangled_typename (d
->of
, f
);
2344 else if (UNION_OR_STRUCT_P (f
)
2345 && f
->u
.p
->u
.s
.line
.file
!= NULL
)
2347 oprintf (d
->of
, ", gt_ggc_e_");
2348 output_mangled_typename (d
->of
, f
);
2351 oprintf (d
->of
, ", gt_types_enum_last");
2353 oprintf (d
->of
, ");\n");
2354 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2355 oprintf (d
->of
, "%*s%s (%s%s, %s, %s);\n", d
->indent
, "",
2356 wtd
->reorder_note_routine
, cast
, d
->val
,
2357 d
->prev_val
[3], d
->reorder_fn
);
2361 if (wtd
->param_prefix
== NULL
)
2366 case TYPE_LANG_STRUCT
:
2367 case TYPE_PARAM_STRUCT
:
2368 oprintf (d
->of
, "%*sgt_%s_", d
->indent
, "", wtd
->prefix
);
2369 output_mangled_typename (d
->of
, f
);
2370 oprintf (d
->of
, " (%s%s);\n", cast
, d
->val
);
2371 if (d
->reorder_fn
&& wtd
->reorder_note_routine
)
2372 oprintf (d
->of
, "%*s%s (%s%s, %s%s, %s);\n", d
->indent
, "",
2373 wtd
->reorder_note_routine
, cast
, d
->val
, cast
, d
->val
,
2385 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2388 output_type_enum (outf_p of
, type_p s
)
2390 if (s
->kind
== TYPE_PARAM_STRUCT
&& s
->u
.s
.line
.file
!= NULL
)
2392 oprintf (of
, ", gt_e_");
2393 output_mangled_typename (of
, s
);
2395 else if (UNION_OR_STRUCT_P (s
) && s
->u
.s
.line
.file
!= NULL
)
2397 oprintf (of
, ", gt_ggc_e_");
2398 output_mangled_typename (of
, s
);
2401 oprintf (of
, ", gt_types_enum_last");
2404 /* For S, a structure that's part of ORIG_S, and using parameters
2405 PARAM, write out a routine that:
2406 - Takes a parameter, a void * but actually of type *S
2407 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2408 field of S or its substructures and (in some cases) things
2409 that are pointed to by S.
2413 write_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
,
2414 const struct write_types_data
*wtd
)
2416 const char *fn
= s
->u
.s
.line
.file
;
2418 const char *chain_next
= NULL
;
2419 const char *chain_prev
= NULL
;
2420 const char *mark_hook_name
= NULL
;
2422 struct walk_type_data d
;
2424 /* This is a hack, and not the good kind either. */
2425 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2426 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2427 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2428 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2430 memset (&d
, 0, sizeof (d
));
2431 d
.of
= get_output_file_with_visibility (fn
);
2433 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2434 if (strcmp (opt
->name
, "chain_next") == 0)
2435 chain_next
= opt
->info
;
2436 else if (strcmp (opt
->name
, "chain_prev") == 0)
2437 chain_prev
= opt
->info
;
2438 else if (strcmp (opt
->name
, "mark_hook") == 0)
2439 mark_hook_name
= opt
->info
;
2441 if (chain_prev
!= NULL
&& chain_next
== NULL
)
2442 error_at_line (&s
->u
.s
.line
, "chain_prev without chain_next");
2444 d
.process_field
= write_types_process_field
;
2448 d
.line
= &s
->u
.s
.line
;
2449 d
.bitmap
= s
->u
.s
.bitmap
;
2451 d
.prev_val
[0] = "*x";
2452 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2453 d
.prev_val
[3] = "x";
2456 oprintf (d
.of
, "\n");
2457 oprintf (d
.of
, "void\n");
2459 oprintf (d
.of
, "gt_%sx_%s", wtd
->prefix
, orig_s
->u
.s
.tag
);
2462 oprintf (d
.of
, "gt_%s_", wtd
->prefix
);
2463 output_mangled_typename (d
.of
, orig_s
);
2465 oprintf (d
.of
, " (void *x_p)\n");
2466 oprintf (d
.of
, "{\n");
2467 oprintf (d
.of
, " %s %s * %sx = (%s %s *)x_p;\n",
2468 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2469 chain_next
== NULL
? "const " : "",
2470 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2471 if (chain_next
!= NULL
)
2472 oprintf (d
.of
, " %s %s * xlimit = x;\n",
2473 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2474 if (chain_next
== NULL
)
2476 oprintf (d
.of
, " if (%s (x", wtd
->marker_routine
);
2477 if (wtd
->param_prefix
)
2479 oprintf (d
.of
, ", x, gt_%s_", wtd
->param_prefix
);
2480 output_mangled_typename (d
.of
, orig_s
);
2481 output_type_enum (d
.of
, orig_s
);
2483 oprintf (d
.of
, "))\n");
2487 oprintf (d
.of
, " while (%s (xlimit", wtd
->marker_routine
);
2488 if (wtd
->param_prefix
)
2490 oprintf (d
.of
, ", xlimit, gt_%s_", wtd
->param_prefix
);
2491 output_mangled_typename (d
.of
, orig_s
);
2492 output_type_enum (d
.of
, orig_s
);
2494 oprintf (d
.of
, "))\n");
2495 if (mark_hook_name
&& !wtd
->skip_hooks
)
2497 oprintf (d
.of
, " {\n");
2498 oprintf (d
.of
, " %s (xlimit);\n ", mark_hook_name
);
2500 oprintf (d
.of
, " xlimit = (");
2501 d
.prev_val
[2] = "*xlimit";
2502 output_escaped_param (&d
, chain_next
, "chain_next");
2503 oprintf (d
.of
, ");\n");
2504 if (mark_hook_name
&& !wtd
->skip_hooks
)
2505 oprintf (d
.of
, " }\n");
2506 if (chain_prev
!= NULL
)
2508 oprintf (d
.of
, " if (x != xlimit)\n");
2509 oprintf (d
.of
, " for (;;)\n");
2510 oprintf (d
.of
, " {\n");
2511 oprintf (d
.of
, " %s %s * const xprev = (",
2512 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2514 d
.prev_val
[2] = "*x";
2515 output_escaped_param (&d
, chain_prev
, "chain_prev");
2516 oprintf (d
.of
, ");\n");
2517 oprintf (d
.of
, " if (xprev == NULL) break;\n");
2518 oprintf (d
.of
, " x = xprev;\n");
2519 oprintf (d
.of
, " (void) %s (xprev",
2520 wtd
->marker_routine
);
2521 if (wtd
->param_prefix
)
2523 oprintf (d
.of
, ", xprev, gt_%s_", wtd
->param_prefix
);
2524 output_mangled_typename (d
.of
, orig_s
);
2525 output_type_enum (d
.of
, orig_s
);
2527 oprintf (d
.of
, ");\n");
2528 oprintf (d
.of
, " }\n");
2530 oprintf (d
.of
, " while (x != xlimit)\n");
2532 oprintf (d
.of
, " {\n");
2533 if (mark_hook_name
&& chain_next
== NULL
&& !wtd
->skip_hooks
)
2535 oprintf (d
.of
, " %s (x);\n", mark_hook_name
);
2537 d
.prev_val
[2] = "*x";
2541 if (chain_next
!= NULL
)
2543 oprintf (d
.of
, " x = (");
2544 output_escaped_param (&d
, chain_next
, "chain_next");
2545 oprintf (d
.of
, ");\n");
2548 oprintf (d
.of
, " }\n");
2549 oprintf (d
.of
, "}\n");
2552 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
2555 write_types (type_p structures
, type_p param_structs
,
2556 const struct write_types_data
*wtd
)
2560 oprintf (header_file
, "\n/* %s*/\n", wtd
->comment
);
2561 for (s
= structures
; s
; s
= s
->next
)
2562 if (s
->gc_used
== GC_POINTED_TO
2563 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2567 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2568 && s
->u
.s
.line
.file
== NULL
)
2571 oprintf (header_file
, "#define gt_%s_", wtd
->prefix
);
2572 output_mangled_typename (header_file
, s
);
2573 oprintf (header_file
, "(X) do { \\\n");
2574 oprintf (header_file
,
2575 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd
->prefix
,
2577 oprintf (header_file
,
2580 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2581 if (strcmp (opt
->name
, "ptr_alias") == 0)
2583 type_p t
= (type_p
) opt
->info
;
2584 if (t
->kind
== TYPE_STRUCT
2585 || t
->kind
== TYPE_UNION
2586 || t
->kind
== TYPE_LANG_STRUCT
)
2587 oprintf (header_file
,
2588 "#define gt_%sx_%s gt_%sx_%s\n",
2589 wtd
->prefix
, s
->u
.s
.tag
, wtd
->prefix
, t
->u
.s
.tag
);
2591 error_at_line (&s
->u
.s
.line
,
2592 "structure alias is not a structure");
2598 /* Declare the marker procedure only once. */
2599 oprintf (header_file
,
2600 "extern void gt_%sx_%s (void *);\n",
2601 wtd
->prefix
, s
->u
.s
.tag
);
2603 if (s
->u
.s
.line
.file
== NULL
)
2605 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2610 if (s
->kind
== TYPE_LANG_STRUCT
)
2613 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2614 write_func_for_structure (s
, ss
, NULL
, wtd
);
2617 write_func_for_structure (s
, s
, NULL
, wtd
);
2620 for (s
= param_structs
; s
; s
= s
->next
)
2621 if (s
->gc_used
== GC_POINTED_TO
)
2623 type_p
* param
= s
->u
.param_struct
.param
;
2624 type_p stru
= s
->u
.param_struct
.stru
;
2626 /* Declare the marker procedure. */
2627 oprintf (header_file
, "extern void gt_%s_", wtd
->prefix
);
2628 output_mangled_typename (header_file
, s
);
2629 oprintf (header_file
, " (void *);\n");
2631 if (stru
->u
.s
.line
.file
== NULL
)
2633 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2638 if (stru
->kind
== TYPE_LANG_STRUCT
)
2641 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2642 write_func_for_structure (s
, ss
, param
, wtd
);
2645 write_func_for_structure (s
, stru
, param
, wtd
);
2649 static const struct write_types_data ggc_wtd
=
2651 "ggc_m", NULL
, "ggc_mark", "ggc_test_and_set_mark", NULL
,
2652 "GC marker procedures. ",
2656 static const struct write_types_data pch_wtd
=
2658 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
2659 "gt_pch_note_reorder",
2660 "PCH type-walking procedures. ",
2664 /* Write out the local pointer-walking routines. */
2666 /* process_field routine for local pointer-walking. */
2669 write_types_local_process_field (type_p f
, const struct walk_type_data
*d
)
2676 case TYPE_LANG_STRUCT
:
2677 case TYPE_PARAM_STRUCT
:
2679 oprintf (d
->of
, "%*sif ((void *)(%s) == this_obj)\n", d
->indent
, "",
2681 oprintf (d
->of
, "%*s op (&(%s), cookie);\n", d
->indent
, "", d
->val
);
2692 /* For S, a structure that's part of ORIG_S, and using parameters
2693 PARAM, write out a routine that:
2694 - Is of type gt_note_pointers
2695 - Calls PROCESS_FIELD on each field of S or its substructures.
2699 write_local_func_for_structure (type_p orig_s
, type_p s
, type_p
*param
)
2701 const char *fn
= s
->u
.s
.line
.file
;
2703 struct walk_type_data d
;
2705 /* This is a hack, and not the good kind either. */
2706 for (i
= NUM_PARAM
- 1; i
>= 0; i
--)
2707 if (param
&& param
[i
] && param
[i
]->kind
== TYPE_POINTER
2708 && UNION_OR_STRUCT_P (param
[i
]->u
.p
))
2709 fn
= param
[i
]->u
.p
->u
.s
.line
.file
;
2711 memset (&d
, 0, sizeof (d
));
2712 d
.of
= get_output_file_with_visibility (fn
);
2714 d
.process_field
= write_types_local_process_field
;
2716 d
.line
= &s
->u
.s
.line
;
2717 d
.bitmap
= s
->u
.s
.bitmap
;
2719 d
.prev_val
[0] = d
.prev_val
[2] = "*x";
2720 d
.prev_val
[1] = "not valid postage"; /* Guarantee an error. */
2721 d
.prev_val
[3] = "x";
2723 d
.fn_wants_lvalue
= true;
2725 oprintf (d
.of
, "\n");
2726 oprintf (d
.of
, "void\n");
2727 oprintf (d
.of
, "gt_pch_p_");
2728 output_mangled_typename (d
.of
, orig_s
);
2729 oprintf (d
.of
, " (ATTRIBUTE_UNUSED void *this_obj,\n"
2731 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2732 "\tATTRIBUTE_UNUSED void *cookie)\n");
2733 oprintf (d
.of
, "{\n");
2734 oprintf (d
.of
, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
2735 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
,
2736 s
->kind
== TYPE_UNION
? "union" : "struct", s
->u
.s
.tag
);
2739 oprintf (d
.of
, "}\n");
2742 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
2745 write_local (type_p structures
, type_p param_structs
)
2749 oprintf (header_file
, "\n/* Local pointer-walking routines. */\n");
2750 for (s
= structures
; s
; s
= s
->next
)
2751 if (s
->gc_used
== GC_POINTED_TO
2752 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2756 if (s
->u
.s
.line
.file
== NULL
)
2759 for (opt
= s
->u
.s
.opt
; opt
; opt
= opt
->next
)
2760 if (strcmp (opt
->name
, "ptr_alias") == 0)
2762 type_p t
= (type_p
) opt
->info
;
2763 if (t
->kind
== TYPE_STRUCT
2764 || t
->kind
== TYPE_UNION
2765 || t
->kind
== TYPE_LANG_STRUCT
)
2767 oprintf (header_file
, "#define gt_pch_p_");
2768 output_mangled_typename (header_file
, s
);
2769 oprintf (header_file
, " gt_pch_p_");
2770 output_mangled_typename (header_file
, t
);
2771 oprintf (header_file
, "\n");
2774 error_at_line (&s
->u
.s
.line
,
2775 "structure alias is not a structure");
2781 /* Declare the marker procedure only once. */
2782 oprintf (header_file
, "extern void gt_pch_p_");
2783 output_mangled_typename (header_file
, s
);
2784 oprintf (header_file
,
2785 "\n (void *, void *, gt_pointer_operator, void *);\n");
2787 if (s
->kind
== TYPE_LANG_STRUCT
)
2790 for (ss
= s
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2791 write_local_func_for_structure (s
, ss
, NULL
);
2794 write_local_func_for_structure (s
, s
, NULL
);
2797 for (s
= param_structs
; s
; s
= s
->next
)
2798 if (s
->gc_used
== GC_POINTED_TO
)
2800 type_p
* param
= s
->u
.param_struct
.param
;
2801 type_p stru
= s
->u
.param_struct
.stru
;
2803 /* Declare the marker procedure. */
2804 oprintf (header_file
, "extern void gt_pch_p_");
2805 output_mangled_typename (header_file
, s
);
2806 oprintf (header_file
,
2807 "\n (void *, void *, gt_pointer_operator, void *);\n");
2809 if (stru
->u
.s
.line
.file
== NULL
)
2811 fprintf (stderr
, "warning: structure `%s' used but not defined\n",
2816 if (stru
->kind
== TYPE_LANG_STRUCT
)
2819 for (ss
= stru
->u
.s
.lang_struct
; ss
; ss
= ss
->next
)
2820 write_local_func_for_structure (s
, ss
, param
);
2823 write_local_func_for_structure (s
, stru
, param
);
2827 /* Write out the 'enum' definition for gt_types_enum. */
2830 write_enum_defn (type_p structures
, type_p param_structs
)
2834 oprintf (header_file
, "\n/* Enumeration of types known. */\n");
2835 oprintf (header_file
, "enum gt_types_enum {\n");
2836 for (s
= structures
; s
; s
= s
->next
)
2837 if (s
->gc_used
== GC_POINTED_TO
2838 || s
->gc_used
== GC_MAYBE_POINTED_TO
)
2840 if (s
->gc_used
== GC_MAYBE_POINTED_TO
2841 && s
->u
.s
.line
.file
== NULL
)
2844 oprintf (header_file
, " gt_ggc_e_");
2845 output_mangled_typename (header_file
, s
);
2846 oprintf (header_file
, ", \n");
2848 for (s
= param_structs
; s
; s
= s
->next
)
2849 if (s
->gc_used
== GC_POINTED_TO
)
2851 oprintf (header_file
, " gt_e_");
2852 output_mangled_typename (header_file
, s
);
2853 oprintf (header_file
, ", \n");
2855 oprintf (header_file
, " gt_types_enum_last\n");
2856 oprintf (header_file
, "};\n");
2859 /* Might T contain any non-pointer elements? */
2862 contains_scalar_p (type_p t
)
2870 return contains_scalar_p (t
->u
.a
.p
);
2872 /* Could also check for structures that have no non-pointer
2873 fields, but there aren't enough of those to worry about. */
2878 /* Mangle FN and print it to F. */
2881 put_mangled_filename (outf_p f
, const char *fn
)
2883 const char *name
= get_output_file_name (fn
);
2884 for (; *name
!= 0; name
++)
2885 if (ISALNUM (*name
))
2886 oprintf (f
, "%c", *name
);
2888 oprintf (f
, "%c", '_');
2891 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
2892 LASTNAME, and NAME are all strings to insert in various places in
2893 the resulting code. */
2896 finish_root_table (struct flist
*flp
, const char *pfx
, const char *lastname
,
2897 const char *tname
, const char *name
)
2901 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
2902 if (fli2
->started_p
)
2904 oprintf (fli2
->f
, " %s\n", lastname
);
2905 oprintf (fli2
->f
, "};\n\n");
2908 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
2909 if (fli2
->started_p
)
2911 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
2914 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
2917 oprintf (base_files
[fnum
],
2918 "extern const struct %s gt_%s_",
2920 put_mangled_filename (base_files
[fnum
], fli2
->name
);
2921 oprintf (base_files
[fnum
], "[];\n");
2927 for (fnum
= 0; fnum
< num_lang_dirs
; fnum
++)
2928 oprintf (base_files
[fnum
],
2929 "const struct %s * const %s[] = {\n",
2934 for (fli2
= flp
; fli2
; fli2
= fli2
->next
)
2935 if (fli2
->started_p
)
2937 lang_bitmap bitmap
= get_lang_bitmap (fli2
->name
);
2940 fli2
->started_p
= 0;
2942 for (fnum
= 0; bitmap
!= 0; fnum
++, bitmap
>>= 1)
2945 oprintf (base_files
[fnum
], " gt_%s_", pfx
);
2946 put_mangled_filename (base_files
[fnum
], fli2
->name
);
2947 oprintf (base_files
[fnum
], ",\n");
2953 for (fnum
= 0; fnum
< num_lang_dirs
; fnum
++)
2955 oprintf (base_files
[fnum
], " NULL\n");
2956 oprintf (base_files
[fnum
], "};\n");
2961 /* Write out to F the table entry and any marker routines needed to
2962 mark NAME as TYPE. The original variable is V, at LINE.
2963 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
2964 is nonzero iff we are building the root table for hash table caches. */
2967 write_root (outf_p f
, pair_p v
, type_p type
, const char *name
, int has_length
,
2968 struct fileloc
*line
, const char *if_marked
)
2975 for (fld
= type
->u
.s
.fields
; fld
; fld
= fld
->next
)
2978 const char *desc
= NULL
;
2981 for (o
= fld
->opt
; o
; o
= o
->next
)
2982 if (strcmp (o
->name
, "skip") == 0)
2984 else if (strcmp (o
->name
, "desc") == 0)
2987 error_at_line (line
,
2988 "field `%s' of global `%s' has unknown option `%s'",
2989 fld
->name
, name
, o
->name
);
2993 else if (desc
&& fld
->type
->kind
== TYPE_UNION
)
2995 pair_p validf
= NULL
;
2998 for (ufld
= fld
->type
->u
.s
.fields
; ufld
; ufld
= ufld
->next
)
3000 const char *tag
= NULL
;
3003 for (oo
= ufld
->opt
; oo
; oo
= oo
->next
)
3004 if (strcmp (oo
->name
, "tag") == 0)
3006 if (tag
== NULL
|| strcmp (tag
, desc
) != 0)
3009 error_at_line (line
,
3010 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3011 name
, fld
->name
, validf
->name
,
3012 name
, fld
->name
, ufld
->name
,
3019 newname
= xasprintf ("%s.%s.%s",
3020 name
, fld
->name
, validf
->name
);
3021 write_root (f
, v
, validf
->type
, newname
, 0, line
,
3027 error_at_line (line
,
3028 "global `%s.%s' has `desc' option but is not union",
3033 newname
= xasprintf ("%s.%s", name
, fld
->name
);
3034 write_root (f
, v
, fld
->type
, newname
, 0, line
, if_marked
);
3044 newname
= xasprintf ("%s[0]", name
);
3045 write_root (f
, v
, type
->u
.a
.p
, newname
, has_length
, line
, if_marked
);
3054 oprintf (f
, " {\n");
3055 oprintf (f
, " &%s,\n", name
);
3058 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3060 oprintf (f
, " * (%s)", ap
->u
.a
.len
);
3061 else if (ap
== v
->type
)
3062 oprintf (f
, " * ARRAY_SIZE (%s)", v
->name
);
3064 oprintf (f
, " sizeof (%s", v
->name
);
3065 for (ap
= v
->type
; ap
->kind
== TYPE_ARRAY
; ap
= ap
->u
.a
.p
)
3067 oprintf (f
, "),\n");
3071 if (! has_length
&& UNION_OR_STRUCT_P (tp
))
3073 oprintf (f
, " >_ggc_mx_%s,\n", tp
->u
.s
.tag
);
3074 oprintf (f
, " >_pch_nx_%s", tp
->u
.s
.tag
);
3076 else if (! has_length
&& tp
->kind
== TYPE_PARAM_STRUCT
)
3078 oprintf (f
, " >_ggc_m_");
3079 output_mangled_typename (f
, tp
);
3080 oprintf (f
, ",\n >_pch_n_");
3081 output_mangled_typename (f
, tp
);
3084 && (tp
->kind
== TYPE_POINTER
|| UNION_OR_STRUCT_P (tp
)))
3086 oprintf (f
, " >_ggc_ma_%s,\n", name
);
3087 oprintf (f
, " >_pch_na_%s", name
);
3091 error_at_line (line
,
3092 "global `%s' is pointer to unimplemented type",
3096 oprintf (f
, ",\n &%s", if_marked
);
3097 oprintf (f
, "\n },\n");
3103 oprintf (f
, " {\n");
3104 oprintf (f
, " &%s,\n", name
);
3105 oprintf (f
, " 1, \n");
3106 oprintf (f
, " sizeof (%s),\n", v
->name
);
3107 oprintf (f
, " >_ggc_m_S,\n");
3108 oprintf (f
, " (gt_pointer_walker) >_pch_n_S\n");
3109 oprintf (f
, " },\n");
3117 error_at_line (line
,
3118 "global `%s' is unimplemented type",
3123 /* This generates a routine to walk an array. */
3126 write_array (outf_p f
, pair_p v
, const struct write_types_data
*wtd
)
3128 struct walk_type_data d
;
3131 memset (&d
, 0, sizeof (d
));
3137 d
.bitmap
= get_lang_bitmap (v
->line
.file
);
3140 d
.prev_val
[3] = prevval3
= xasprintf ("&%s", v
->name
);
3142 if (wtd
->param_prefix
)
3144 oprintf (f
, "static void gt_%sa_%s\n", wtd
->param_prefix
, v
->name
);
3146 " (void *, void *, gt_pointer_operator, void *);\n");
3147 oprintf (f
, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3148 wtd
->param_prefix
, v
->name
);
3150 " ATTRIBUTE_UNUSED void *x_p,\n"
3151 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3152 " ATTRIBUTE_UNUSED void * cookie)\n");
3153 oprintf (d
.of
, "{\n");
3154 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3155 d
.process_field
= write_types_local_process_field
;
3156 walk_type (v
->type
, &d
);
3157 oprintf (f
, "}\n\n");
3161 oprintf (f
, "static void gt_%sa_%s (void *);\n",
3162 wtd
->prefix
, v
->name
);
3163 oprintf (f
, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3164 wtd
->prefix
, v
->name
);
3166 d
.prev_val
[0] = d
.prev_val
[1] = d
.prev_val
[2] = d
.val
= v
->name
;
3167 d
.process_field
= write_types_process_field
;
3168 walk_type (v
->type
, &d
);
3170 oprintf (f
, "}\n\n");
3173 /* Output a table describing the locations and types of VARIABLES. */
3176 write_roots (pair_p variables
)
3179 struct flist
*flp
= NULL
;
3181 for (v
= variables
; v
; v
= v
->next
)
3183 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3185 const char *length
= NULL
;
3186 int deletable_p
= 0;
3189 for (o
= v
->opt
; o
; o
= o
->next
)
3190 if (strcmp (o
->name
, "length") == 0)
3192 else if (strcmp (o
->name
, "deletable") == 0)
3194 else if (strcmp (o
->name
, "param_is") == 0)
3196 else if (strncmp (o
->name
, "param", 5) == 0
3197 && ISDIGIT (o
->name
[5])
3198 && strcmp (o
->name
+ 6, "_is") == 0)
3200 else if (strcmp (o
->name
, "if_marked") == 0)
3203 error_at_line (&v
->line
,
3204 "global `%s' has unknown option `%s'",
3207 for (fli
= flp
; fli
; fli
= fli
->next
)
3212 fli
= XNEW (struct flist
);
3216 fli
->name
= v
->line
.file
;
3219 oprintf (f
, "\n/* GC roots. */\n\n");
3224 && v
->type
->kind
== TYPE_POINTER
3225 && (v
->type
->u
.p
->kind
== TYPE_POINTER
3226 || v
->type
->u
.p
->kind
== TYPE_STRUCT
))
3228 write_array (f
, v
, &ggc_wtd
);
3229 write_array (f
, v
, &pch_wtd
);
3233 for (v
= variables
; v
; v
= v
->next
)
3235 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3241 for (o
= v
->opt
; o
; o
= o
->next
)
3242 if (strcmp (o
->name
, "length") == 0)
3244 else if (strcmp (o
->name
, "deletable") == 0
3245 || strcmp (o
->name
, "if_marked") == 0)
3251 for (fli
= flp
; fli
; fli
= fli
->next
)
3254 if (! fli
->started_p
)
3258 oprintf (f
, "const struct ggc_root_tab gt_ggc_r_");
3259 put_mangled_filename (f
, v
->line
.file
);
3260 oprintf (f
, "[] = {\n");
3263 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3266 finish_root_table (flp
, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3269 for (v
= variables
; v
; v
= v
->next
)
3271 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3276 for (o
= v
->opt
; o
; o
= o
->next
)
3277 if (strcmp (o
->name
, "deletable") == 0)
3279 else if (strcmp (o
->name
, "if_marked") == 0)
3285 for (fli
= flp
; fli
; fli
= fli
->next
)
3288 if (! fli
->started_p
)
3292 oprintf (f
, "const struct ggc_root_tab gt_ggc_rd_");
3293 put_mangled_filename (f
, v
->line
.file
);
3294 oprintf (f
, "[] = {\n");
3297 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3301 finish_root_table (flp
, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3302 "gt_ggc_deletable_rtab");
3304 for (v
= variables
; v
; v
= v
->next
)
3306 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3308 const char *if_marked
= NULL
;
3312 for (o
= v
->opt
; o
; o
= o
->next
)
3313 if (strcmp (o
->name
, "length") == 0)
3315 else if (strcmp (o
->name
, "if_marked") == 0)
3316 if_marked
= o
->info
;
3318 if (if_marked
== NULL
)
3321 if (v
->type
->kind
!= TYPE_POINTER
3322 || v
->type
->u
.p
->kind
!= TYPE_PARAM_STRUCT
3323 || v
->type
->u
.p
->u
.param_struct
.stru
!= find_structure ("htab", 0))
3325 error_at_line (&v
->line
, "if_marked option used but not hash table");
3329 for (fli
= flp
; fli
; fli
= fli
->next
)
3332 if (! fli
->started_p
)
3336 oprintf (f
, "const struct ggc_cache_tab gt_ggc_rc_");
3337 put_mangled_filename (f
, v
->line
.file
);
3338 oprintf (f
, "[] = {\n");
3341 write_root (f
, v
, v
->type
->u
.p
->u
.param_struct
.param
[0],
3342 v
->name
, length_p
, &v
->line
, if_marked
);
3345 finish_root_table (flp
, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
3346 "gt_ggc_cache_rtab");
3348 for (v
= variables
; v
; v
= v
->next
)
3350 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3353 int if_marked_p
= 0;
3356 for (o
= v
->opt
; o
; o
= o
->next
)
3357 if (strcmp (o
->name
, "length") == 0)
3359 else if (strcmp (o
->name
, "if_marked") == 0)
3365 for (fli
= flp
; fli
; fli
= fli
->next
)
3368 if (! fli
->started_p
)
3372 oprintf (f
, "const struct ggc_root_tab gt_pch_rc_");
3373 put_mangled_filename (f
, v
->line
.file
);
3374 oprintf (f
, "[] = {\n");
3377 write_root (f
, v
, v
->type
, v
->name
, length_p
, &v
->line
, NULL
);
3380 finish_root_table (flp
, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3381 "gt_pch_cache_rtab");
3383 for (v
= variables
; v
; v
= v
->next
)
3385 outf_p f
= get_output_file_with_visibility (v
->line
.file
);
3390 for (o
= v
->opt
; o
; o
= o
->next
)
3391 if (strcmp (o
->name
, "deletable") == 0
3392 || strcmp (o
->name
, "if_marked") == 0)
3398 if (! contains_scalar_p (v
->type
))
3401 for (fli
= flp
; fli
; fli
= fli
->next
)
3404 if (! fli
->started_p
)
3408 oprintf (f
, "const struct ggc_root_tab gt_pch_rs_");
3409 put_mangled_filename (f
, v
->line
.file
);
3410 oprintf (f
, "[] = {\n");
3413 oprintf (f
, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3417 finish_root_table (flp
, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3418 "gt_pch_scalar_rtab");
3421 /* Record the definition of a generic VEC structure, as if we had expanded
3422 the macros in vec.h:
3424 typedef struct VEC_<type>_base GTY(()) {
3427 <type> GTY((length ("%h.num"))) vec[1];
3430 where the GTY(()) tags are only present if is_scalar is _false_. */
3433 note_def_vec (const char *typename
, bool is_scalar
, struct fileloc
*pos
)
3438 type_p len_ty
= create_scalar_type ("unsigned");
3439 const char *name
= concat ("VEC_", typename
, "_base", (char *)0);
3443 t
= create_scalar_type (typename
);
3448 t
= resolve_typedef (typename
, pos
);
3449 o
= create_option (0, "length", "%h.num");
3452 /* We assemble the field list in reverse order. */
3453 fields
= create_field_at (0, create_array (t
, "1"), "vec", o
, pos
);
3454 fields
= create_field_at (fields
, len_ty
, "alloc", 0, pos
);
3455 fields
= create_field_at (fields
, len_ty
, "num", 0, pos
);
3457 do_typedef (name
, new_structure (name
, 0, pos
, fields
, 0), pos
);
3460 /* Record the definition of an allocation-specific VEC structure, as if
3461 we had expanded the macros in vec.h:
3463 typedef struct VEC_<type>_<astrat> {
3464 VEC_<type>_base base;
3465 } VEC_<type>_<astrat>;
3468 note_def_vec_alloc (const char *type
, const char *astrat
, struct fileloc
*pos
)
3470 const char *astratname
= concat ("VEC_", type
, "_", astrat
, (char *)0);
3471 const char *basename
= concat ("VEC_", type
, "_base", (char *)0);
3473 pair_p field
= create_field_at (0, resolve_typedef (basename
, pos
),
3476 do_typedef (astratname
, new_structure (astratname
, 0, pos
, field
, 0), pos
);
3479 /* Yet more temporary kludge since gengtype doesn't understand conditionals.
3480 This must be kept in sync with input.h. */
3482 define_location_structures (void)
3486 static struct fileloc pos
= { this_file
, __LINE__
};
3487 do_scalar_typedef ("source_location", &pos
);
3489 #ifdef USE_MAPPED_LOCATION
3490 fields
= create_field (0, &scalar_nonchar
, "column");
3491 fields
= create_field (fields
, &scalar_nonchar
, "line");
3492 fields
= create_field (fields
, &string_type
, "file");
3493 locs
= new_structure ("anon:expanded_location", 0, &pos
, fields
, 0);
3495 do_typedef ("expanded_location", locs
, &pos
);
3496 do_scalar_typedef ("location_t", &pos
);
3497 do_scalar_typedef ("source_locus", &pos
);
3499 fields
= create_field (0, &scalar_nonchar
, "line");
3500 fields
= create_field (fields
, &string_type
, "file");
3501 locs
= new_structure ("location_s", 0, &pos
, fields
, 0);
3503 do_typedef ("expanded_location", locs
, &pos
);
3504 do_typedef ("location_t", locs
, &pos
);
3505 do_typedef ("source_locus", create_pointer (locs
), &pos
);
3511 main (int argc
, char **argv
)
3514 static struct fileloc pos
= { this_file
, 0 };
3516 /* fatal uses this */
3517 progname
= "gengtype";
3520 fatal ("usage: gengtype srcdir input-list");
3523 srcdir_len
= strlen (srcdir
);
3525 read_input_list (argv
[2]);
3529 scalar_char
.u
.scalar_is_char
= true;
3530 scalar_nonchar
.u
.scalar_is_char
= false;
3533 /* These types are set up with #define or else outside of where
3535 pos
.line
= __LINE__
+ 1;
3536 do_scalar_typedef ("CUMULATIVE_ARGS", &pos
); pos
.line
++;
3537 do_scalar_typedef ("REAL_VALUE_TYPE", &pos
); pos
.line
++;
3538 do_scalar_typedef ("double_int", &pos
); pos
.line
++;
3539 do_scalar_typedef ("uint8", &pos
); pos
.line
++;
3540 do_scalar_typedef ("jword", &pos
); pos
.line
++;
3541 do_scalar_typedef ("JCF_u2", &pos
); pos
.line
++;
3542 do_scalar_typedef ("void", &pos
); pos
.line
++;
3543 do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos
)), &pos
);
3544 define_location_structures ();
3546 for (i
= 0; i
< num_gt_files
; i
++)
3547 parse_file (gt_files
[i
]);
3552 set_gc_used (variables
);
3555 write_enum_defn (structures
, param_structs
);
3556 write_types (structures
, param_structs
, &ggc_wtd
);
3557 write_types (structures
, param_structs
, &pch_wtd
);
3558 write_local (structures
, param_structs
);
3559 write_roots (variables
);
3561 close_output_files ();