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
24 #include "coretypes.h"
30 /* Nonzero iff an error has occurred. */
31 static int hit_error = 0;
33 static void gen_rtx_next (void);
34 static void write_rtx_next (void);
35 static void open_base_files (void);
36 static void close_output_files (void);
38 /* Report an error at POS, printing MSG. */
41 error_at_line (struct fileloc *pos, const char *msg, ...)
47 fprintf (stderr, "%s:%d: ", pos->file, pos->line);
48 vfprintf (stderr, msg, ap);
55 /* vasprintf, but produces fatal message on out-of-memory. */
57 xvasprintf (char **result, const char *format, va_list args)
59 int ret = vasprintf (result, format, args);
60 if (*result == NULL || ret < 0)
62 fputs ("gengtype: out of memory", stderr);
68 /* Wrapper for xvasprintf. */
70 xasprintf (const char *format, ...)
75 va_start (ap, format);
76 xvasprintf (&result, format, ap);
81 /* The one and only TYPE_STRING. */
83 struct type string_type = {
84 TYPE_STRING, NULL, NULL, GC_USED, {0}
87 /* Lists of various things. */
89 static pair_p typedefs;
90 static type_p structures;
91 static type_p param_structs;
92 static pair_p variables;
94 static void do_scalar_typedef (const char *, struct fileloc *);
95 static type_p find_param_structure
96 (type_p t, type_p param[NUM_PARAM]);
97 static type_p adjust_field_tree_exp (type_p t, options_p opt);
98 static type_p adjust_field_rtx_def (type_p t, options_p opt);
100 /* Define S as a typedef to T at POS. */
103 do_typedef (const char *s, type_p t, struct fileloc *pos)
107 for (p = typedefs; p != NULL; p = p->next)
108 if (strcmp (p->name, s) == 0)
112 error_at_line (pos, "type `%s' previously defined", s);
113 error_at_line (&p->line, "previously defined here");
118 p = XNEW (struct pair);
126 /* Define S as a typename of a scalar. */
129 do_scalar_typedef (const char *s, struct fileloc *pos)
131 do_typedef (s, create_scalar_type (s, strlen (s)), pos);
134 /* Return the type previously defined for S. Use POS to report errors. */
137 resolve_typedef (const char *s, struct fileloc *pos)
140 for (p = typedefs; p != NULL; p = p->next)
141 if (strcmp (p->name, s) == 0)
143 error_at_line (pos, "unidentified type `%s'", s);
144 return create_scalar_type ("char", 4);
147 /* Create and return a new structure with tag NAME (or a union iff
148 ISUNION is nonzero), at POS with fields FIELDS and options O. */
151 new_structure (const char *name, int isunion, struct fileloc *pos,
152 pair_p fields, options_p o)
156 lang_bitmap bitmap = get_base_file_bitmap (pos->file);
158 for (si = structures; si != NULL; si = si->next)
159 if (strcmp (name, si->u.s.tag) == 0
160 && UNION_P (si) == isunion)
163 if (si->kind == TYPE_LANG_STRUCT)
167 for (si = ls->u.s.lang_struct; si != NULL; si = si->next)
168 if (si->u.s.bitmap == bitmap)
171 else if (si->u.s.line.file != NULL && si->u.s.bitmap != bitmap)
174 si = XCNEW (struct type);
175 memcpy (si, ls, sizeof (struct type));
176 ls->kind = TYPE_LANG_STRUCT;
177 ls->u.s.lang_struct = si;
178 ls->u.s.fields = NULL;
180 si->pointer_to = NULL;
181 si->u.s.lang_struct = ls;
186 if (ls != NULL && s == NULL)
188 s = XCNEW (struct type);
189 s->next = ls->u.s.lang_struct;
190 ls->u.s.lang_struct = s;
191 s->u.s.lang_struct = ls;
198 s = XCNEW (struct type);
199 s->next = structures;
203 if (s->u.s.line.file != NULL
204 || (s->u.s.lang_struct && (s->u.s.lang_struct->u.s.bitmap & bitmap)))
206 error_at_line (pos, "duplicate structure definition");
207 error_at_line (&s->u.s.line, "previous definition here");
210 s->kind = isunion ? TYPE_UNION : TYPE_STRUCT;
213 s->u.s.fields = fields;
215 s->u.s.bitmap = bitmap;
216 if (s->u.s.lang_struct)
217 s->u.s.lang_struct->u.s.bitmap |= bitmap;
222 /* Return the previously-defined structure with tag NAME (or a union
223 iff ISUNION is nonzero), or a new empty structure or union if none
224 was defined previously. */
227 find_structure (const char *name, int isunion)
231 for (s = structures; s != NULL; s = s->next)
232 if (strcmp (name, s->u.s.tag) == 0
233 && UNION_P (s) == isunion)
236 s = XCNEW (struct type);
237 s->next = structures;
239 s->kind = isunion ? TYPE_UNION : TYPE_STRUCT;
245 /* Return the previously-defined parameterized structure for structure
246 T and parameters PARAM, or a new parameterized empty structure or
247 union if none was defined previously. */
250 find_param_structure (type_p t, type_p param[NUM_PARAM])
254 for (res = param_structs; res; res = res->next)
255 if (res->u.param_struct.stru == t
256 && memcmp (res->u.param_struct.param, param,
257 sizeof (type_p) * NUM_PARAM) == 0)
261 res = XCNEW (struct type);
262 res->kind = TYPE_PARAM_STRUCT;
263 res->next = param_structs;
265 res->u.param_struct.stru = t;
266 memcpy (res->u.param_struct.param, param, sizeof (type_p) * NUM_PARAM);
271 /* Return a scalar type with name NAME. */
274 create_scalar_type (const char *name, size_t name_len)
276 type_p r = XCNEW (struct type);
277 r->kind = TYPE_SCALAR;
278 r->u.sc = (char *) xmemdup (name, name_len, name_len + 1);
282 /* Return a pointer to T. */
285 create_pointer (type_p t)
289 type_p r = XCNEW (struct type);
290 r->kind = TYPE_POINTER;
294 return t->pointer_to;
297 /* Return an array of length LEN. */
300 create_array (type_p t, const char *len)
304 v = XCNEW (struct type);
305 v->kind = TYPE_ARRAY;
311 /* Return an options structure with name NAME and info INFO. NEXT is the
312 next option in the chain. */
315 create_option (options_p next, const char *name, const void *info)
317 options_p o = XNEW (struct options);
320 o->info = (const char*) info;
324 /* Add a variable named S of type T with options O defined at POS,
328 note_variable (const char *s, type_p t, options_p o, struct fileloc *pos)
331 n = XNEW (struct pair);
340 /* Create a fake field with the given type and name. NEXT is the next
341 field in the chain. */
344 create_field (pair_p next, type_p type, const char *name)
348 field = XNEW (struct pair);
353 field->line.file = __FILE__;
354 field->line.line = __LINE__;
358 /* Like create_field, but the field is only valid when condition COND
362 create_optional_field (pair_p next, type_p type, const char *name,
366 pair_p union_fields, field;
369 /* Create a fake union type with a single nameless field of type TYPE.
370 The field has a tag of "1". This allows us to make the presence
371 of a field of type TYPE depend on some boolean "desc" being true. */
372 union_fields = create_field (NULL, type, "");
373 union_fields->opt = create_option (union_fields->opt, "dot", "");
374 union_fields->opt = create_option (union_fields->opt, "tag", "1");
375 union_type = new_structure (xasprintf ("%s_%d", "fake_union", id++), 1,
376 &lexer_line, union_fields, NULL);
378 /* Create the field and give it the new fake union type. Add a "desc"
379 tag that specifies the condition under which the field is valid. */
380 field = create_field (next, union_type, name);
381 field->opt = create_option (field->opt, "desc", cond);
385 /* We don't care how long a CONST_DOUBLE is. */
386 #define CONST_DOUBLE_FORMAT "ww"
387 /* We don't want to see codes that are only for generator files. */
388 #undef GENERATOR_FILE
391 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
397 static const char * const rtx_name[NUM_RTX_CODE] = {
398 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
403 static const char * const rtx_format[NUM_RTX_CODE] = {
404 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
409 static int rtx_next_new[NUM_RTX_CODE];
411 /* We also need codes and names for insn notes (not register notes).
412 Note that we do *not* bias the note values here. */
414 #define DEF_INSN_NOTE(NAME) NAME,
415 #include "insn-notes.def"
421 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
422 default field for line number notes. */
423 static const char *const note_insn_name[NOTE_INSN_MAX+1] = {
424 #define DEF_INSN_NOTE(NAME) #NAME,
425 #include "insn-notes.def"
429 #undef CONST_DOUBLE_FORMAT
430 #define GENERATOR_FILE
432 /* Generate the contents of the rtx_next array. This really doesn't belong
433 in gengtype at all, but it's needed for adjust_field_rtx_def. */
439 for (i = 0; i < NUM_RTX_CODE; i++)
443 rtx_next_new[i] = -1;
444 if (strncmp (rtx_format[i], "iuu", 3) == 0)
446 else if (i == COND_EXEC || i == SET || i == EXPR_LIST || i == INSN_LIST)
449 for (k = strlen (rtx_format[i]) - 1; k >= 0; k--)
450 if (rtx_format[i][k] == 'e' || rtx_format[i][k] == 'u')
455 /* Write out the contents of the rtx_next array. */
457 write_rtx_next (void)
459 outf_p f = get_output_file_with_visibility (NULL);
462 oprintf (f, "\n/* Used to implement the RTX_NEXT macro. */\n");
463 oprintf (f, "const unsigned char rtx_next[NUM_RTX_CODE] = {\n");
464 for (i = 0; i < NUM_RTX_CODE; i++)
465 if (rtx_next_new[i] == -1)
466 oprintf (f, " 0,\n");
469 " RTX_HDR_SIZE + %d * sizeof (rtunion),\n",
474 /* Handle `special("rtx_def")'. This is a special case for field
475 `fld' of struct rtx_def, which is an array of unions whose values
476 are based in a complex way on the type of RTL. */
479 adjust_field_rtx_def (type_p t, options_p ARG_UNUSED (opt))
484 type_p rtx_tp, rtvec_tp, tree_tp, mem_attrs_tp, note_union_tp, scalar_tp;
485 type_p bitmap_tp, basic_block_tp, reg_attrs_tp, constant_tp, symbol_union_tp;
487 if (t->kind != TYPE_UNION)
489 error_at_line (&lexer_line,
490 "special `rtx_def' must be applied to a union");
494 nodot = create_option (NULL, "dot", "");
496 rtx_tp = create_pointer (find_structure ("rtx_def", 0));
497 rtvec_tp = create_pointer (find_structure ("rtvec_def", 0));
498 tree_tp = create_pointer (find_structure ("tree_node", 1));
499 mem_attrs_tp = create_pointer (find_structure ("mem_attrs", 0));
500 reg_attrs_tp = create_pointer (find_structure ("reg_attrs", 0));
501 bitmap_tp = create_pointer (find_structure ("bitmap_element_def", 0));
502 basic_block_tp = create_pointer (find_structure ("basic_block_def", 0));
503 constant_tp = create_pointer (find_structure ("constant_descriptor_rtx", 0));
504 scalar_tp = create_scalar_type ("rtunion scalar", 14);
507 pair_p note_flds = NULL;
510 for (c = 0; c <= NOTE_INSN_MAX; c++)
515 note_flds = create_field (note_flds, &string_type, "rt_str");
518 case NOTE_INSN_BLOCK_BEG:
519 case NOTE_INSN_BLOCK_END:
520 note_flds = create_field (note_flds, tree_tp, "rt_tree");
523 case NOTE_INSN_VAR_LOCATION:
524 note_flds = create_field (note_flds, rtx_tp, "rt_rtx");
528 note_flds = create_field (note_flds, scalar_tp, "rt_int");
531 /* NOTE_INSN_MAX is used as the default field for line
533 if (c == NOTE_INSN_MAX)
534 note_flds->opt = create_option (nodot, "default", "");
536 note_flds->opt = create_option (nodot, "tag", note_insn_name[c]);
538 note_union_tp = new_structure ("rtx_def_note_subunion", 1,
539 &lexer_line, note_flds, NULL);
541 /* Create a type to represent the various forms of SYMBOL_REF_DATA. */
545 sym_flds = create_field (NULL, tree_tp, "rt_tree");
546 sym_flds->opt = create_option (nodot, "default", "");
548 sym_flds = create_field (sym_flds, constant_tp, "rt_constant");
549 sym_flds->opt = create_option (nodot, "tag", "1");
551 symbol_union_tp = new_structure ("rtx_def_symbol_subunion", 1,
552 &lexer_line, sym_flds, NULL);
554 for (i = 0; i < NUM_RTX_CODE; i++)
556 pair_p subfields = NULL;
557 size_t aindex, nmindex;
562 for (aindex = 0; aindex < strlen (rtx_format[i]); aindex++)
567 switch (rtx_format[i][aindex])
578 if (i == MEM && aindex == 1)
579 t = mem_attrs_tp, subname = "rt_mem";
580 else if (i == JUMP_INSN && aindex == 9)
581 t = rtx_tp, subname = "rt_rtx";
582 else if (i == CODE_LABEL && aindex == 4)
583 t = scalar_tp, subname = "rt_int";
584 else if (i == CODE_LABEL && aindex == 5)
585 t = rtx_tp, subname = "rt_rtx";
586 else if (i == LABEL_REF
587 && (aindex == 1 || aindex == 2))
588 t = rtx_tp, subname = "rt_rtx";
589 else if (i == NOTE && aindex == 4)
590 t = note_union_tp, subname = "";
591 else if (i == NOTE && aindex >= 7)
592 t = scalar_tp, subname = "rt_int";
593 else if (i == ADDR_DIFF_VEC && aindex == 4)
594 t = scalar_tp, subname = "rt_int";
595 else if (i == VALUE && aindex == 0)
596 t = scalar_tp, subname = "rt_int";
597 else if (i == REG && aindex == 1)
598 t = scalar_tp, subname = "rt_int";
599 else if (i == REG && aindex == 2)
600 t = reg_attrs_tp, subname = "rt_reg";
601 else if (i == SCRATCH && aindex == 0)
602 t = scalar_tp, subname = "rt_int";
603 else if (i == SYMBOL_REF && aindex == 1)
604 t = scalar_tp, subname = "rt_int";
605 else if (i == SYMBOL_REF && aindex == 2)
606 t = symbol_union_tp, subname = "";
607 else if (i == BARRIER && aindex >= 3)
608 t = scalar_tp, subname = "rt_int";
611 error_at_line (&lexer_line,
612 "rtx type `%s' has `0' in position %lu, can't handle",
613 rtx_name[i], (unsigned long) aindex);
635 subname = "rt_rtvec";
654 error_at_line (&lexer_line,
655 "rtx type `%s' has `%c' in position %lu, can't handle",
656 rtx_name[i], rtx_format[i][aindex],
657 (unsigned long)aindex);
663 subfields = create_field (subfields, t,
664 xasprintf (".fld[%lu].%s",
665 (unsigned long) aindex,
667 subfields->opt = nodot;
668 if (t == note_union_tp)
669 subfields->opt = create_option (subfields->opt, "desc",
670 "NOTE_LINE_NUMBER (&%0)");
671 if (t == symbol_union_tp)
672 subfields->opt = create_option (subfields->opt, "desc",
673 "CONSTANT_POOL_ADDRESS_P (&%0)");
678 /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds. */
679 type_p field_tp = find_structure ("block_symbol", 0);
681 = create_optional_field (subfields, field_tp, "block_sym",
682 "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
685 sname = xasprintf ("rtx_def_%s", rtx_name[i]);
686 substruct = new_structure (sname, 0, &lexer_line, subfields, NULL);
688 ftag = xstrdup (rtx_name[i]);
689 for (nmindex = 0; nmindex < strlen (ftag); nmindex++)
690 ftag[nmindex] = TOUPPER (ftag[nmindex]);
692 flds = create_field (flds, substruct, "");
693 flds->opt = create_option (nodot, "tag", ftag);
696 return new_structure ("rtx_def_subunion", 1, &lexer_line, flds, nodot);
699 /* Handle `special("tree_exp")'. This is a special case for
700 field `operands' of struct tree_exp, which although it claims to contain
701 pointers to trees, actually sometimes contains pointers to RTL too.
702 Passed T, the old type of the field, and OPT its options. Returns
703 a new type for the field. */
706 adjust_field_tree_exp (type_p t, options_p opt ATTRIBUTE_UNUSED)
711 if (t->kind != TYPE_ARRAY)
713 error_at_line (&lexer_line,
714 "special `tree_exp' must be applied to an array");
718 nodot = create_option (NULL, "dot", "");
720 flds = create_field (NULL, t, "");
721 flds->opt = create_option (nodot, "length",
722 "TREE_CODE_LENGTH (TREE_CODE ((tree) &%0))");
723 flds->opt = create_option (flds->opt, "default", "");
725 return new_structure ("tree_exp_subunion", 1, &lexer_line, flds, nodot);
728 /* Perform any special processing on a type T, about to become the type
729 of a field. Return the appropriate type for the field.
731 - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
732 - Similarly for arrays of pointer-to-char;
733 - Converts structures for which a parameter is provided to
735 - Handles "special" options.
739 adjust_field_type (type_p t, options_p opt)
742 const int pointer_p = t->kind == TYPE_POINTER;
743 type_p params[NUM_PARAM];
747 for (i = 0; i < NUM_PARAM; i++)
750 for (; opt; opt = opt->next)
751 if (strcmp (opt->name, "length") == 0)
753 else if (strcmp (opt->name, "param_is") == 0
754 || (strncmp (opt->name, "param", 5) == 0
755 && ISDIGIT (opt->name[5])
756 && strcmp (opt->name + 6, "_is") == 0))
758 int num = ISDIGIT (opt->name[5]) ? opt->name[5] - '0' : 0;
760 if (! UNION_OR_STRUCT_P (t)
761 && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p)))
763 error_at_line (&lexer_line,
764 "option `%s' may only be applied to structures or structure pointers",
770 if (params[num] != NULL)
771 error_at_line (&lexer_line, "duplicate `%s' option", opt->name);
772 if (! ISDIGIT (opt->name[5]))
773 params[num] = create_pointer ((type_p) opt->info);
775 params[num] = (type_p) opt->info;
777 else if (strcmp (opt->name, "special") == 0)
779 const char *special_name = opt->info;
780 if (strcmp (special_name, "tree_exp") == 0)
781 t = adjust_field_tree_exp (t, opt);
782 else if (strcmp (special_name, "rtx_def") == 0)
783 t = adjust_field_rtx_def (t, opt);
785 error_at_line (&lexer_line, "unknown special `%s'", special_name);
794 realt = find_param_structure (t, params);
795 t = pointer_p ? create_pointer (realt) : realt;
800 && t->u.p->kind == TYPE_SCALAR
801 && (strcmp (t->u.p->u.sc, "char") == 0
802 || strcmp (t->u.p->u.sc, "unsigned char") == 0))
804 if (t->kind == TYPE_ARRAY && t->u.a.p->kind == TYPE_POINTER
805 && t->u.a.p->u.p->kind == TYPE_SCALAR
806 && (strcmp (t->u.a.p->u.p->u.sc, "char") == 0
807 || strcmp (t->u.a.p->u.p->u.sc, "unsigned char") == 0))
808 return create_array (&string_type, t->u.a.len);
813 /* Create a union for YYSTYPE, as yacc would do it, given a fieldlist FIELDS
814 and information about the correspondence between token types and fields
815 in TYPEINFO. POS is used for error messages. */
818 note_yacc_type (options_p o, pair_p fields, pair_p typeinfo,
824 for (p = typeinfo; p; p = p->next)
831 if (p->type == (type_p) 1)
836 for (pp = typeinfo; pp; pp = pp->next)
837 if (pp->type != (type_p) 1
838 && strcmp (pp->opt->info, p->opt->info) == 0)
847 for (m = fields; m; m = m->next)
848 if (strcmp (m->name, p->name) == 0)
852 error_at_line (&p->line,
853 "couldn't match fieldname `%s'", p->name);
864 || p->type == (type_p) 1)
870 do_typedef ("YYSTYPE", new_structure ("yy_union", 1, pos, typeinfo, o), pos);
873 static void set_gc_used_type (type_p, enum gc_used_enum, type_p *);
874 static void set_gc_used (pair_p);
876 /* Handle OPT for set_gc_used_type. */
879 process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef,
880 int *pass_param, int *length, int *skip, type_p *nested_ptr)
883 for (o = opt; o; o = o->next)
884 if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO)
885 set_gc_used_type ((type_p) o->info, GC_POINTED_TO, NULL);
886 else if (strcmp (o->name, "maybe_undef") == 0)
888 else if (strcmp (o->name, "use_params") == 0)
890 else if (strcmp (o->name, "length") == 0)
892 else if (strcmp (o->name, "skip") == 0)
894 else if (strcmp (o->name, "nested_ptr") == 0)
895 *nested_ptr = ((const struct nested_ptr_data *) o->info)->type;
898 /* Set the gc_used field of T to LEVEL, and handle the types it references. */
901 set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM])
903 if (t->gc_used >= level)
917 process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, &dummy,
920 for (f = t->u.s.fields; f; f = f->next)
926 type_p nested_ptr = NULL;
927 process_gc_options (f->opt, level, &maybe_undef, &pass_param,
928 &length, &skip, &nested_ptr);
930 if (nested_ptr && f->type->kind == TYPE_POINTER)
931 set_gc_used_type (nested_ptr, GC_POINTED_TO,
932 pass_param ? param : NULL);
933 else if (length && f->type->kind == TYPE_POINTER)
934 set_gc_used_type (f->type->u.p, GC_USED, NULL);
935 else if (maybe_undef && f->type->kind == TYPE_POINTER)
936 set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO, NULL);
937 else if (pass_param && f->type->kind == TYPE_POINTER && param)
938 set_gc_used_type (find_param_structure (f->type->u.p, param),
939 GC_POINTED_TO, NULL);
941 ; /* target type is not used through this field */
943 set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL);
949 set_gc_used_type (t->u.p, GC_POINTED_TO, NULL);
953 set_gc_used_type (t->u.a.p, GC_USED, param);
956 case TYPE_LANG_STRUCT:
957 for (t = t->u.s.lang_struct; t; t = t->next)
958 set_gc_used_type (t, level, param);
961 case TYPE_PARAM_STRUCT:
964 for (i = 0; i < NUM_PARAM; i++)
965 if (t->u.param_struct.param[i] != 0)
966 set_gc_used_type (t->u.param_struct.param[i], GC_USED, NULL);
968 if (t->u.param_struct.stru->gc_used == GC_POINTED_TO)
969 level = GC_POINTED_TO;
972 t->u.param_struct.stru->gc_used = GC_UNUSED;
973 set_gc_used_type (t->u.param_struct.stru, level,
974 t->u.param_struct.param);
982 /* Set the gc_used fields of all the types pointed to by VARIABLES. */
985 set_gc_used (pair_p variables)
988 for (p = variables; p; p = p->next)
989 set_gc_used_type (p->type, GC_USED, NULL);
992 /* File mapping routines. For each input file, there is one output .c file
993 (but some output files have many input files), and there is one .h file
994 for the whole build. */
996 /* The list of output files. */
997 static outf_p output_files;
999 /* The output header file that is included into pretty much every
1001 static outf_p header_file;
1003 /* Number of files specified in gtfiles. */
1004 #define NUM_GT_FILES (ARRAY_SIZE (all_files) - 1)
1006 /* Number of files in the language files array. */
1007 #define NUM_LANG_FILES (ARRAY_SIZE (lang_files) - 1)
1009 /* Length of srcdir name. */
1010 static int srcdir_len = 0;
1012 #define NUM_BASE_FILES (ARRAY_SIZE (lang_dir_names) - 1)
1013 outf_p base_files[NUM_BASE_FILES];
1015 static outf_p create_file (const char *, const char *);
1016 static const char * get_file_basename (const char *);
1018 /* Create and return an outf_p for a new file for NAME, to be called
1022 create_file (const char *name, const char *oname)
1024 static const char *const hdr[] = {
1025 " Copyright (C) 2004 Free Software Foundation, Inc.\n",
1027 "This file is part of GCC.\n",
1029 "GCC is free software; you can redistribute it and/or modify it under\n",
1030 "the terms of the GNU General Public License as published by the Free\n",
1031 "Software Foundation; either version 2, or (at your option) any later\n",
1034 "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1035 "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1036 "FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n",
1037 "for more details.\n",
1039 "You should have received a copy of the GNU General Public License\n",
1040 "along with GCC; see the file COPYING. If not, write to the Free\n",
1041 "Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA\n",
1042 "02110-1301, USA. */\n",
1044 "/* This file is machine generated. Do not edit. */\n"
1049 f = XCNEW (struct outf);
1050 f->next = output_files;
1054 oprintf (f, "/* Type information for %s.\n", name);
1055 for (i = 0; i < ARRAY_SIZE (hdr); i++)
1056 oprintf (f, "%s", hdr[i]);
1060 /* Print, like fprintf, to O. */
1062 oprintf (outf_p o, const char *format, ...)
1068 va_start (ap, format);
1069 slength = xvasprintf (&s, format, ap);
1071 if (o->bufused + slength > o->buflength)
1073 size_t new_len = o->buflength;
1078 } while (o->bufused + slength >= new_len);
1079 o->buf = XRESIZEVEC (char, o->buf, new_len);
1080 o->buflength = new_len;
1082 memcpy (o->buf + o->bufused, s, slength);
1083 o->bufused += slength;
1088 /* Open the global header file and the language-specific header files. */
1091 open_base_files (void)
1095 header_file = create_file ("GCC", "gtype-desc.h");
1097 for (i = 0; i < NUM_BASE_FILES; i++)
1098 base_files[i] = create_file (lang_dir_names[i],
1099 xasprintf ("gtype-%s.h", lang_dir_names[i]));
1101 /* gtype-desc.c is a little special, so we create it here. */
1103 /* The order of files here matters very much. */
1104 static const char *const ifiles [] = {
1105 "config.h", "system.h", "coretypes.h", "tm.h", "varray.h",
1106 "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1107 "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1108 "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1109 "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1110 "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1111 "cfglayout.h", "except.h", "output.h", NULL
1113 const char *const *ifp;
1114 outf_p gtype_desc_c;
1116 gtype_desc_c = create_file ("GCC", "gtype-desc.c");
1117 for (ifp = ifiles; *ifp; ifp++)
1118 oprintf (gtype_desc_c, "#include \"%s\"\n", *ifp);
1122 /* Determine the pathname to F relative to $(srcdir). */
1125 get_file_basename (const char *f)
1127 const char *basename;
1130 basename = strrchr (f, '/');
1137 for (i = 1; i < NUM_BASE_FILES; i++)
1143 s1 = basename - strlen (lang_dir_names [i]) - 1;
1144 s2 = lang_dir_names [i];
1147 if (l1 >= l2 && IS_DIR_SEPARATOR (s1[-1]) && !memcmp (s1, s2, l2))
1150 if ((basename - f - 1) != srcdir_len)
1151 fatal ("filename `%s' should be preceded by $srcdir", f);
1159 /* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
1160 INPUT_FILE is used by <lang>.
1162 This function should be written to assume that a file _is_ used
1163 if the situation is unclear. If it wrongly assumes a file _is_ used,
1164 a linker error will result. If it wrongly assumes a file _is not_ used,
1165 some GC roots may be missed, which is a much harder-to-debug problem. */
1168 get_base_file_bitmap (const char *input_file)
1170 const char *basename = get_file_basename (input_file);
1171 const char *slashpos = strchr (basename, '/');
1176 /* If the file resides in a language subdirectory (e.g., 'cp'), assume that
1177 it belongs to the corresponding language. The file may belong to other
1178 languages as well (which is checked for below). */
1183 for (i = 1; i < NUM_BASE_FILES; i++)
1184 if ((size_t)(slashpos - basename) == strlen (lang_dir_names [i])
1185 && memcmp (basename, lang_dir_names[i], strlen (lang_dir_names[i])) == 0)
1187 /* It's in a language directory, set that language. */
1192 /* If it's in any config-lang.in, then set for the languages
1197 for (j = 0; j < NUM_LANG_FILES; j++)
1199 if (!strcmp(input_file, lang_files[j]))
1201 for (k = 0; k < NUM_BASE_FILES; k++)
1203 if (!strcmp(lang_dir_names[k], langs_for_lang_files[j]))
1209 /* Otherwise, set all languages. */
1211 bitmap = (1 << NUM_BASE_FILES) - 1;
1216 /* An output file, suitable for definitions, that can see declarations
1217 made in INPUT_FILE and is linked into every language that uses
1221 get_output_file_with_visibility (const char *input_file)
1225 const char *basename;
1226 const char *for_name;
1227 const char *output_name;
1229 /* This can happen when we need a file with visibility on a
1230 structure that we've never seen. We have to just hope that it's
1231 globally visible. */
1232 if (input_file == NULL)
1233 input_file = "system.h";
1235 /* Determine the output file name. */
1236 basename = get_file_basename (input_file);
1238 len = strlen (basename);
1239 if ((len > 2 && memcmp (basename+len-2, ".c", 2) == 0)
1240 || (len > 2 && memcmp (basename+len-2, ".y", 2) == 0)
1241 || (len > 3 && memcmp (basename+len-3, ".in", 3) == 0))
1245 output_name = s = xasprintf ("gt-%s", basename);
1246 for (; *s != '.'; s++)
1247 if (! ISALNUM (*s) && *s != '-')
1249 memcpy (s, ".h", sizeof (".h"));
1250 for_name = basename;
1252 /* Some headers get used by more than one front-end; hence, it
1253 would be inappropriate to spew them out to a single gtype-<lang>.h
1254 (and gengtype doesn't know how to direct spewage into multiple
1255 gtype-<lang>.h headers at this time). Instead, we pair up these
1256 headers with source files (and their special purpose gt-*.h headers). */
1257 else if (strcmp (basename, "c-common.h") == 0)
1258 output_name = "gt-c-common.h", for_name = "c-common.c";
1259 else if (strcmp (basename, "c-tree.h") == 0)
1260 output_name = "gt-c-decl.h", for_name = "c-decl.c";
1261 else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2])
1262 && strcmp (basename + 3, "cp-tree.h") == 0)
1263 output_name = "gt-cp-tree.h", for_name = "cp/tree.c";
1264 else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2])
1265 && strcmp (basename + 3, "decl.h") == 0)
1266 output_name = "gt-cp-decl.h", for_name = "cp/decl.c";
1267 else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2])
1268 && strcmp (basename + 3, "name-lookup.h") == 0)
1269 output_name = "gt-cp-name-lookup.h", for_name = "cp/name-lookup.c";
1270 else if (strncmp (basename, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename[4])
1271 && strcmp (basename + 5, "objc-act.h") == 0)
1272 output_name = "gt-objc-objc-act.h", for_name = "objc/objc-act.c";
1277 for (i = 0; i < NUM_BASE_FILES; i++)
1278 if (memcmp (basename, lang_dir_names[i], strlen (lang_dir_names[i])) == 0
1279 && basename[strlen(lang_dir_names[i])] == '/')
1280 return base_files[i];
1282 output_name = "gtype-desc.c";
1286 /* Look through to see if we've ever seen this output filename before. */
1287 for (r = output_files; r; r = r->next)
1288 if (strcmp (r->name, output_name) == 0)
1291 /* If not, create it. */
1292 r = create_file (for_name, output_name);
1297 /* The name of an output file, suitable for definitions, that can see
1298 declarations made in INPUT_FILE and is linked into every language
1299 that uses INPUT_FILE. */
1302 get_output_file_name (const char *input_file)
1304 return get_output_file_with_visibility (input_file)->name;
1307 /* Copy the output to its final destination,
1308 but don't unnecessarily change modification times. */
1311 close_output_files (void)
1315 for (of = output_files; of; of = of->next)
1319 newfile = fopen (of->name, "r");
1320 if (newfile != NULL )
1325 for (i = 0; i < of->bufused; i++)
1328 ch = fgetc (newfile);
1329 if (ch == EOF || ch != (unsigned char) of->buf[i])
1332 no_write_p = i == of->bufused && fgetc (newfile) == EOF;
1339 newfile = fopen (of->name, "w");
1340 if (newfile == NULL)
1342 perror ("opening output file");
1345 if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused)
1347 perror ("writing output file");
1350 if (fclose (newfile) != 0)
1352 perror ("closing output file");
1365 struct walk_type_data;
1367 /* For scalars and strings, given the item in 'val'.
1368 For structures, given a pointer to the item in 'val'.
1369 For misc. pointers, given the item in 'val'.
1371 typedef void (*process_field_fn)
1372 (type_p f, const struct walk_type_data *p);
1373 typedef void (*func_name_fn)
1374 (type_p s, const struct walk_type_data *p);
1376 /* Parameters for write_types. */
1378 struct write_types_data
1381 const char *param_prefix;
1382 const char *subfield_marker_routine;
1383 const char *marker_routine;
1384 const char *reorder_note_routine;
1385 const char *comment;
1386 int skip_hooks; /* skip hook generation if non zero */
1389 static void output_escaped_param (struct walk_type_data *d,
1390 const char *, const char *);
1391 static void output_mangled_typename (outf_p, type_p);
1392 static void walk_type (type_p t, struct walk_type_data *d);
1393 static void write_func_for_structure
1394 (type_p orig_s, type_p s, type_p * param,
1395 const struct write_types_data *wtd);
1396 static void write_types_process_field
1397 (type_p f, const struct walk_type_data *d);
1398 static void write_types (type_p structures,
1399 type_p param_structs,
1400 const struct write_types_data *wtd);
1401 static void write_types_local_process_field
1402 (type_p f, const struct walk_type_data *d);
1403 static void write_local_func_for_structure
1404 (type_p orig_s, type_p s, type_p * param);
1405 static void write_local (type_p structures,
1406 type_p param_structs);
1407 static void write_enum_defn (type_p structures, type_p param_structs);
1408 static int contains_scalar_p (type_p t);
1409 static void put_mangled_filename (outf_p , const char *);
1410 static void finish_root_table (struct flist *flp, const char *pfx,
1411 const char *tname, const char *lastname,
1413 static void write_root (outf_p , pair_p, type_p, const char *, int,
1414 struct fileloc *, const char *);
1415 static void write_array (outf_p f, pair_p v,
1416 const struct write_types_data *wtd);
1417 static void write_roots (pair_p);
1419 /* Parameters for walk_type. */
1421 struct walk_type_data
1423 process_field_fn process_field;
1428 const char *prev_val[4];
1431 struct fileloc *line;
1436 const char *reorder_fn;
1438 bool fn_wants_lvalue;
1441 /* Print a mangled name representing T to OF. */
1444 output_mangled_typename (outf_p of, type_p t)
1448 else switch (t->kind)
1452 output_mangled_typename (of, t->u.p);
1462 case TYPE_LANG_STRUCT:
1463 oprintf (of, "%lu%s", (unsigned long) strlen (t->u.s.tag), t->u.s.tag);
1465 case TYPE_PARAM_STRUCT:
1468 for (i = 0; i < NUM_PARAM; i++)
1469 if (t->u.param_struct.param[i] != NULL)
1470 output_mangled_typename (of, t->u.param_struct.param[i]);
1471 output_mangled_typename (of, t->u.param_struct.stru);
1479 /* Print PARAM to D->OF processing escapes. D->VAL references the
1480 current object, D->PREV_VAL the object containing the current
1481 object, ONAME is the name of the option and D->LINE is used to
1482 print error messages. */
1485 output_escaped_param (struct walk_type_data *d, const char *param,
1490 for (p = param; *p; p++)
1492 oprintf (d->of, "%c", *p);
1496 oprintf (d->of, "(%s)", d->prev_val[2]);
1499 oprintf (d->of, "(%s)", d->prev_val[0]);
1502 oprintf (d->of, "(%s)", d->prev_val[1]);
1506 const char *pp = d->val + strlen (d->val);
1507 while (pp[-1] == ']')
1510 oprintf (d->of, "%s", pp);
1514 error_at_line (d->line, "`%s' option contains bad escape %c%c",
1519 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
1520 which is of type T. Write code to D->OF to constrain execution (at
1521 the point that D->PROCESS_FIELD is called) to the appropriate
1522 cases. Call D->PROCESS_FIELD on subobjects before calling it on
1523 pointers to those objects. D->PREV_VAL lists the objects
1524 containing the current object, D->OPT is a list of options to
1525 apply, D->INDENT is the current indentation level, D->LINE is used
1526 to print error messages, D->BITMAP indicates which languages to
1527 print the structure for, and D->PARAM is the current parameter
1528 (from an enclosing param_is option). */
1531 walk_type (type_p t, struct walk_type_data *d)
1533 const char *length = NULL;
1534 const char *desc = NULL;
1535 int maybe_undef_p = 0;
1536 int use_param_num = -1;
1537 int use_params_p = 0;
1539 const struct nested_ptr_data *nested_ptr_d = NULL;
1541 d->needs_cast_p = false;
1542 for (oo = d->opt; oo; oo = oo->next)
1543 if (strcmp (oo->name, "length") == 0)
1545 else if (strcmp (oo->name, "maybe_undef") == 0)
1547 else if (strncmp (oo->name, "use_param", 9) == 0
1548 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
1549 use_param_num = oo->name[9] == '\0' ? 0 : oo->name[9] - '0';
1550 else if (strcmp (oo->name, "use_params") == 0)
1552 else if (strcmp (oo->name, "desc") == 0)
1554 else if (strcmp (oo->name, "mark_hook") == 0)
1556 else if (strcmp (oo->name, "nested_ptr") == 0)
1557 nested_ptr_d = (const struct nested_ptr_data *) oo->info;
1558 else if (strcmp (oo->name, "dot") == 0)
1560 else if (strcmp (oo->name, "tag") == 0)
1562 else if (strcmp (oo->name, "special") == 0)
1564 else if (strcmp (oo->name, "skip") == 0)
1566 else if (strcmp (oo->name, "default") == 0)
1568 else if (strcmp (oo->name, "descbits") == 0)
1570 else if (strcmp (oo->name, "param_is") == 0)
1572 else if (strncmp (oo->name, "param", 5) == 0
1573 && ISDIGIT (oo->name[5])
1574 && strcmp (oo->name + 6, "_is") == 0)
1576 else if (strcmp (oo->name, "chain_next") == 0)
1578 else if (strcmp (oo->name, "chain_prev") == 0)
1580 else if (strcmp (oo->name, "reorder") == 0)
1583 error_at_line (d->line, "unknown option `%s'\n", oo->name);
1590 int pointer_p = t->kind == TYPE_POINTER;
1594 if (! UNION_OR_STRUCT_P (t))
1595 error_at_line (d->line, "`use_params' option on unimplemented type");
1597 t = find_param_structure (t, d->param);
1599 t = create_pointer (t);
1602 if (use_param_num != -1)
1604 if (d->param != NULL && d->param[use_param_num] != NULL)
1606 type_p nt = d->param[use_param_num];
1608 if (t->kind == TYPE_ARRAY)
1609 nt = create_array (nt, t->u.a.len);
1610 else if (length != NULL && t->kind == TYPE_POINTER)
1611 nt = create_pointer (nt);
1612 d->needs_cast_p = (t->kind != TYPE_POINTER
1613 && (nt->kind == TYPE_POINTER
1614 || nt->kind == TYPE_STRING));
1618 error_at_line (d->line, "no parameter defined for `%s'",
1623 && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p)))
1625 error_at_line (d->line,
1626 "field `%s' has invalid option `maybe_undef_p'\n",
1635 d->process_field (t, d);
1641 && t->u.p->u.s.line.file == NULL)
1643 oprintf (d->of, "%*sgcc_assert (!%s);\n", d->indent, "", d->val);
1649 if (! UNION_OR_STRUCT_P (t->u.p)
1650 && t->u.p->kind != TYPE_PARAM_STRUCT)
1652 error_at_line (d->line,
1653 "field `%s' is pointer to unimplemented type",
1660 const char *oldprevval2 = d->prev_val[2];
1662 if (! UNION_OR_STRUCT_P (nested_ptr_d->type))
1664 error_at_line (d->line,
1665 "field `%s' has invalid "
1666 "option `nested_ptr'\n",
1671 d->prev_val[2] = d->val;
1672 oprintf (d->of, "%*s{\n", d->indent, "");
1674 d->val = xasprintf ("x%d", d->counter++);
1675 oprintf (d->of, "%*s%s %s * %s%s =\n", d->indent, "",
1676 (nested_ptr_d->type->kind == TYPE_UNION
1677 ? "union" : "struct"),
1678 nested_ptr_d->type->u.s.tag,
1679 d->fn_wants_lvalue ? "" : "const ",
1681 oprintf (d->of, "%*s", d->indent + 2, "");
1682 output_escaped_param (d, nested_ptr_d->convert_from,
1684 oprintf (d->of, ";\n");
1686 d->process_field (nested_ptr_d->type, d);
1688 if (d->fn_wants_lvalue)
1690 oprintf (d->of, "%*s%s = ", d->indent, "",
1692 d->prev_val[2] = d->val;
1693 output_escaped_param (d, nested_ptr_d->convert_to,
1695 oprintf (d->of, ";\n");
1699 oprintf (d->of, "%*s}\n", d->indent, "");
1700 d->val = d->prev_val[2];
1701 d->prev_val[2] = oldprevval2;
1704 d->process_field (t->u.p, d);
1708 int loopcounter = d->counter++;
1709 const char *oldval = d->val;
1710 const char *oldprevval3 = d->prev_val[3];
1713 oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val);
1715 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
1716 oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent, "",
1717 loopcounter, loopcounter);
1718 output_escaped_param (d, length, "length");
1719 oprintf (d->of, "); i%d++) {\n", loopcounter);
1721 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
1723 d->prev_val[3] = oldval;
1724 walk_type (t->u.p, d);
1727 d->prev_val[3] = oldprevval3;
1730 oprintf (d->of, "%*s}\n", d->indent, "");
1731 d->process_field(t, d);
1733 oprintf (d->of, "%*s}\n", d->indent, "");
1740 int loopcounter = d->counter++;
1741 const char *oldval = d->val;
1744 /* If it's an array of scalars, we optimize by not generating
1746 if (t->u.a.p->kind == TYPE_SCALAR)
1749 oprintf (d->of, "%*s{\n", d->indent, "");
1751 oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
1752 oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent, "",
1753 loopcounter, loopcounter);
1755 output_escaped_param (d, length, "length");
1757 oprintf (d->of, "%s", t->u.a.len);
1758 oprintf (d->of, "); i%d++) {\n", loopcounter);
1760 d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
1762 walk_type (t->u.a.p, d);
1767 oprintf (d->of, "%*s}\n", d->indent, "");
1769 oprintf (d->of, "%*s}\n", d->indent, "");
1777 const char *oldval = d->val;
1778 const char *oldprevval1 = d->prev_val[1];
1779 const char *oldprevval2 = d->prev_val[2];
1780 const int union_p = t->kind == TYPE_UNION;
1781 int seen_default_p = 0;
1784 if (! t->u.s.line.file)
1785 error_at_line (d->line, "incomplete structure `%s'", t->u.s.tag);
1787 if ((d->bitmap & t->u.s.bitmap) != d->bitmap)
1789 error_at_line (d->line,
1790 "structure `%s' defined for mismatching languages",
1792 error_at_line (&t->u.s.line, "one structure defined here");
1795 /* Some things may also be defined in the structure's options. */
1796 for (o = t->u.s.opt; o; o = o->next)
1797 if (! desc && strcmp (o->name, "desc") == 0)
1800 d->prev_val[2] = oldval;
1801 d->prev_val[1] = oldprevval2;
1806 error_at_line (d->line, "missing `desc' option for union `%s'",
1810 oprintf (d->of, "%*sswitch (", d->indent, "");
1811 output_escaped_param (d, desc, "desc");
1812 oprintf (d->of, ")\n");
1814 oprintf (d->of, "%*s{\n", d->indent, "");
1816 for (f = t->u.s.fields; f; f = f->next)
1819 const char *dot = ".";
1820 const char *tagid = NULL;
1823 int use_param_p = 0;
1826 d->reorder_fn = NULL;
1827 for (oo = f->opt; oo; oo = oo->next)
1828 if (strcmp (oo->name, "dot") == 0)
1830 else if (strcmp (oo->name, "tag") == 0)
1832 else if (strcmp (oo->name, "skip") == 0)
1834 else if (strcmp (oo->name, "default") == 0)
1836 else if (strcmp (oo->name, "reorder") == 0)
1837 d->reorder_fn = oo->info;
1838 else if (strncmp (oo->name, "use_param", 9) == 0
1839 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
1845 if (union_p && tagid)
1847 oprintf (d->of, "%*scase %s:\n", d->indent, "", tagid);
1850 else if (union_p && default_p)
1852 oprintf (d->of, "%*sdefault:\n", d->indent, "");
1856 else if (! union_p && (default_p || tagid))
1857 error_at_line (d->line,
1858 "can't use `%s' outside a union on field `%s'",
1859 default_p ? "default" : "tag", f->name);
1860 else if (union_p && ! (default_p || tagid)
1861 && f->type->kind == TYPE_SCALAR)
1864 "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
1865 d->line->file, d->line->line, f->name);
1868 else if (union_p && ! (default_p || tagid))
1869 error_at_line (d->line,
1870 "field `%s' is missing `tag' or `default' option",
1874 d->val = newval = xasprintf ("%s%s%s", oldval, dot, f->name);
1876 d->used_length = false;
1878 if (union_p && use_param_p && d->param == NULL)
1879 oprintf (d->of, "%*sgcc_unreachable ();\n", d->indent, "");
1881 walk_type (f->type, d);
1887 oprintf (d->of, "%*sbreak;\n", d->indent, "");
1891 d->reorder_fn = NULL;
1894 d->prev_val[1] = oldprevval1;
1895 d->prev_val[2] = oldprevval2;
1897 if (union_p && ! seen_default_p)
1899 oprintf (d->of, "%*sdefault:\n", d->indent, "");
1900 oprintf (d->of, "%*s break;\n", d->indent, "");
1904 oprintf (d->of, "%*s}\n", d->indent, "");
1910 case TYPE_LANG_STRUCT:
1913 for (nt = t->u.s.lang_struct; nt; nt = nt->next)
1914 if ((d->bitmap & nt->u.s.bitmap) == d->bitmap)
1917 error_at_line (d->line, "structure `%s' differs between languages",
1924 case TYPE_PARAM_STRUCT:
1926 type_p *oldparam = d->param;
1928 d->param = t->u.param_struct.param;
1929 walk_type (t->u.param_struct.stru, d);
1930 d->param = oldparam;
1939 /* process_field routine for marking routines. */
1942 write_types_process_field (type_p f, const struct walk_type_data *d)
1944 const struct write_types_data *wtd;
1945 const char *cast = d->needs_cast_p ? "(void *)" : "";
1946 wtd = (const struct write_types_data *) d->cookie;
1951 oprintf (d->of, "%*s%s (%s%s", d->indent, "",
1952 wtd->subfield_marker_routine, cast, d->val);
1953 if (wtd->param_prefix)
1955 oprintf (d->of, ", %s", d->prev_val[3]);
1958 oprintf (d->of, ", gt_%s_", wtd->param_prefix);
1959 output_mangled_typename (d->of, d->orig_s);
1962 oprintf (d->of, ", gt_%sa_%s", wtd->param_prefix, d->prev_val[0]);
1964 if (f->u.p->kind == TYPE_PARAM_STRUCT
1965 && f->u.p->u.s.line.file != NULL)
1967 oprintf (d->of, ", gt_e_");
1968 output_mangled_typename (d->of, f);
1970 else if (UNION_OR_STRUCT_P (f)
1971 && f->u.p->u.s.line.file != NULL)
1973 oprintf (d->of, ", gt_ggc_e_");
1974 output_mangled_typename (d->of, f);
1977 oprintf (d->of, ", gt_types_enum_last");
1979 oprintf (d->of, ");\n");
1980 if (d->reorder_fn && wtd->reorder_note_routine)
1981 oprintf (d->of, "%*s%s (%s%s, %s, %s);\n", d->indent, "",
1982 wtd->reorder_note_routine, cast, d->val,
1983 d->prev_val[3], d->reorder_fn);
1987 if (wtd->param_prefix == NULL)
1992 case TYPE_LANG_STRUCT:
1993 case TYPE_PARAM_STRUCT:
1994 oprintf (d->of, "%*sgt_%s_", d->indent, "", wtd->prefix);
1995 output_mangled_typename (d->of, f);
1996 oprintf (d->of, " (%s%s);\n", cast, d->val);
1997 if (d->reorder_fn && wtd->reorder_note_routine)
1998 oprintf (d->of, "%*s%s (%s%s, %s%s, %s);\n", d->indent, "",
1999 wtd->reorder_note_routine, cast, d->val, cast, d->val,
2011 /* A subroutine of write_func_for_structure. Write the enum tag for S. */
2014 output_type_enum (outf_p of, type_p s)
2016 if (s->kind == TYPE_PARAM_STRUCT && s->u.s.line.file != NULL)
2018 oprintf (of, ", gt_e_");
2019 output_mangled_typename (of, s);
2021 else if (UNION_OR_STRUCT_P (s) && s->u.s.line.file != NULL)
2023 oprintf (of, ", gt_ggc_e_");
2024 output_mangled_typename (of, s);
2027 oprintf (of, ", gt_types_enum_last");
2030 /* For S, a structure that's part of ORIG_S, and using parameters
2031 PARAM, write out a routine that:
2032 - Takes a parameter, a void * but actually of type *S
2033 - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2034 field of S or its substructures and (in some cases) things
2035 that are pointed to by S.
2039 write_func_for_structure (type_p orig_s, type_p s, type_p *param,
2040 const struct write_types_data *wtd)
2042 const char *fn = s->u.s.line.file;
2044 const char *chain_next = NULL;
2045 const char *chain_prev = NULL;
2046 const char *mark_hook_name = NULL;
2048 struct walk_type_data d;
2050 /* This is a hack, and not the good kind either. */
2051 for (i = NUM_PARAM - 1; i >= 0; i--)
2052 if (param && param[i] && param[i]->kind == TYPE_POINTER
2053 && UNION_OR_STRUCT_P (param[i]->u.p))
2054 fn = param[i]->u.p->u.s.line.file;
2056 memset (&d, 0, sizeof (d));
2057 d.of = get_output_file_with_visibility (fn);
2059 for (opt = s->u.s.opt; opt; opt = opt->next)
2060 if (strcmp (opt->name, "chain_next") == 0)
2061 chain_next = opt->info;
2062 else if (strcmp (opt->name, "chain_prev") == 0)
2063 chain_prev = opt->info;
2064 else if (strcmp (opt->name, "mark_hook") == 0)
2065 mark_hook_name = opt->info;
2067 if (chain_prev != NULL && chain_next == NULL)
2068 error_at_line (&s->u.s.line, "chain_prev without chain_next");
2070 d.process_field = write_types_process_field;
2074 d.line = &s->u.s.line;
2075 d.bitmap = s->u.s.bitmap;
2077 d.prev_val[0] = "*x";
2078 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
2079 d.prev_val[3] = "x";
2082 oprintf (d.of, "\n");
2083 oprintf (d.of, "void\n");
2085 oprintf (d.of, "gt_%sx_%s", wtd->prefix, orig_s->u.s.tag);
2088 oprintf (d.of, "gt_%s_", wtd->prefix);
2089 output_mangled_typename (d.of, orig_s);
2091 oprintf (d.of, " (void *x_p)\n");
2092 oprintf (d.of, "{\n");
2093 oprintf (d.of, " %s %s * %sx = (%s %s *)x_p;\n",
2094 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag,
2095 chain_next == NULL ? "const " : "",
2096 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2097 if (chain_next != NULL)
2098 oprintf (d.of, " %s %s * xlimit = x;\n",
2099 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2100 if (chain_next == NULL)
2102 oprintf (d.of, " if (%s (x", wtd->marker_routine);
2103 if (wtd->param_prefix)
2105 oprintf (d.of, ", x, gt_%s_", wtd->param_prefix);
2106 output_mangled_typename (d.of, orig_s);
2107 output_type_enum (d.of, orig_s);
2109 oprintf (d.of, "))\n");
2113 oprintf (d.of, " while (%s (xlimit", wtd->marker_routine);
2114 if (wtd->param_prefix)
2116 oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix);
2117 output_mangled_typename (d.of, orig_s);
2118 output_type_enum (d.of, orig_s);
2120 oprintf (d.of, "))\n");
2121 if (mark_hook_name && !wtd->skip_hooks)
2123 oprintf (d.of, " {\n");
2124 oprintf (d.of, " %s (xlimit);\n ", mark_hook_name);
2126 oprintf (d.of, " xlimit = (");
2127 d.prev_val[2] = "*xlimit";
2128 output_escaped_param (&d, chain_next, "chain_next");
2129 oprintf (d.of, ");\n");
2130 if (mark_hook_name && !wtd->skip_hooks)
2131 oprintf (d.of, " }\n");
2132 if (chain_prev != NULL)
2134 oprintf (d.of, " if (x != xlimit)\n");
2135 oprintf (d.of, " for (;;)\n");
2136 oprintf (d.of, " {\n");
2137 oprintf (d.of, " %s %s * const xprev = (",
2138 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2140 d.prev_val[2] = "*x";
2141 output_escaped_param (&d, chain_prev, "chain_prev");
2142 oprintf (d.of, ");\n");
2143 oprintf (d.of, " if (xprev == NULL) break;\n");
2144 oprintf (d.of, " x = xprev;\n");
2145 oprintf (d.of, " (void) %s (xprev",
2146 wtd->marker_routine);
2147 if (wtd->param_prefix)
2149 oprintf (d.of, ", xprev, gt_%s_", wtd->param_prefix);
2150 output_mangled_typename (d.of, orig_s);
2151 output_type_enum (d.of, orig_s);
2153 oprintf (d.of, ");\n");
2154 oprintf (d.of, " }\n");
2156 oprintf (d.of, " while (x != xlimit)\n");
2158 oprintf (d.of, " {\n");
2159 if (mark_hook_name && chain_next == NULL && !wtd->skip_hooks)
2161 oprintf (d.of, " %s (x);\n", mark_hook_name);
2163 d.prev_val[2] = "*x";
2167 if (chain_next != NULL)
2169 oprintf (d.of, " x = (");
2170 output_escaped_param (&d, chain_next, "chain_next");
2171 oprintf (d.of, ");\n");
2174 oprintf (d.of, " }\n");
2175 oprintf (d.of, "}\n");
2178 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
2181 write_types (type_p structures, type_p param_structs,
2182 const struct write_types_data *wtd)
2186 oprintf (header_file, "\n/* %s*/\n", wtd->comment);
2187 for (s = structures; s; s = s->next)
2188 if (s->gc_used == GC_POINTED_TO
2189 || s->gc_used == GC_MAYBE_POINTED_TO)
2193 if (s->gc_used == GC_MAYBE_POINTED_TO
2194 && s->u.s.line.file == NULL)
2197 oprintf (header_file, "#define gt_%s_", wtd->prefix);
2198 output_mangled_typename (header_file, s);
2199 oprintf (header_file, "(X) do { \\\n");
2200 oprintf (header_file,
2201 " if (X != NULL) gt_%sx_%s (X);\\\n", wtd->prefix,
2203 oprintf (header_file,
2206 for (opt = s->u.s.opt; opt; opt = opt->next)
2207 if (strcmp (opt->name, "ptr_alias") == 0)
2209 type_p t = (type_p) opt->info;
2210 if (t->kind == TYPE_STRUCT
2211 || t->kind == TYPE_UNION
2212 || t->kind == TYPE_LANG_STRUCT)
2213 oprintf (header_file,
2214 "#define gt_%sx_%s gt_%sx_%s\n",
2215 wtd->prefix, s->u.s.tag, wtd->prefix, t->u.s.tag);
2217 error_at_line (&s->u.s.line,
2218 "structure alias is not a structure");
2224 /* Declare the marker procedure only once. */
2225 oprintf (header_file,
2226 "extern void gt_%sx_%s (void *);\n",
2227 wtd->prefix, s->u.s.tag);
2229 if (s->u.s.line.file == NULL)
2231 fprintf (stderr, "warning: structure `%s' used but not defined\n",
2236 if (s->kind == TYPE_LANG_STRUCT)
2239 for (ss = s->u.s.lang_struct; ss; ss = ss->next)
2240 write_func_for_structure (s, ss, NULL, wtd);
2243 write_func_for_structure (s, s, NULL, wtd);
2246 for (s = param_structs; s; s = s->next)
2247 if (s->gc_used == GC_POINTED_TO)
2249 type_p * param = s->u.param_struct.param;
2250 type_p stru = s->u.param_struct.stru;
2252 /* Declare the marker procedure. */
2253 oprintf (header_file, "extern void gt_%s_", wtd->prefix);
2254 output_mangled_typename (header_file, s);
2255 oprintf (header_file, " (void *);\n");
2257 if (stru->u.s.line.file == NULL)
2259 fprintf (stderr, "warning: structure `%s' used but not defined\n",
2264 if (stru->kind == TYPE_LANG_STRUCT)
2267 for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
2268 write_func_for_structure (s, ss, param, wtd);
2271 write_func_for_structure (s, stru, param, wtd);
2275 static const struct write_types_data ggc_wtd =
2277 "ggc_m", NULL, "ggc_mark", "ggc_test_and_set_mark", NULL,
2278 "GC marker procedures. ",
2282 static const struct write_types_data pch_wtd =
2284 "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
2285 "gt_pch_note_reorder",
2286 "PCH type-walking procedures. ",
2290 /* Write out the local pointer-walking routines. */
2292 /* process_field routine for local pointer-walking. */
2295 write_types_local_process_field (type_p f, const struct walk_type_data *d)
2302 case TYPE_LANG_STRUCT:
2303 case TYPE_PARAM_STRUCT:
2305 oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "",
2307 oprintf (d->of, "%*s op (&(%s), cookie);\n", d->indent, "", d->val);
2318 /* For S, a structure that's part of ORIG_S, and using parameters
2319 PARAM, write out a routine that:
2320 - Is of type gt_note_pointers
2321 - Calls PROCESS_FIELD on each field of S or its substructures.
2325 write_local_func_for_structure (type_p orig_s, type_p s, type_p *param)
2327 const char *fn = s->u.s.line.file;
2329 struct walk_type_data d;
2331 /* This is a hack, and not the good kind either. */
2332 for (i = NUM_PARAM - 1; i >= 0; i--)
2333 if (param && param[i] && param[i]->kind == TYPE_POINTER
2334 && UNION_OR_STRUCT_P (param[i]->u.p))
2335 fn = param[i]->u.p->u.s.line.file;
2337 memset (&d, 0, sizeof (d));
2338 d.of = get_output_file_with_visibility (fn);
2340 d.process_field = write_types_local_process_field;
2342 d.line = &s->u.s.line;
2343 d.bitmap = s->u.s.bitmap;
2345 d.prev_val[0] = d.prev_val[2] = "*x";
2346 d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
2347 d.prev_val[3] = "x";
2349 d.fn_wants_lvalue = true;
2351 oprintf (d.of, "\n");
2352 oprintf (d.of, "void\n");
2353 oprintf (d.of, "gt_pch_p_");
2354 output_mangled_typename (d.of, orig_s);
2355 oprintf (d.of, " (ATTRIBUTE_UNUSED void *this_obj,\n"
2357 "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2358 "\tATTRIBUTE_UNUSED void *cookie)\n");
2359 oprintf (d.of, "{\n");
2360 oprintf (d.of, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
2361 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag,
2362 s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2365 oprintf (d.of, "}\n");
2368 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
2371 write_local (type_p structures, type_p param_structs)
2375 oprintf (header_file, "\n/* Local pointer-walking routines. */\n");
2376 for (s = structures; s; s = s->next)
2377 if (s->gc_used == GC_POINTED_TO
2378 || s->gc_used == GC_MAYBE_POINTED_TO)
2382 if (s->u.s.line.file == NULL)
2385 for (opt = s->u.s.opt; opt; opt = opt->next)
2386 if (strcmp (opt->name, "ptr_alias") == 0)
2388 type_p t = (type_p) opt->info;
2389 if (t->kind == TYPE_STRUCT
2390 || t->kind == TYPE_UNION
2391 || t->kind == TYPE_LANG_STRUCT)
2393 oprintf (header_file, "#define gt_pch_p_");
2394 output_mangled_typename (header_file, s);
2395 oprintf (header_file, " gt_pch_p_");
2396 output_mangled_typename (header_file, t);
2397 oprintf (header_file, "\n");
2400 error_at_line (&s->u.s.line,
2401 "structure alias is not a structure");
2407 /* Declare the marker procedure only once. */
2408 oprintf (header_file, "extern void gt_pch_p_");
2409 output_mangled_typename (header_file, s);
2410 oprintf (header_file,
2411 "\n (void *, void *, gt_pointer_operator, void *);\n");
2413 if (s->kind == TYPE_LANG_STRUCT)
2416 for (ss = s->u.s.lang_struct; ss; ss = ss->next)
2417 write_local_func_for_structure (s, ss, NULL);
2420 write_local_func_for_structure (s, s, NULL);
2423 for (s = param_structs; s; s = s->next)
2424 if (s->gc_used == GC_POINTED_TO)
2426 type_p * param = s->u.param_struct.param;
2427 type_p stru = s->u.param_struct.stru;
2429 /* Declare the marker procedure. */
2430 oprintf (header_file, "extern void gt_pch_p_");
2431 output_mangled_typename (header_file, s);
2432 oprintf (header_file,
2433 "\n (void *, void *, gt_pointer_operator, void *);\n");
2435 if (stru->u.s.line.file == NULL)
2437 fprintf (stderr, "warning: structure `%s' used but not defined\n",
2442 if (stru->kind == TYPE_LANG_STRUCT)
2445 for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
2446 write_local_func_for_structure (s, ss, param);
2449 write_local_func_for_structure (s, stru, param);
2453 /* Write out the 'enum' definition for gt_types_enum. */
2456 write_enum_defn (type_p structures, type_p param_structs)
2460 oprintf (header_file, "\n/* Enumeration of types known. */\n");
2461 oprintf (header_file, "enum gt_types_enum {\n");
2462 for (s = structures; s; s = s->next)
2463 if (s->gc_used == GC_POINTED_TO
2464 || s->gc_used == GC_MAYBE_POINTED_TO)
2466 if (s->gc_used == GC_MAYBE_POINTED_TO
2467 && s->u.s.line.file == NULL)
2470 oprintf (header_file, " gt_ggc_e_");
2471 output_mangled_typename (header_file, s);
2472 oprintf (header_file, ", \n");
2474 for (s = param_structs; s; s = s->next)
2475 if (s->gc_used == GC_POINTED_TO)
2477 oprintf (header_file, " gt_e_");
2478 output_mangled_typename (header_file, s);
2479 oprintf (header_file, ", \n");
2481 oprintf (header_file, " gt_types_enum_last\n");
2482 oprintf (header_file, "};\n");
2485 /* Might T contain any non-pointer elements? */
2488 contains_scalar_p (type_p t)
2496 return contains_scalar_p (t->u.a.p);
2498 /* Could also check for structures that have no non-pointer
2499 fields, but there aren't enough of those to worry about. */
2504 /* Mangle FN and print it to F. */
2507 put_mangled_filename (outf_p f, const char *fn)
2509 const char *name = get_output_file_name (fn);
2510 for (; *name != 0; name++)
2511 if (ISALNUM (*name))
2512 oprintf (f, "%c", *name);
2514 oprintf (f, "%c", '_');
2517 /* Finish off the currently-created root tables in FLP. PFX, TNAME,
2518 LASTNAME, and NAME are all strings to insert in various places in
2519 the resulting code. */
2522 finish_root_table (struct flist *flp, const char *pfx, const char *lastname,
2523 const char *tname, const char *name)
2527 for (fli2 = flp; fli2; fli2 = fli2->next)
2528 if (fli2->started_p)
2530 oprintf (fli2->f, " %s\n", lastname);
2531 oprintf (fli2->f, "};\n\n");
2534 for (fli2 = flp; fli2; fli2 = fli2->next)
2535 if (fli2->started_p)
2537 lang_bitmap bitmap = get_base_file_bitmap (fli2->name);
2540 for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1)
2543 oprintf (base_files[fnum],
2544 "extern const struct %s gt_%s_",
2546 put_mangled_filename (base_files[fnum], fli2->name);
2547 oprintf (base_files[fnum], "[];\n");
2553 for (fnum = 0; fnum < NUM_BASE_FILES; fnum++)
2554 oprintf (base_files [fnum],
2555 "const struct %s * const %s[] = {\n",
2560 for (fli2 = flp; fli2; fli2 = fli2->next)
2561 if (fli2->started_p)
2563 lang_bitmap bitmap = get_base_file_bitmap (fli2->name);
2566 fli2->started_p = 0;
2568 for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1)
2571 oprintf (base_files[fnum], " gt_%s_", pfx);
2572 put_mangled_filename (base_files[fnum], fli2->name);
2573 oprintf (base_files[fnum], ",\n");
2579 for (fnum = 0; fnum < NUM_BASE_FILES; fnum++)
2581 oprintf (base_files[fnum], " NULL\n");
2582 oprintf (base_files[fnum], "};\n");
2587 /* Write out to F the table entry and any marker routines needed to
2588 mark NAME as TYPE. The original variable is V, at LINE.
2589 HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
2590 is nonzero iff we are building the root table for hash table caches. */
2593 write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
2594 struct fileloc *line, const char *if_marked)
2601 for (fld = type->u.s.fields; fld; fld = fld->next)
2604 const char *desc = NULL;
2607 for (o = fld->opt; o; o = o->next)
2608 if (strcmp (o->name, "skip") == 0)
2610 else if (strcmp (o->name, "desc") == 0)
2613 error_at_line (line,
2614 "field `%s' of global `%s' has unknown option `%s'",
2615 fld->name, name, o->name);
2619 else if (desc && fld->type->kind == TYPE_UNION)
2621 pair_p validf = NULL;
2624 for (ufld = fld->type->u.s.fields; ufld; ufld = ufld->next)
2626 const char *tag = NULL;
2629 for (oo = ufld->opt; oo; oo = oo->next)
2630 if (strcmp (oo->name, "tag") == 0)
2632 if (tag == NULL || strcmp (tag, desc) != 0)
2635 error_at_line (line,
2636 "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
2637 name, fld->name, validf->name,
2638 name, fld->name, ufld->name,
2645 newname = xasprintf ("%s.%s.%s",
2646 name, fld->name, validf->name);
2647 write_root (f, v, validf->type, newname, 0, line,
2653 error_at_line (line,
2654 "global `%s.%s' has `desc' option but is not union",
2659 newname = xasprintf ("%s.%s", name, fld->name);
2660 write_root (f, v, fld->type, newname, 0, line, if_marked);
2670 newname = xasprintf ("%s[0]", name);
2671 write_root (f, v, type->u.a.p, newname, has_length, line, if_marked);
2680 oprintf (f, " {\n");
2681 oprintf (f, " &%s,\n", name);
2684 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
2686 oprintf (f, " * (%s)", ap->u.a.len);
2687 else if (ap == v->type)
2688 oprintf (f, " * ARRAY_SIZE (%s)", v->name);
2690 oprintf (f, " sizeof (%s", v->name);
2691 for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
2693 oprintf (f, "),\n");
2697 if (! has_length && UNION_OR_STRUCT_P (tp))
2699 oprintf (f, " >_ggc_mx_%s,\n", tp->u.s.tag);
2700 oprintf (f, " >_pch_nx_%s", tp->u.s.tag);
2702 else if (! has_length && tp->kind == TYPE_PARAM_STRUCT)
2704 oprintf (f, " >_ggc_m_");
2705 output_mangled_typename (f, tp);
2706 oprintf (f, ",\n >_pch_n_");
2707 output_mangled_typename (f, tp);
2710 && (tp->kind == TYPE_POINTER || UNION_OR_STRUCT_P (tp)))
2712 oprintf (f, " >_ggc_ma_%s,\n", name);
2713 oprintf (f, " >_pch_na_%s", name);
2717 error_at_line (line,
2718 "global `%s' is pointer to unimplemented type",
2722 oprintf (f, ",\n &%s", if_marked);
2723 oprintf (f, "\n },\n");
2729 oprintf (f, " {\n");
2730 oprintf (f, " &%s,\n", name);
2731 oprintf (f, " 1, \n");
2732 oprintf (f, " sizeof (%s),\n", v->name);
2733 oprintf (f, " >_ggc_m_S,\n");
2734 oprintf (f, " (gt_pointer_walker) >_pch_n_S\n");
2735 oprintf (f, " },\n");
2743 error_at_line (line,
2744 "global `%s' is unimplemented type",
2749 /* This generates a routine to walk an array. */
2752 write_array (outf_p f, pair_p v, const struct write_types_data *wtd)
2754 struct walk_type_data d;
2757 memset (&d, 0, sizeof (d));
2763 d.bitmap = get_base_file_bitmap (v->line.file);
2766 d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name);
2768 if (wtd->param_prefix)
2770 oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name);
2772 " (void *, void *, gt_pointer_operator, void *);\n");
2773 oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
2774 wtd->param_prefix, v->name);
2776 " ATTRIBUTE_UNUSED void *x_p,\n"
2777 " ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
2778 " ATTRIBUTE_UNUSED void * cookie)\n");
2779 oprintf (d.of, "{\n");
2780 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
2781 d.process_field = write_types_local_process_field;
2782 walk_type (v->type, &d);
2783 oprintf (f, "}\n\n");
2787 oprintf (f, "static void gt_%sa_%s (void *);\n",
2788 wtd->prefix, v->name);
2789 oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
2790 wtd->prefix, v->name);
2792 d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
2793 d.process_field = write_types_process_field;
2794 walk_type (v->type, &d);
2796 oprintf (f, "}\n\n");
2799 /* Output a table describing the locations and types of VARIABLES. */
2802 write_roots (pair_p variables)
2805 struct flist *flp = NULL;
2807 for (v = variables; v; v = v->next)
2809 outf_p f = get_output_file_with_visibility (v->line.file);
2811 const char *length = NULL;
2812 int deletable_p = 0;
2815 for (o = v->opt; o; o = o->next)
2816 if (strcmp (o->name, "length") == 0)
2818 else if (strcmp (o->name, "deletable") == 0)
2820 else if (strcmp (o->name, "param_is") == 0)
2822 else if (strncmp (o->name, "param", 5) == 0
2823 && ISDIGIT (o->name[5])
2824 && strcmp (o->name + 6, "_is") == 0)
2826 else if (strcmp (o->name, "if_marked") == 0)
2829 error_at_line (&v->line,
2830 "global `%s' has unknown option `%s'",
2833 for (fli = flp; fli; fli = fli->next)
2838 fli = XNEW (struct flist);
2842 fli->name = v->line.file;
2845 oprintf (f, "\n/* GC roots. */\n\n");
2850 && v->type->kind == TYPE_POINTER
2851 && (v->type->u.p->kind == TYPE_POINTER
2852 || v->type->u.p->kind == TYPE_STRUCT))
2854 write_array (f, v, &ggc_wtd);
2855 write_array (f, v, &pch_wtd);
2859 for (v = variables; v; v = v->next)
2861 outf_p f = get_output_file_with_visibility (v->line.file);
2867 for (o = v->opt; o; o = o->next)
2868 if (strcmp (o->name, "length") == 0)
2870 else if (strcmp (o->name, "deletable") == 0
2871 || strcmp (o->name, "if_marked") == 0)
2877 for (fli = flp; fli; fli = fli->next)
2880 if (! fli->started_p)
2884 oprintf (f, "const struct ggc_root_tab gt_ggc_r_");
2885 put_mangled_filename (f, v->line.file);
2886 oprintf (f, "[] = {\n");
2889 write_root (f, v, v->type, v->name, length_p, &v->line, NULL);
2892 finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
2895 for (v = variables; v; v = v->next)
2897 outf_p f = get_output_file_with_visibility (v->line.file);
2902 for (o = v->opt; o; o = o->next)
2903 if (strcmp (o->name, "deletable") == 0)
2905 else if (strcmp (o->name, "if_marked") == 0)
2911 for (fli = flp; fli; fli = fli->next)
2914 if (! fli->started_p)
2918 oprintf (f, "const struct ggc_root_tab gt_ggc_rd_");
2919 put_mangled_filename (f, v->line.file);
2920 oprintf (f, "[] = {\n");
2923 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
2927 finish_root_table (flp, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
2928 "gt_ggc_deletable_rtab");
2930 for (v = variables; v; v = v->next)
2932 outf_p f = get_output_file_with_visibility (v->line.file);
2934 const char *if_marked = NULL;
2938 for (o = v->opt; o; o = o->next)
2939 if (strcmp (o->name, "length") == 0)
2941 else if (strcmp (o->name, "if_marked") == 0)
2942 if_marked = o->info;
2944 if (if_marked == NULL)
2947 if (v->type->kind != TYPE_POINTER
2948 || v->type->u.p->kind != TYPE_PARAM_STRUCT
2949 || v->type->u.p->u.param_struct.stru != find_structure ("htab", 0))
2951 error_at_line (&v->line, "if_marked option used but not hash table");
2955 for (fli = flp; fli; fli = fli->next)
2958 if (! fli->started_p)
2962 oprintf (f, "const struct ggc_cache_tab gt_ggc_rc_");
2963 put_mangled_filename (f, v->line.file);
2964 oprintf (f, "[] = {\n");
2967 write_root (f, v, v->type->u.p->u.param_struct.param[0],
2968 v->name, length_p, &v->line, if_marked);
2971 finish_root_table (flp, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
2972 "gt_ggc_cache_rtab");
2974 for (v = variables; v; v = v->next)
2976 outf_p f = get_output_file_with_visibility (v->line.file);
2979 int if_marked_p = 0;
2982 for (o = v->opt; o; o = o->next)
2983 if (strcmp (o->name, "length") == 0)
2985 else if (strcmp (o->name, "if_marked") == 0)
2991 for (fli = flp; fli; fli = fli->next)
2994 if (! fli->started_p)
2998 oprintf (f, "const struct ggc_root_tab gt_pch_rc_");
2999 put_mangled_filename (f, v->line.file);
3000 oprintf (f, "[] = {\n");
3003 write_root (f, v, v->type, v->name, length_p, &v->line, NULL);
3006 finish_root_table (flp, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3007 "gt_pch_cache_rtab");
3009 for (v = variables; v; v = v->next)
3011 outf_p f = get_output_file_with_visibility (v->line.file);
3016 for (o = v->opt; o; o = o->next)
3017 if (strcmp (o->name, "deletable") == 0
3018 || strcmp (o->name, "if_marked") == 0)
3024 if (! contains_scalar_p (v->type))
3027 for (fli = flp; fli; fli = fli->next)
3030 if (! fli->started_p)
3034 oprintf (f, "const struct ggc_root_tab gt_pch_rs_");
3035 put_mangled_filename (f, v->line.file);
3036 oprintf (f, "[] = {\n");
3039 oprintf (f, " { &%s, 1, sizeof (%s), NULL, NULL },\n",
3043 finish_root_table (flp, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3044 "gt_pch_scalar_rtab");
3048 extern int main (int argc, char **argv);
3050 main (int ARG_UNUSED (argc), char ** ARG_UNUSED (argv))
3053 static struct fileloc pos = { __FILE__, __LINE__ };
3058 srcdir_len = strlen (srcdir);
3060 do_scalar_typedef ("CUMULATIVE_ARGS", &pos);
3061 do_scalar_typedef ("REAL_VALUE_TYPE", &pos);
3062 do_scalar_typedef ("double_int", &pos);
3063 do_scalar_typedef ("uint8", &pos);
3064 do_scalar_typedef ("jword", &pos);
3065 do_scalar_typedef ("JCF_u2", &pos);
3066 #ifdef USE_MAPPED_LOCATION
3067 do_scalar_typedef ("location_t", &pos);
3068 do_scalar_typedef ("source_locus", &pos);
3070 do_scalar_typedef ("void", &pos);
3072 do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos)), &pos);
3074 do_typedef ("HARD_REG_SET", create_array (
3075 create_scalar_type ("unsigned long", strlen ("unsigned long")),
3078 for (i = 0; i < NUM_GT_FILES; i++)
3081 /* Omit if already seen. */
3082 for (j = 0; j < i; j++)
3084 if (!strcmp (all_files[i], all_files[j]))
3091 parse_file (all_files[i]);
3092 #ifndef USE_MAPPED_LOCATION
3093 /* temporary kludge - gengtype doesn't handle conditionals.
3094 Manually add source_locus *after* we've processed input.h. */
3096 do_typedef ("source_locus", create_pointer (resolve_typedef ("location_t", &pos)), &pos);
3103 set_gc_used (variables);
3106 write_enum_defn (structures, param_structs);
3107 write_types (structures, param_structs, &ggc_wtd);
3108 write_types (structures, param_structs, &pch_wtd);
3109 write_local (structures, param_structs);
3110 write_roots (variables);
3112 close_output_files ();
3114 return (hit_error != 0);