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