gcc/gengtype.h

   1 /* Process source files and output type information.
   2    Copyright (C) 2002, 2003, 2004, 2007, 2008, 2010, 2011
   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 };
 152
 153 /* Discriminating kind for options.  */
 154 enum option_kind {
 155   OPTION_NONE=0,        /* Never used, so zeroed memory is invalid.  */
 156   OPTION_STRING,        /* A string-valued option.  Most options are
 157                            strings.  */
 158   OPTION_TYPE,          /* A type-valued option.  */
 159   OPTION_NESTED         /* Option data for 'nested_ptr'.  */
 160 };
 161
 162
 163 /* A way to pass data through to the output end.  */
 164 struct options {
 165   struct options *next;         /* next option of the same pair.  */
 166   const char *name;             /* GTY option name.  */
 167   enum option_kind kind;        /* discriminating option kind.  */
 168   union {
 169     const char* string;                    /* When OPTION_STRING.  */
 170     type_p type;                           /* When OPTION_TYPE.  */
 171     struct nested_ptr_data* nested;        /* when OPTION_NESTED.  */
 172   } info;
 173 };
 174
 175
 176 /* Option data for the 'nested_ptr' option.  */
 177 struct nested_ptr_data {
 178   type_p type;
 179   const char *convert_to;
 180   const char *convert_from;
 181 };
 182
 183 /* Some functions to create various options structures with name NAME
 184    and info INFO.  NEXT is the next option in the chain.  */
 185
 186 /* Create a string option.  */
 187 options_p create_string_option (options_p next, const char* name,
 188                                 const char* info);
 189
 190 /* Create a type option.  */
 191 options_p create_type_option (options_p next, const char* name,
 192                               type_p info);
 193
 194 /* Create a nested option.  */
 195 options_p create_nested_option (options_p next, const char* name,
 196                                 struct nested_ptr_data* info);
 197
 198 /* Create a nested pointer option.  */
 199 options_p create_nested_ptr_option (options_p, type_p t,
 200                                      const char *from, const char *to);
 201
 202 /* A name and a type.  */
 203 struct pair {
 204   pair_p next;                  /* The next pair in the linked list.  */
 205   const char *name;             /* The defined name.  */
 206   type_p type;                  /* Its GTY-ed type.  */
 207   struct fileloc line;          /* The file location.  */
 208   options_p opt;                /* GTY options, as a linked list.  */
 209 };
 210
 211 /* Usage information for GTY-ed types.  Gengtype has to care only of
 212    used GTY-ed types.  Types are initially unused, and their usage is
 213    computed by set_gc_used_type and set_gc_used functions.  */
 214
 215 enum gc_used_enum {
 216
 217   /* We need that zeroed types are initially unused.  */
 218   GC_UNUSED=0,
 219
 220   /* The GTY-ed type is used, e.g by a GTY-ed variable or a field
 221      inside a GTY-ed used type.  */
 222   GC_USED,
 223
 224   /* For GTY-ed structures whose definitions we haven't seen so far
 225      when we encounter a pointer to it that is annotated with
 226      ``maybe_undef''.  If after reading in everything we don't have
 227      source file information for it, we assume that it never has been
 228      defined.  */
 229   GC_MAYBE_POINTED_TO,
 230
 231   /* For known GTY-ed structures which are pointed to by GTY-ed
 232      variables or fields.  */
 233   GC_POINTED_TO
 234 };
 235
 236 /* We can have at most ten type parameters in parameterized structures.  */
 237 #define NUM_PARAM 10
 238
 239 /* Our type structure describes all types handled by gengtype.  */
 240 struct type {
 241   /* Discriminating kind, cannot be TYPE_NONE.  */
 242   enum typekind kind;
 243
 244   /* For top-level structs or unions, the 'next' field links the
 245      global list 'structures' or 'param_structs'; for lang_structs,
 246      their homonymous structs are linked using this 'next' field.  The
 247      homonymous list starts at the s.lang_struct field of the
 248      lang_struct.  See the new_structure function for details.  This is
 249      tricky!  */
 250   type_p next;
 251
 252   /* State number used when writing & reading the persistent state.  A
 253      type with a positive number has already been written.  For ease
 254      of debugging, newly allocated types have a unique negative
 255      number.  */
 256   int state_number;
 257
 258   /* Each GTY-ed type which is pointed to by some GTY-ed type knows
 259      the GTY pointer type pointing to it.  See create_pointer
 260      function.  */
 261   type_p pointer_to;
 262
 263   /* Type usage information, computed by set_gc_used_type and
 264      set_gc_used functions.  */
 265   enum gc_used_enum gc_used;
 266
 267   /* The following union is discriminated by the 'kind' field above.  */
 268   union {
 269     /* TYPE__NONE is impossible.  */
 270
 271     /* when TYPE_POINTER:  */
 272     type_p p;
 273
 274     /* when TYPE_STRUCT or TYPE_UNION or TYPE_LANG_STRUCT, we have an
 275        aggregate type containing fields: */
 276     struct {
 277       const char *tag;          /* the aggragate tag, if any.  */
 278       struct fileloc line;      /* the source location.  */
 279       pair_p fields;            /* the linked list of fields.  */
 280       options_p opt;            /* the GTY options if any.  */
 281       lang_bitmap bitmap;       /* the set of front-end languages
 282                                    using that GTY-ed aggregate.  */
 283       /* For TYPE_LANG_STRUCT, the lang_struct field gives the first
 284          element of a linked list of homonymous struct or union types.
 285          Within this list, each homonymous type has as its lang_struct
 286          field the original TYPE_LANG_STRUCT type.  This is a dirty
 287          trick, see the new_structure function for details.  */
 288       type_p lang_struct;
 289     } s;
 290
 291     /* when TYPE_SCALAR: */
 292     bool scalar_is_char;
 293
 294     /* when TYPE_ARRAY: */
 295     struct {
 296       type_p p;                 /* The array component type.  */
 297       const char *len;          /* The string if any giving its length.  */
 298     } a;
 299
 300     /* When TYPE_PARAM_STRUCT for (param_is, use_param, param1_is,
 301        param2_is, ... use_param1, use_param_2, ... use_params) GTY
 302        options.  */
 303     struct {
 304       type_p stru;              /* The generic GTY-ed type.  */
 305       type_p param[NUM_PARAM];  /* The actual parameter types.  */
 306       struct fileloc line;      /* The source location.  */
 307     } param_struct;
 308
 309   } u;
 310 };
 311
 312 /* The one and only TYPE_STRING.  */
 313 extern struct type string_type;
 314
 315 /* The two and only TYPE_SCALARs.  Their u.scalar_is_char flags are
 316    set early in main.  */
 317 extern struct type scalar_nonchar;
 318 extern struct type scalar_char;
 319
 320 /* Test if a type is a union, either a plain one or a language
 321    specific one.  */
 322 #define UNION_P(x)                                      \
 323     ((x)->kind == TYPE_UNION ||                         \
 324      ((x)->kind == TYPE_LANG_STRUCT                     \
 325       && (x)->u.s.lang_struct->kind == TYPE_UNION))
 326
 327 /* Test if a type is a union or a structure, perhaps a language
 328    specific one.  */
 329 #define UNION_OR_STRUCT_P(x)                    \
 330     ((x)->kind == TYPE_UNION                    \
 331      || (x)->kind == TYPE_STRUCT                \
 332      || (x)->kind == TYPE_LANG_STRUCT)
 333
 334
 335
 336 /* Give the file location of a type, if any. */
 337 static inline struct fileloc*
 338 type_fileloc (type_p t)
 339 {
 340   if (!t)
 341     return NULL;
 342   if (UNION_OR_STRUCT_P(t))
 343     return &t->u.s.line;
 344   if  (t->kind == TYPE_PARAM_STRUCT)
 345     return &t->u.param_struct.line;
 346   return NULL;
 347 }
 348
 349 /* Structure representing an output file.  */
 350 struct outf
 351 {
 352   struct outf *next;
 353   const char *name;
 354   size_t buflength;
 355   size_t bufused;
 356   char *buf;
 357 };
 358 typedef struct outf *outf_p;
 359
 360 /* The list of output files.  */
 361 extern outf_p output_files;
 362
 363 /* The output header file that is included into pretty much every
 364    source file.  */
 365 extern outf_p header_file;
 366
 367 /* Print, like fprintf, to O.  No-op if O is NULL.  */
 368 void
 369 oprintf (outf_p o, const char *S, ...)
 370   ATTRIBUTE_PRINTF_2;
 371
 372 /* An output file, suitable for definitions, that can see declarations
 373    made in INPF and is linked into every language that uses INPF.  May
 374    return NULL in plugin mode.  The INPF argument is almost const, but
 375    since the result is cached in its inpoutf field it cannot be
 376    declared const.  */
 377 outf_p get_output_file_with_visibility (input_file* inpf);
 378
 379 /* The name of an output file, suitable for definitions, that can see
 380    declarations made in INPF and is linked into every language that
 381    uses INPF.  May return NULL.  */
 382 const char *get_output_file_name (input_file *inpf);
 383
 384
 385 /* Source directory.  */
 386 extern const char *srcdir;      /* (-S) program argument. */
 387
 388 /* Length of srcdir name.  */
 389 extern size_t srcdir_len;
 390
 391 /* Variable used for reading and writing the state.  */
 392 extern const char *read_state_filename; /* (-r) program argument. */
 393 extern const char *write_state_filename; /* (-w) program argument. */
 394
 395 /* Functions reading and writing the entire gengtype state, called from
 396    main, and implemented in file gengtype-state.c.  */
 397 void read_state (const char* path);
 398 /* Write the state, and update the state_number field in types.  */
 399 void write_state (const char* path);
 400
 401
 402 /* Print an error message.  */
 403 extern void error_at_line
 404 (const struct fileloc *pos, const char *msg, ...) ATTRIBUTE_PRINTF_2;
 405
 406 /* Like asprintf, but calls fatal() on out of memory.  */
 407 extern char *xasprintf (const char *, ...) ATTRIBUTE_PRINTF_1;
 408
 409 /* Constructor routines for types.  */
 410 extern void do_typedef (const char *s, type_p t, struct fileloc *pos);
 411 extern void do_scalar_typedef (const char *s, struct fileloc *pos);
 412 extern type_p resolve_typedef (const char *s, struct fileloc *pos);
 413 extern type_p new_structure (const char *name, int isunion,
 414                              struct fileloc *pos, pair_p fields,
 415                              options_p o);
 416 extern type_p find_structure (const char *s, int isunion);
 417 extern type_p create_scalar_type (const char *name);
 418 extern type_p create_pointer (type_p t);
 419 extern type_p create_array (type_p t, const char *len);
 420 extern pair_p create_field_at (pair_p next, type_p type,
 421                                const char *name, options_p opt,
 422                                struct fileloc *pos);
 423 extern pair_p nreverse_pairs (pair_p list);
 424 extern type_p adjust_field_type (type_p, options_p);
 425 extern void note_variable (const char *s, type_p t, options_p o,
 426                            struct fileloc *pos);
 427 extern void note_def_vec (const char *type_name, bool is_scalar,
 428                           struct fileloc *pos);
 429 extern void note_def_vec_alloc (const char *type, const char *astrat,
 430                                 struct fileloc *pos);
 431
 432 /* Lexer and parser routines.  */
 433 extern int yylex (const char **yylval);
 434 extern void yybegin (const char *fname);
 435 extern void yyend (void);
 436 extern void parse_file (const char *name);
 437 extern bool hit_error;
 438
 439 /* Token codes.  */
 440 enum
 441   {
 442     EOF_TOKEN = 0,
 443
 444     /* Per standard convention, codes in the range (0, UCHAR_MAX]
 445        represent single characters with those character codes.  */
 446
 447     CHAR_TOKEN_OFFSET = UCHAR_MAX + 1,
 448     GTY_TOKEN = CHAR_TOKEN_OFFSET,
 449     TYPEDEF,
 450     EXTERN,
 451     STATIC,
 452     UNION,
 453     STRUCT,
 454     ENUM,
 455     VEC_TOKEN,
 456     DEFVEC_OP,
 457     DEFVEC_I,
 458     DEFVEC_ALLOC,
 459     ELLIPSIS,
 460     PTR_ALIAS,
 461     NESTED_PTR,
 462     PARAM_IS,
 463     NUM,
 464     SCALAR,
 465     ID,
 466     STRING,
 467     CHAR,
 468     ARRAY,
 469
 470     /* print_token assumes that any token >= FIRST_TOKEN_WITH_VALUE may have
 471        a meaningful value to be printed.  */
 472     FIRST_TOKEN_WITH_VALUE = PARAM_IS
 473   };
 474
 475
 476 /* Level for verbose messages, e.g. output file generation...  */
 477 extern int verbosity_level;     /* (-v) program argument.  */
 478
 479 /* For debugging purposes we provide two flags.  */
 480
 481 /* Dump everything to understand gengtype's state. Might be useful to
 482    gengtype users.  */
 483 extern int do_dump;             /* (-d) program argument. */
 484
 485 /* Trace the execution by many DBGPRINTF (with the position inside
 486    gengtype source code).  Only useful to debug gengtype itself.  */
 487 extern int do_debug;            /* (-D) program argument. */
 488
 489 #if ENABLE_CHECKING
 490 #define DBGPRINTF(Fmt,...) do {if (do_debug)                            \
 491       fprintf (stderr, "%s:%d: " Fmt "\n",                              \
 492                lbasename (__FILE__),__LINE__, ##__VA_ARGS__);} while (0)
 493 void dbgprint_count_type_at (const char *, int, const char *, type_p);
 494 #define DBGPRINT_COUNT_TYPE(Msg,Ty) do {if (do_debug)                   \
 495       dbgprint_count_type_at (__FILE__, __LINE__, Msg, Ty);}while (0)
 496 #else
 497 #define DBGPRINTF(Fmt,...) do {/*nodbgrintf*/} while (0)
 498 #define DBGPRINT_COUNT_TYPE(Msg,Ty) do{/*nodbgprint_count_type*/}while (0)
 499 #endif /*ENABLE_CHECKING */
 500
 501 #endif