gcc/opts.h

   1 /* Command line option handling.
   2    Copyright (C) 2002-2018 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_OPTS_H
  21 #define GCC_OPTS_H
  22
  23 #include "obstack.h"
  24
  25 /* Specifies how a switch's VAR_VALUE relates to its FLAG_VAR.  */
  26 enum cl_var_type {
  27   /* The switch is enabled when FLAG_VAR is nonzero.  */
  28   CLVC_BOOLEAN,
  29
  30   /* The switch is enabled when FLAG_VAR == VAR_VALUE.  */
  31   CLVC_EQUAL,
  32
  33   /* The switch is enabled when VAR_VALUE is not set in FLAG_VAR.  */
  34   CLVC_BIT_CLEAR,
  35
  36   /* The switch is enabled when VAR_VALUE is set in FLAG_VAR.  */
  37   CLVC_BIT_SET,
  38
  39   /* The switch takes a string argument and FLAG_VAR points to that
  40      argument.  */
  41   CLVC_STRING,
  42
  43   /* The switch takes an enumerated argument (VAR_ENUM says what
  44      enumeration) and FLAG_VAR points to that argument.  */
  45   CLVC_ENUM,
  46
  47   /* The switch should be stored in the VEC pointed to by FLAG_VAR for
  48      later processing.  */
  49   CLVC_DEFER
  50 };
  51
  52 struct cl_option
  53 {
  54   /* Text of the option, including initial '-'.  */
  55   const char *opt_text;
  56   /* Help text for --help, or NULL.  */
  57   const char *help;
  58   /* Error message for missing argument, or NULL.  */
  59   const char *missing_argument_error;
  60   /* Warning to give when this option is used, or NULL.  */
  61   const char *warn_message;
  62   /* Argument of alias target when positive option given, or NULL.  */
  63   const char *alias_arg;
  64   /* Argument of alias target when negative option given, or NULL.  */
  65   const char *neg_alias_arg;
  66   /* Alias target, or N_OPTS if not an alias.  */
  67   unsigned short alias_target;
  68   /* Previous option that is an initial substring of this one, or
  69      N_OPTS if none.  */
  70   unsigned short back_chain;
  71   /* Option length, not including initial '-'.  */
  72   unsigned char opt_len;
  73   /* Next option in a sequence marked with Negative, or -1 if none.  */
  74   int neg_index;
  75   /* CL_* flags for this option.  */
  76   unsigned int flags;
  77   /* Disabled in this configuration.  */
  78   BOOL_BITFIELD cl_disabled : 1;
  79   /* Options marked with CL_SEPARATE take a number of separate
  80      arguments (1 to 4) that is one more than the number in this
  81      bit-field.  */
  82   unsigned int cl_separate_nargs : 2;
  83   /* Option is an alias when used with separate argument.  */
  84   BOOL_BITFIELD cl_separate_alias : 1;
  85   /* Alias to negative form of option.  */
  86   BOOL_BITFIELD cl_negative_alias : 1;
  87   /* Option takes no argument in the driver.  */
  88   BOOL_BITFIELD cl_no_driver_arg : 1;
  89   /* Reject this option in the driver.  */
  90   BOOL_BITFIELD cl_reject_driver : 1;
  91   /* Reject no- form.  */
  92   BOOL_BITFIELD cl_reject_negative : 1;
  93   /* Missing argument OK (joined).  */
  94   BOOL_BITFIELD cl_missing_ok : 1;
  95   /* Argument is an integer >=0.  */
  96   BOOL_BITFIELD cl_uinteger : 1;
  97   /* Argument is a HOST_WIDE_INT.  */
  98   BOOL_BITFIELD cl_host_wide_int : 1;
  99   /* Argument should be converted to lowercase.  */
 100   BOOL_BITFIELD cl_tolower : 1;
 101   /* Report argument with -fverbose-asm  */
 102   BOOL_BITFIELD cl_report : 1;
 103   /* Offset of field for this option in struct gcc_options, or
 104      (unsigned short) -1 if none.  */
 105   unsigned short flag_var_offset;
 106   /* Index in cl_enums of enum used for this option's arguments, for
 107      CLVC_ENUM options.  */
 108   unsigned short var_enum;
 109   /* How this option's value is determined and sets a field.  */
 110   enum cl_var_type var_type;
 111   /* Value or bit-mask with which to set a field.  */
 112   HOST_WIDE_INT var_value;
 113   /* Range info minimum, or -1.  */
 114   int range_min;
 115   /* Range info maximum, or -1.  */
 116   int range_max;
 117 };
 118
 119 /* Records that the state of an option consists of SIZE bytes starting
 120    at DATA.  DATA might point to CH in some cases.  */
 121 struct cl_option_state {
 122   const void *data;
 123   size_t size;
 124   char ch;
 125 };
 126
 127 extern const struct cl_option cl_options[];
 128 extern const unsigned int cl_options_count;
 129 extern const char *const lang_names[];
 130 extern const unsigned int cl_lang_count;
 131
 132 #define CL_PARAMS               (1U << 16) /* Fake entry.  Used to display --param info with --help.  */
 133 #define CL_WARNING              (1U << 17) /* Enables an (optional) warning message.  */
 134 #define CL_OPTIMIZATION         (1U << 18) /* Enables an (optional) optimization.  */
 135 #define CL_DRIVER               (1U << 19) /* Driver option.  */
 136 #define CL_TARGET               (1U << 20) /* Target-specific option.  */
 137 #define CL_COMMON               (1U << 21) /* Language-independent.  */
 138
 139 #define CL_MIN_OPTION_CLASS     CL_PARAMS
 140 #define CL_MAX_OPTION_CLASS     CL_COMMON
 141
 142 /* From here on the bits describe attributes of the options.
 143    Before this point the bits have described the class of the option.
 144    This distinction is important because --help will not list options
 145    which only have these higher bits set.  */
 146
 147 #define CL_JOINED               (1U << 22) /* If takes joined argument.  */
 148 #define CL_SEPARATE             (1U << 23) /* If takes a separate argument.  */
 149 #define CL_UNDOCUMENTED         (1U << 24) /* Do not output with --help.  */
 150 #define CL_NO_DWARF_RECORD      (1U << 25) /* Do not add to producer string.  */
 151 #define CL_PCH_IGNORE           (1U << 26) /* Do compare state for pch.  */
 152
 153 /* Flags for an enumerated option argument.  */
 154 #define CL_ENUM_CANONICAL       (1 << 0) /* Canonical for this value.  */
 155 #define CL_ENUM_DRIVER_ONLY     (1 << 1) /* Only accepted in the driver.  */
 156
 157 /* Structure describing an enumerated option argument.  */
 158
 159 struct cl_enum_arg
 160 {
 161   /* The argument text, or NULL at the end of the array.  */
 162   const char *arg;
 163
 164   /* The corresponding integer value.  */
 165   int value;
 166
 167   /* Flags associated with this argument.  */
 168   unsigned int flags;
 169 };
 170
 171 /* Structure describing an enumerated set of option arguments.  */
 172
 173 struct cl_enum
 174 {
 175   /* Help text, or NULL if the values should not be listed in --help
 176      output.  */
 177   const char *help;
 178
 179   /* Error message for unknown arguments, or NULL to use a generic
 180      error.  */
 181   const char *unknown_error;
 182
 183   /* Array of possible values.  */
 184   const struct cl_enum_arg *values;
 185
 186   /* The size of the type used to store a value.  */
 187   size_t var_size;
 188
 189   /* Function to set a variable of this type.  */
 190   void (*set) (void *var, int value);
 191
 192   /* Function to get the value of a variable of this type.  */
 193   int (*get) (const void *var);
 194 };
 195
 196 extern const struct cl_enum cl_enums[];
 197 extern const unsigned int cl_enums_count;
 198
 199 /* Possible ways in which a command-line option may be erroneous.
 200    These do not include not being known at all; an option index of
 201    OPT_SPECIAL_unknown is used for that.  */
 202
 203 #define CL_ERR_DISABLED         (1 << 0) /* Disabled in this configuration.  */
 204 #define CL_ERR_MISSING_ARG      (1 << 1) /* Argument required but missing.  */
 205 #define CL_ERR_WRONG_LANG       (1 << 2) /* Option for wrong language.  */
 206 #define CL_ERR_UINT_ARG         (1 << 3) /* Bad unsigned integer argument.  */
 207 #define CL_ERR_INT_RANGE_ARG    (1 << 4) /* Bad unsigned integer argument.  */
 208 #define CL_ERR_ENUM_ARG         (1 << 5) /* Bad enumerated argument.  */
 209 #define CL_ERR_NEGATIVE         (1 << 6) /* Negative form of option
 210                                             not permitted (together
 211                                             with OPT_SPECIAL_unknown).  */
 212
 213 /* Structure describing the result of decoding an option.  */
 214
 215 struct cl_decoded_option
 216 {
 217   /* The index of this option, or an OPT_SPECIAL_* value for
 218      non-options and unknown options.  */
 219   size_t opt_index;
 220
 221   /* Any warning to give for use of this option, or NULL if none.  */
 222   const char *warn_message;
 223
 224   /* The string argument, or NULL if none.  For OPT_SPECIAL_* cases,
 225      the option or non-option command-line argument.  */
 226   const char *arg;
 227
 228   /* The original text of option plus arguments, with separate argv
 229      elements concatenated into one string with spaces separating
 230      them.  This is for such uses as diagnostics and
 231      -frecord-gcc-switches.  */
 232   const char *orig_option_with_args_text;
 233
 234   /* The canonical form of the option and its argument, for when it is
 235      necessary to reconstruct argv elements (in particular, for
 236      processing specs and passing options to subprocesses from the
 237      driver).  */
 238   const char *canonical_option[4];
 239
 240   /* The number of elements in the canonical form of the option and
 241      arguments; always at least 1.  */
 242   size_t canonical_option_num_elements;
 243
 244   /* For a boolean option, 1 for the true case and 0 for the "no-"
 245      case.  For an unsigned integer option, the value of the
 246      argument.  1 in all other cases.  */
 247   int value;
 248
 249   /* Any flags describing errors detected in this option.  */
 250   int errors;
 251 };
 252
 253 /* Structure describing an option deferred for handling after the main
 254    option handlers.  */
 255
 256 struct cl_deferred_option
 257 {
 258   /* Elements from struct cl_decoded_option used for deferred
 259      options.  */
 260   size_t opt_index;
 261   const char *arg;
 262   int value;
 263 };
 264
 265 /* Structure describing a single option-handling callback.  */
 266
 267 struct cl_option_handler_func
 268 {
 269   /* The function called to handle the option.  */
 270   bool (*handler) (struct gcc_options *opts,
 271                    struct gcc_options *opts_set,
 272                    const struct cl_decoded_option *decoded,
 273                    unsigned int lang_mask, int kind, location_t loc,
 274                    const struct cl_option_handlers *handlers,
 275                    diagnostic_context *dc,
 276                    void (*target_option_override_hook) (void));
 277
 278   /* The mask that must have some bit in common with the flags for the
 279      option for this particular handler to be used.  */
 280   unsigned int mask;
 281 };
 282
 283 /* Structure describing the callbacks used in handling options.  */
 284
 285 struct cl_option_handlers
 286 {
 287   /* Callback for an unknown option to determine whether to give an
 288      error for it, and possibly store information to diagnose the
 289      option at a later point.  Return true if an error should be
 290      given, false otherwise.  */
 291   bool (*unknown_option_callback) (const struct cl_decoded_option *decoded);
 292
 293   /* Callback to handle, and possibly diagnose, an option for another
 294      language.  */
 295   void (*wrong_lang_callback) (const struct cl_decoded_option *decoded,
 296                                unsigned int lang_mask);
 297
 298   /* Target option override hook.  */
 299   void (*target_option_override_hook) (void);
 300
 301   /* The number of individual handlers.  */
 302   size_t num_handlers;
 303
 304   /* The handlers themselves.  */
 305   struct cl_option_handler_func handlers[3];
 306 };
 307
 308 /* Hold command-line options associated with stack limitation.  */
 309 extern const char *opt_fstack_limit_symbol_arg;
 310 extern int opt_fstack_limit_register_no;
 311
 312 /* Input file names.  */
 313
 314 extern const char **in_fnames;
 315
 316 /* The count of input filenames.  */
 317
 318 extern unsigned num_in_fnames;
 319
 320 extern char *opts_concat (const char *first, ...);
 321
 322 /* Obstack for option strings.  */
 323
 324 extern struct obstack opts_obstack;
 325
 326 size_t find_opt (const char *input, unsigned int lang_mask);
 327 extern int integral_argument (const char *arg);
 328 extern bool enum_value_to_arg (const struct cl_enum_arg *enum_args,
 329                                const char **argp, int value,
 330                                unsigned int lang_mask);
 331 extern void decode_cmdline_options_to_array (unsigned int argc,
 332                                              const char **argv,
 333                                              unsigned int lang_mask,
 334                                              struct cl_decoded_option **decoded_options,
 335                                              unsigned int *decoded_options_count);
 336 extern void init_options_once (void);
 337 extern void init_options_struct (struct gcc_options *opts,
 338                                  struct gcc_options *opts_set);
 339 extern void init_opts_obstack (void);
 340 extern void finalize_options_struct (struct gcc_options *opts);
 341 extern void decode_cmdline_options_to_array_default_mask (unsigned int argc,
 342                                                           const char **argv,
 343                                                           struct cl_decoded_option **decoded_options,
 344                                                           unsigned int *decoded_options_count);
 345 extern void set_default_handlers (struct cl_option_handlers *handlers,
 346                                   void (*target_option_override_hook) (void));
 347 extern void decode_options (struct gcc_options *opts,
 348                             struct gcc_options *opts_set,
 349                             struct cl_decoded_option *decoded_options,
 350                             unsigned int decoded_options_count,
 351                             location_t loc,
 352                             diagnostic_context *dc,
 353                             void (*target_option_override_hook) (void));
 354 extern int option_enabled (int opt_idx, void *opts);
 355 extern bool get_option_state (struct gcc_options *, int,
 356                               struct cl_option_state *);
 357 extern void set_option (struct gcc_options *opts,
 358                         struct gcc_options *opts_set,
 359                         int opt_index, int value, const char *arg, int kind,
 360                         location_t loc, diagnostic_context *dc);
 361 extern void *option_flag_var (int opt_index, struct gcc_options *opts);
 362 bool handle_generated_option (struct gcc_options *opts,
 363                               struct gcc_options *opts_set,
 364                               size_t opt_index, const char *arg, int value,
 365                               unsigned int lang_mask, int kind, location_t loc,
 366                               const struct cl_option_handlers *handlers,
 367                               bool generated_p, diagnostic_context *dc);
 368 void generate_option (size_t opt_index, const char *arg, int value,
 369                       unsigned int lang_mask,
 370                       struct cl_decoded_option *decoded);
 371 void generate_option_input_file (const char *file,
 372                                  struct cl_decoded_option *decoded);
 373 extern void read_cmdline_option (struct gcc_options *opts,
 374                                  struct gcc_options *opts_set,
 375                                  struct cl_decoded_option *decoded,
 376                                  location_t loc,
 377                                  unsigned int lang_mask,
 378                                  const struct cl_option_handlers *handlers,
 379                                  diagnostic_context *dc);
 380 extern void control_warning_option (unsigned int opt_index, int kind,
 381                                     const char *arg, bool imply, location_t loc,
 382                                     unsigned int lang_mask,
 383                                     const struct cl_option_handlers *handlers,
 384                                     struct gcc_options *opts,
 385                                     struct gcc_options *opts_set,
 386                                     diagnostic_context *dc);
 387 extern char *write_langs (unsigned int mask);
 388 extern void print_ignored_options (void);
 389 extern void handle_common_deferred_options (void);
 390 unsigned int parse_sanitizer_options (const char *, location_t, int,
 391                                       unsigned int, int, bool);
 392
 393 unsigned int parse_no_sanitize_attribute (char *value);
 394 extern bool common_handle_option (struct gcc_options *opts,
 395                                   struct gcc_options *opts_set,
 396                                   const struct cl_decoded_option *decoded,
 397                                   unsigned int lang_mask, int kind,
 398                                   location_t loc,
 399                                   const struct cl_option_handlers *handlers,
 400                                   diagnostic_context *dc,
 401                                   void (*target_option_override_hook) (void));
 402 extern bool target_handle_option (struct gcc_options *opts,
 403                                   struct gcc_options *opts_set,
 404                                   const struct cl_decoded_option *decoded,
 405                                   unsigned int lang_mask, int kind,
 406                                   location_t loc,
 407                                   const struct cl_option_handlers *handlers,
 408                                   diagnostic_context *dc,
 409                                   void (*target_option_override_hook) (void));
 410 extern void finish_options (struct gcc_options *opts,
 411                             struct gcc_options *opts_set,
 412                             location_t loc);
 413 extern void default_options_optimization (struct gcc_options *opts,
 414                                           struct gcc_options *opts_set,
 415                                           struct cl_decoded_option *decoded_options,
 416                                           unsigned int decoded_options_count,
 417                                           location_t loc,
 418                                           unsigned int lang_mask,
 419                                           const struct cl_option_handlers *handlers,
 420                                           diagnostic_context *dc);
 421 extern void set_struct_debug_option (struct gcc_options *opts,
 422                                      location_t loc,
 423                                      const char *value);
 424 extern bool opt_enum_arg_to_value (size_t opt_index, const char *arg,
 425                                    int *value, unsigned int lang_mask);
 426
 427 extern const struct sanitizer_opts_s
 428 {
 429   const char *const name;
 430   unsigned int flag;
 431   size_t len;
 432   bool can_recover;
 433 } sanitizer_opts[];
 434
 435 extern void add_misspelling_candidates (auto_vec<char *> *candidates,
 436                                         const struct cl_option *option,
 437                                         const char *base_option);
 438 extern const char *candidates_list_and_hint (const char *arg, char *&str,
 439                                              const auto_vec <const char *> &
 440                                              candidates);
 441
 442 #endif