gcc/opts.h

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