gcc/gengtype.h

   1 /* Process source files and output type information.
   2    Copyright (C) 2002, 2003, 2004, 2007, 2008, 2010, 2011, 2012
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it under
   8    the terms of the GNU General Public License as published by the Free
   9    Software Foundation; either version 3, or (at your option) any later
  10    version.
  11
  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
  15    for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING3.  If not see
  19    <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_GENGTYPE_H
  22 #define GCC_GENGTYPE_H
  23
  24 #define obstack_chunk_alloc    ((void *(*) (long)) xmalloc)
  25 #define obstack_chunk_free     ((void (*) (void *)) free)
  26 #define OBSTACK_CHUNK_SIZE     0
  27
  28 /* Sets of accepted source languages like C, C++, Ada... are
  29    represented by a bitmap.  */
  30 typedef unsigned lang_bitmap;
  31
  32 /* Variable length structure representing an input file.  A hash table
  33    ensure uniqueness for a given input file name.  The only function
  34    allocating input_file-s is input_file_by_name.  */
  35 struct input_file_st
  36 {
  37   struct outf* inpoutf;  /* Cached corresponding output file, computed
  38                             in get_output_file_with_visibility.  */
  39   lang_bitmap inpbitmap; /* The set of languages using this file.  */
  40   bool inpisplugin;      /* Flag set for plugin input files.  */
  41   char inpname[1];       /* A variable-length array, ended by a null
  42                             char.  */
  43 };
  44 typedef struct input_file_st input_file;
  45
  46 /* A file position, mostly for error messages.
  47    The FILE element may be compared using pointer equality.  */
  48 struct fileloc
  49 {
  50   const input_file *file;
  51   int line;
  52 };
  53
  54
  55 /* Table of all input files and its size.  */
  56 extern const input_file** gt_files;
  57 extern size_t num_gt_files;
  58
  59 /* A number of places use the name of this "gengtype.c" file for a
  60    location for things that we can't rely on the source to define.  We
  61    also need to refer to the "system.h" file specifically.  These two
  62    pointers are initialized early in main.  */
  63 extern input_file* this_file;
  64 extern input_file* system_h_file;
  65
  66 /* Retrieve or create the input_file for a given name, which is a file
  67    path.  This is the only function allocating input_file-s and it is
  68    hash-consing them.  */
  69 input_file* input_file_by_name (const char* name);
  70
  71 /* For F an input_file, return the relative path to F from $(srcdir)
  72    if the latter is a prefix in F, NULL otherwise.  */
  73 const char *get_file_srcdir_relative_path (const input_file *inpf);
  74
  75 /* Get the name of an input file.  */
  76 static inline const char*
  77 get_input_file_name (const input_file *inpf)
  78 {
  79   if (inpf)
  80       return inpf->inpname;
  81   return NULL;
  82 }
  83
  84 /* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
  85    INPUT_FILE is used by <lang>.
  86
  87    This function should be written to assume that a file _is_ used
  88    if the situation is unclear.  If it wrongly assumes a file _is_ used,
  89    a linker error will result.  If it wrongly assumes a file _is not_ used,
  90    some GC roots may be missed, which is a much harder-to-debug problem.
  91   */
  92
  93 static inline lang_bitmap
  94 get_lang_bitmap (const input_file* inpf)
  95 {
  96   if (inpf == NULL)
  97     return 0;
  98   return inpf->inpbitmap;
  99 }
 100
 101 /* Set the bitmap returned by get_lang_bitmap.  The only legitimate
 102    callers of this function are read_input_list & read_state_*.  */
 103 static inline void
 104 set_lang_bitmap (input_file* inpf, lang_bitmap n)
 105 {
 106   gcc_assert (inpf);
 107   inpf->inpbitmap = n;
 108 }
 109
 110 /* Vector of per-language directories.  */
 111 extern const char **lang_dir_names;
 112 extern size_t num_lang_dirs;
 113
 114 /* Data types handed around within, but opaque to, the lexer and parser.  */
 115 typedef struct pair *pair_p;
 116 typedef struct type *type_p;
 117 typedef const struct type *const_type_p;
 118 typedef struct options *options_p;
 119
 120 /* Variables used to communicate between the lexer and the parser.  */
 121 extern int lexer_toplevel_done;
 122 extern struct fileloc lexer_line;
 123
 124 /* Various things, organized as linked lists, needed both in
 125    gengtype.c & in gengtype-state.c files.  */
 126 extern pair_p typedefs;
 127 extern type_p structures;
 128 extern type_p param_structs;
 129 extern pair_p variables;
 130
 131
 132
 133 /* Discrimating kind of types we can understand.  */
 134
 135 enum typekind {
 136   TYPE_NONE=0,          /* Never used, so zeroed memory is invalid.  */
 137   TYPE_SCALAR,          /* Scalar types like char.  */
 138   TYPE_STRING,          /* The string type.  */
 139   TYPE_STRUCT,          /* Type for GTY-ed structs.  */
 140   TYPE_UNION,           /* Type for GTY-ed discriminated unions.  */
 141   TYPE_POINTER,         /* Pointer type to GTY-ed type.  */
 142   TYPE_ARRAY,           /* Array of GTY-ed types.  */
 143   TYPE_LANG_STRUCT,     /* GCC front-end language specific structs.
 144                            Various languages may have homonymous but
 145                            different structs.  */
 146   TYPE_PARAM_STRUCT,    /* Type for parametrized structs, e.g. hash_t
 147                            hash-tables, ...  See (param_is, use_param,
 148                            param1_is, param2_is,... use_param1,
 149                            use_param_2,... use_params) GTY
 150                            options.  */
 151   TYPE_USER_STRUCT      /* User defined type.  Walkers and markers for
 152                            this type are assumed to be provided by the
 153                            user.  */
 154 };
 155
 156 /* Discriminating kind for options.  */
 157 enum option_kind {
 158   OPTION_NONE=0,        /* Never used, so zeroed memory is invalid.  */
 159   OPTION_STRING,        /* A string-valued option.  Most options are
 160                            strings.  */
 161   OPTION_TYPE,          /* A type-valued option.  */
 162   OPTION_NESTED         /* Option data for 'nested_ptr'.  */
 163 };
 164
 165
 166 /* A way to pass data through to the output end.  */
 167 struct options {
 168   struct options *next;         /* next option of the same pair.  */
 169   const char *name;             /* GTY option name.  */
 170   enum option_kind kind;        /* discriminating option kind.  */
 171   union {
 172     const char* string;                    /* When OPTION_STRING.  */
 173     type_p type;                           /* When OPTION_TYPE.  */
 174     struct nested_ptr_data* nested;        /* when OPTION_NESTED.  */
 175   } info;
 176 };
 177
 178
 179 /* Option data for the 'nested_ptr' option.  */
 180 struct nested_ptr_data {
 181   type_p type;
 182   const char *convert_to;
 183   const char *convert_from;
 184 };
 185
 186 /* Some functions to create various options structures with name NAME
 187    and info INFO.  NEXT is the next option in the chain.  */
 188
 189 /* Create a string option.  */
 190 options_p create_string_option (options_p next, const char* name,
 191                                 const char* info);
 192
 193 /* Create a type option.  */
 194 options_p create_type_option (options_p next, const char* name,
 195                               type_p info);
 196
 197 /* Create a nested option.  */
 198 options_p create_nested_option (options_p next, const char* name,
 199                                 struct nested_ptr_data* info);
 200
 201 /* Create a nested pointer option.  */
 202 options_p create_nested_ptr_option (options_p, type_p t,
 203                                      const char *from, const char *to);
 204
 205 /* A name and a type.  */
 206 struct pair {
 207   pair_p next;                  /* The next pair in the linked list.  */
 208   const char *name;             /* The defined name.  */
 209   type_p type;                  /* Its GTY-ed type.  */
 210   struct fileloc line;          /* The file location.  */
 211   options_p opt;                /* GTY options, as a linked list.  */
 212 };
 213
 214 /* Usage information for GTY-ed types.  Gengtype has to care only of
 215    used GTY-ed types.  Types are initially unused, and their usage is
 216    computed by set_gc_used_type and set_gc_used functions.  */
 217
 218 enum gc_used_enum {
 219
 220   /* We need that zeroed types are initially unused.  */
 221   GC_UNUSED=0,
 222
 223   /* The GTY-ed type is used, e.g by a GTY-ed variable or a field
 224      inside a GTY-ed used type.  */
 225   GC_USED,
 226
 227   /* For GTY-ed structures whose definitions we haven't seen so far
 228      when we encounter a pointer to it that is annotated with
 229      ``maybe_undef''.  If after reading in everything we don't have
 230      source file information for it, we assume that it never has been
 231      defined.  */
 232   GC_MAYBE_POINTED_TO,
 233
 234   /* For known GTY-ed structures which are pointed to by GTY-ed
 235      variables or fields.  */
 236   GC_POINTED_TO
 237 };
 238
 239 /* We can have at most ten type parameters in parameterized structures.  */
 240 #define NUM_PARAM 10
 241
 242 /* Our type structure describes all types handled by gengtype.  */
 243 struct type {
 244   /* Discriminating kind, cannot be TYPE_NONE.  */
 245   enum typekind kind;
 246
 247   /* For top-level structs or unions, the 'next' field links the
 248      global list 'structures' or 'param_structs'; for lang_structs,
 249      their homonymous structs are linked using this 'next' field.  The
 250      homonymous list starts at the s.lang_struct field of the
 251      lang_struct.  See the new_structure function for details.  This is
 252      tricky!  */
 253   type_p next;
 254
 255   /* State number used when writing & reading the persistent state.  A
 256      type with a positive number has already been written.  For ease
 257      of debugging, newly allocated types have a unique negative
 258      number.  */
 259   int state_number;
 260
 261   /* Each GTY-ed type which is pointed to by some GTY-ed type knows
 262      the GTY pointer type pointing to it.  See create_pointer
 263      function.  */
 264   type_p pointer_to;
 265
 266   /* Type usage information, computed by set_gc_used_type and
 267      set_gc_used functions.  */
 268   enum gc_used_enum gc_used;
 269
 270   /* The following union is discriminated by the 'kind' field above.  */
 271   union {
 272     /* TYPE__NONE is impossible.  */
 273
 274     /* when TYPE_POINTER:  */
 275     type_p p;
 276
 277     /* when TYPE_STRUCT or TYPE_UNION or TYPE_LANG_STRUCT, we have an
 278        aggregate type containing fields: */
 279     struct {
 280       const char *tag;          /* the aggragate tag, if any.  */
 281       struct fileloc line;      /* the source location.  */
 282       pair_p fields;            /* the linked list of fields.  */
 283       options_p opt;            /* the GTY options if any.  */
 284       lang_bitmap bitmap;       /* the set of front-end languages
 285                                    using that GTY-ed aggregate.  */
 286       /* For TYPE_LANG_STRUCT, the lang_struct field gives the first
 287          element of a linked list of homonymous struct or union types.
 288          Within this list, each homonymous type has as its lang_struct
 289          field the original TYPE_LANG_STRUCT type.  This is a dirty
 290          trick, see the new_structure function for details.  */
 291       type_p lang_struct;
 292     } s;
 293
 294     /* when TYPE_SCALAR: */
 295     bool scalar_is_char;
 296
 297     /* when TYPE_ARRAY: */
 298     struct {
 299       type_p p;                 /* The array component type.  */
 300       const char *len;          /* The string if any giving its length.  */
 301     } a;
 302
 303     /* When TYPE_PARAM_STRUCT for (param_is, use_param, param1_is,
 304        param2_is, ... use_param1, use_param_2, ... use_params) GTY
 305        options.  */
 306     struct {
 307       type_p stru;              /* The generic GTY-ed type.  */
 308       type_p param[NUM_PARAM];  /* The actual parameter types.  */
 309       struct fileloc line;      /* The source location.  */
 310     } param_struct;
 311   } u;
 312 };
 313
 314 /* The one and only TYPE_STRING.  */
 315 extern struct type string_type;
 316
 317 /* The two and only TYPE_SCALARs.  Their u.scalar_is_char flags are
 318    set early in main.  */
 319 extern struct type scalar_nonchar;
 320 extern struct type scalar_char;
 321
 322 /* Test if a type is a union, either a plain one or a language
 323    specific one.  */
 324 #define UNION_P(x)                                      \
 325     ((x)->kind == TYPE_UNION                            \
 326      || ((x)->kind == TYPE_LANG_STRUCT                  \
 327          && (x)->u.s.lang_struct->kind == TYPE_UNION))
 328
 329 /* Test if a type is a union or a structure, perhaps a language
 330    specific one.  */
 331 static inline bool
 332 union_or_struct_p (enum typekind kind)
 333 {
 334   return (kind == TYPE_UNION
 335           || kind == TYPE_STRUCT
 336           || kind == TYPE_LANG_STRUCT
 337           || kind == TYPE_USER_STRUCT);
 338 }
 339
 340 static inline bool
 341 union_or_struct_p (const_type_p x)
 342 {
 343   return union_or_struct_p (x->kind);
 344 }
 345
 346 /* Give the file location of a type, if any. */
 347 static inline struct fileloc*
 348 type_fileloc (type_p t)
 349 {
 350   if (!t)
 351     return NULL;
 352   if (union_or_struct_p (t))
 353     return &t->u.s.line;
 354   if  (t->kind == TYPE_PARAM_STRUCT)
 355     return &t->u.param_struct.line;
 356   return NULL;
 357 }
 358
 359 /* Structure representing an output file.  */
 360 struct outf
 361 {
 362   struct outf *next;
 363   const char *name;
 364   size_t buflength;
 365   size_t bufused;
 366   char *buf;
 367 };
 368 typedef struct outf *outf_p;
 369
 370 /* The list of output files.  */
 371 extern outf_p output_files;
 372
 373 /* The output header file that is included into pretty much every
 374    source file.  */
 375 extern outf_p header_file;
 376
 377 /* Print, like fprintf, to O.  No-op if O is NULL.  */
 378 void
 379 oprintf (outf_p o, const char *S, ...)
 380   ATTRIBUTE_PRINTF_2;
 381
 382 /* An output file, suitable for definitions, that can see declarations
 383    made in INPF and is linked into every language that uses INPF.  May
 384    return NULL in plugin mode.  The INPF argument is almost const, but
 385    since the result is cached in its inpoutf field it cannot be
 386    declared const.  */
 387 outf_p get_output_file_with_visibility (input_file* inpf);
 388
 389 /* The name of an output file, suitable for definitions, that can see
 390    declarations made in INPF and is linked into every language that
 391    uses INPF.  May return NULL.  */
 392 const char *get_output_file_name (input_file *inpf);
 393
 394
 395 /* Source directory.  */
 396 extern const char *srcdir;      /* (-S) program argument. */
 397
 398 /* Length of srcdir name.  */
 399 extern size_t srcdir_len;
 400
 401 /* Variable used for reading and writing the state.  */
 402 extern const char *read_state_filename; /* (-r) program argument. */
 403 extern const char *write_state_filename; /* (-w) program argument. */
 404
 405 /* Functions reading and writing the entire gengtype state, called from
 406    main, and implemented in file gengtype-state.c.  */
 407 void read_state (const char* path);
 408 /* Write the state, and update the state_number field in types.  */
 409 void write_state (const char* path);
 410
 411
 412 /* Print an error message.  */
 413 extern void error_at_line
 414 (const struct fileloc *pos, const char *msg, ...) ATTRIBUTE_PRINTF_2;
 415
 416 /* Like asprintf, but calls fatal() on out of memory.  */
 417 extern char *xasprintf (const char *, ...) ATTRIBUTE_PRINTF_1;
 418
 419 /* Constructor routines for types.  */
 420 extern void do_typedef (const char *s, type_p t, struct fileloc *pos);
 421 extern void do_scalar_typedef (const char *s, struct fileloc *pos);
 422 extern type_p resolve_typedef (const char *s, struct fileloc *pos);
 423 extern type_p new_structure (const char *name, enum typekind kind,
 424                              struct fileloc *pos, pair_p fields,
 425                              options_p o);
 426 extern type_p find_structure (const char *s, enum typekind kind);
 427 extern type_p create_scalar_type (const char *name);
 428 extern type_p create_pointer (type_p t);
 429 extern type_p create_array (type_p t, const char *len);
 430 extern pair_p create_field_at (pair_p next, type_p type,
 431                                const char *name, options_p opt,
 432                                struct fileloc *pos);
 433 extern pair_p nreverse_pairs (pair_p list);
 434 extern type_p adjust_field_type (type_p, options_p);
 435 extern void note_variable (const char *s, type_p t, options_p o,
 436                            struct fileloc *pos);
 437
 438 /* Lexer and parser routines.  */
 439 extern int yylex (const char **yylval);
 440 extern void yybegin (const char *fname);
 441 extern void yyend (void);
 442 extern void parse_file (const char *name);
 443 extern bool hit_error;
 444
 445 /* Token codes.  */
 446 enum gty_token
 447 {
 448   EOF_TOKEN = 0,
 449
 450   /* Per standard convention, codes in the range (0, UCHAR_MAX]
 451      represent single characters with those character codes.  */
 452   CHAR_TOKEN_OFFSET = UCHAR_MAX + 1,
 453   GTY_TOKEN = CHAR_TOKEN_OFFSET,
 454   TYPEDEF,
 455   EXTERN,
 456   STATIC,
 457   UNION,
 458   STRUCT,
 459   ENUM,
 460   VEC_TOKEN,
 461   ELLIPSIS,
 462   PTR_ALIAS,
 463   NESTED_PTR,
 464   USER_GTY,
 465   PARAM_IS,
 466   NUM,
 467   SCALAR,
 468   ID,
 469   STRING,
 470   CHAR,
 471   ARRAY,
 472   IGNORABLE_CXX_KEYWORD,
 473
 474   /* print_token assumes that any token >= FIRST_TOKEN_WITH_VALUE may have
 475      a meaningful value to be printed.  */
 476   FIRST_TOKEN_WITH_VALUE = PARAM_IS
 477 };
 478
 479
 480 /* Level for verbose messages, e.g. output file generation...  */
 481 extern int verbosity_level;     /* (-v) program argument.  */
 482
 483 /* For debugging purposes we provide two flags.  */
 484
 485 /* Dump everything to understand gengtype's state. Might be useful to
 486    gengtype users.  */
 487 extern int do_dump;             /* (-d) program argument. */
 488
 489 /* Trace the execution by many DBGPRINTF (with the position inside
 490    gengtype source code).  Only useful to debug gengtype itself.  */
 491 extern int do_debug;            /* (-D) program argument. */
 492
 493 #if ENABLE_CHECKING
 494 #define DBGPRINTF(Fmt,...) do {if (do_debug)                            \
 495       fprintf (stderr, "%s:%d: " Fmt "\n",                              \
 496                lbasename (__FILE__),__LINE__, ##__VA_ARGS__);} while (0)
 497 void dbgprint_count_type_at (const char *, int, const char *, type_p);
 498 #define DBGPRINT_COUNT_TYPE(Msg,Ty) do {if (do_debug)                   \
 499       dbgprint_count_type_at (__FILE__, __LINE__, Msg, Ty);}while (0)
 500 #else
 501 #define DBGPRINTF(Fmt,...) do {/*nodbgrintf*/} while (0)
 502 #define DBGPRINT_COUNT_TYPE(Msg,Ty) do{/*nodbgprint_count_type*/}while (0)
 503 #endif /*ENABLE_CHECKING */
 504
 505 #endif