gcc/gengtype.h

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