gcc/opts.h

   1 /* Command line option handling.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
   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_OPTS_H
  22 #define GCC_OPTS_H
  23
  24 #include "input.h"
  25 #include "vec.h"
  26
  27 /* Specifies how a switch's VAR_VALUE relates to its FLAG_VAR.  */
  28 enum cl_var_type {
  29   /* The switch is enabled when FLAG_VAR is nonzero.  */
  30   CLVC_BOOLEAN,
  31
  32   /* The switch is enabled when FLAG_VAR == VAR_VALUE.  */
  33   CLVC_EQUAL,
  34
  35   /* The switch is enabled when VAR_VALUE is not set in FLAG_VAR.  */
  36   CLVC_BIT_CLEAR,
  37
  38   /* The switch is enabled when VAR_VALUE is set in FLAG_VAR.  */
  39   CLVC_BIT_SET,
  40
  41   /* The switch takes a string argument and FLAG_VAR points to that
  42      argument.  */
  43   CLVC_STRING,
  44
  45   /* The switch should be stored in the VEC pointed to by FLAG_VAR for
  46      later processing.  */
  47   CLVC_DEFER
  48 };
  49
  50 struct cl_option
  51 {
  52   const char *opt_text;
  53   const char *help;
  54   const char *missing_argument_error;
  55   const char *warn_message;
  56   const char *alias_arg;
  57   const char *neg_alias_arg;
  58   unsigned short alias_target;
  59   unsigned short back_chain;
  60   unsigned char opt_len;
  61   int neg_index;
  62   unsigned int flags;
  63   unsigned short flag_var_offset;
  64   enum cl_var_type var_type;
  65   int var_value;
  66 };
  67
  68 /* Records that the state of an option consists of SIZE bytes starting
  69    at DATA.  DATA might point to CH in some cases.  */
  70 struct cl_option_state {
  71   const void *data;
  72   size_t size;
  73   char ch;
  74 };
  75
  76 extern const struct cl_option cl_options[];
  77 extern const unsigned int cl_options_count;
  78 extern const char *const lang_names[];
  79 extern const unsigned int cl_lang_count;
  80
  81 #define CL_PARAMS               (1 << 11) /* Fake entry.  Used to display --param info with --help.  */
  82 #define CL_WARNING              (1 << 12) /* Enables an (optional) warning message.  */
  83 #define CL_OPTIMIZATION         (1 << 13) /* Enables an (optional) optimization.  */
  84 #define CL_DRIVER               (1 << 14) /* Driver option.  */
  85 #define CL_TARGET               (1 << 15) /* Target-specific option.  */
  86 #define CL_COMMON               (1 << 16) /* Language-independent.  */
  87
  88 #define CL_MIN_OPTION_CLASS     CL_PARAMS
  89 #define CL_MAX_OPTION_CLASS     CL_COMMON
  90
  91 /* From here on the bits describe attributes of the options.
  92    Before this point the bits have described the class of the option.
  93    This distinction is important because --help will not list options
  94    which only have these higher bits set.  */
  95
  96 /* Options marked with CL_SEPARATE take a number of separate arguments
  97    (1 to 4) that is one more than the number in this bit-field.  */
  98 #define CL_SEPARATE_NARGS_SHIFT 17
  99 #define CL_SEPARATE_NARGS_MASK  (3 << CL_SEPARATE_NARGS_SHIFT)
 100
 101 #define CL_SEPARATE_ALIAS       (1 << 19) /* Option is an alias when used with separate argument.  */
 102 #define CL_NO_DRIVER_ARG        (1 << 20) /* Option takes no argument in the driver.  */
 103 #define CL_REJECT_DRIVER        (1 << 21) /* Reject this option in the driver.  */
 104 #define CL_SAVE                 (1 << 22) /* Target-specific option for attribute.  */
 105 #define CL_DISABLED             (1 << 23) /* Disabled in this configuration.  */
 106 #define CL_REPORT               (1 << 24) /* Report argument with -fverbose-asm  */
 107 #define CL_JOINED               (1 << 25) /* If takes joined argument.  */
 108 #define CL_SEPARATE             (1 << 26) /* If takes a separate argument.  */
 109 #define CL_REJECT_NEGATIVE      (1 << 27) /* Reject no- form.  */
 110 #define CL_MISSING_OK           (1 << 28) /* Missing argument OK (joined).  */
 111 #define CL_UINTEGER             (1 << 29) /* Argument is an integer >=0.  */
 112 #define CL_UNDOCUMENTED         (1 << 30) /* Do not output with --help.  */
 113
 114 /* Possible ways in which a command-line option may be erroneous.
 115    These do not include not being known at all; an option index of
 116    OPT_SPECIAL_unknown is used for that.  */
 117
 118 #define CL_ERR_DISABLED         (1 << 0) /* Disabled in this configuration.  */
 119 #define CL_ERR_MISSING_ARG      (1 << 1) /* Argument required but missing.  */
 120 #define CL_ERR_WRONG_LANG       (1 << 2) /* Option for wrong language.  */
 121 #define CL_ERR_UINT_ARG         (1 << 3) /* Bad unsigned integer argument.  */
 122 #define CL_ERR_NEGATIVE         (1 << 4) /* Negative form of option
 123                                             not permitted (together
 124                                             with OPT_SPECIAL_unknown).  */
 125
 126 /* Structure describing the result of decoding an option.  */
 127
 128 struct cl_decoded_option
 129 {
 130   /* The index of this option, or an OPT_SPECIAL_* value for
 131      non-options and unknown options.  */
 132   size_t opt_index;
 133
 134   /* Any warning to give for use of this option, or NULL if none.  */
 135   const char *warn_message;
 136
 137   /* The string argument, or NULL if none.  For OPT_SPECIAL_* cases,
 138      the option or non-option command-line argument.  */
 139   const char *arg;
 140
 141   /* The original text of option plus arguments, with separate argv
 142      elements concatenated into one string with spaces separating
 143      them.  This is for such uses as diagnostics and
 144      -frecord-gcc-switches.  */
 145   const char *orig_option_with_args_text;
 146
 147   /* The canonical form of the option and its argument, for when it is
 148      necessary to reconstruct argv elements (in particular, for
 149      processing specs and passing options to subprocesses from the
 150      driver).  */
 151   const char *canonical_option[4];
 152
 153   /* The number of elements in the canonical form of the option and
 154      arguments; always at least 1.  */
 155   size_t canonical_option_num_elements;
 156
 157   /* For a boolean option, 1 for the true case and 0 for the "no-"
 158      case.  For an unsigned integer option, the value of the
 159      argument.  1 in all other cases.  */
 160   int value;
 161
 162   /* Any flags describing errors detected in this option.  */
 163   int errors;
 164 };
 165
 166 /* Structure describing an option deferred for handling after the main
 167    option handlers.  */
 168
 169 typedef struct
 170 {
 171   /* Elements from struct cl_decoded_option used for deferred
 172      options.  */
 173   size_t opt_index;
 174   const char *arg;
 175   int value;
 176 } cl_deferred_option;
 177 DEF_VEC_O(cl_deferred_option);
 178 DEF_VEC_ALLOC_O(cl_deferred_option,heap);
 179
 180 /* Structure describing a single option-handling callback.  */
 181
 182 struct cl_option_handler_func
 183 {
 184   /* The function called to handle the option.  */
 185   bool (*handler) (struct gcc_options *opts,
 186                    struct gcc_options *opts_set,
 187                    const struct cl_decoded_option *decoded,
 188                    unsigned int lang_mask, int kind, location_t loc,
 189                    const struct cl_option_handlers *handlers,
 190                    diagnostic_context *dc);
 191
 192   /* The mask that must have some bit in common with the flags for the
 193      option for this particular handler to be used.  */
 194   unsigned int mask;
 195 };
 196
 197 /* Structure describing the callbacks used in handling options.  */
 198
 199 struct cl_option_handlers
 200 {
 201   /* Callback for an unknown option to determine whether to give an
 202      error for it, and possibly store information to diagnose the
 203      option at a later point.  Return true if an error should be
 204      given, false otherwise.  */
 205   bool (*unknown_option_callback) (const struct cl_decoded_option *decoded);
 206
 207   /* Callback to handle, and possibly diagnose, an option for another
 208      language.  */
 209   void (*wrong_lang_callback) (const struct cl_decoded_option *decoded,
 210                                unsigned int lang_mask);
 211
 212   /* Callback to call after the successful handling of any option.  */
 213   void (*post_handling_callback) (const struct cl_decoded_option *decoded,
 214                                   unsigned int mask);
 215
 216   /* The number of individual handlers.  */
 217   size_t num_handlers;
 218
 219   /* The handlers themselves.  */
 220   struct cl_option_handler_func handlers[3];
 221 };
 222
 223 /* Input file names.  */
 224
 225 extern const char **in_fnames;
 226
 227 /* The count of input filenames.  */
 228
 229 extern unsigned num_in_fnames;
 230
 231 size_t find_opt (const char *input, int lang_mask);
 232 extern int integral_argument (const char *arg);
 233 extern void decode_cmdline_options_to_array (unsigned int argc,
 234                                              const char **argv,
 235                                              unsigned int lang_mask,
 236                                              struct cl_decoded_option **decoded_options,
 237                                              unsigned int *decoded_options_count);
 238 extern void init_options_once (void);
 239 extern void init_options_struct (struct gcc_options *opts,
 240                                  struct gcc_options *opts_set);
 241 extern void decode_cmdline_options_to_array_default_mask (unsigned int argc,
 242                                                           const char **argv,
 243                                                           struct cl_decoded_option **decoded_options,
 244                                                           unsigned int *decoded_options_count);
 245 extern void set_default_handlers (struct cl_option_handlers *handlers);
 246 extern void decode_options (struct gcc_options *opts,
 247                             struct gcc_options *opts_set,
 248                             struct cl_decoded_option *decoded_options,
 249                             unsigned int decoded_options_count,
 250                             location_t loc,
 251                             diagnostic_context *dc);
 252 extern int option_enabled (int opt_idx, void *opts);
 253 extern bool get_option_state (struct gcc_options *, int,
 254                               struct cl_option_state *);
 255 extern void set_option (struct gcc_options *opts,
 256                         struct gcc_options *opts_set,
 257                         int opt_index, int value, const char *arg, int kind,
 258                         location_t loc, diagnostic_context *dc);
 259 extern void *option_flag_var (int opt_index, struct gcc_options *opts);
 260 bool handle_generated_option (struct gcc_options *opts,
 261                               struct gcc_options *opts_set,
 262                               size_t opt_index, const char *arg, int value,
 263                               unsigned int lang_mask, int kind, location_t loc,
 264                               const struct cl_option_handlers *handlers,
 265                               diagnostic_context *dc);
 266 void generate_option (size_t opt_index, const char *arg, int value,
 267                       unsigned int lang_mask,
 268                       struct cl_decoded_option *decoded);
 269 void generate_option_input_file (const char *file,
 270                                  struct cl_decoded_option *decoded);
 271 extern void read_cmdline_option (struct gcc_options *opts,
 272                                  struct gcc_options *opts_set,
 273                                  struct cl_decoded_option *decoded,
 274                                  location_t loc,
 275                                  unsigned int lang_mask,
 276                                  const struct cl_option_handlers *handlers,
 277                                  diagnostic_context *dc);
 278 extern void control_warning_option (unsigned int opt_index, int kind,
 279                                     bool imply, location_t loc,
 280                                     unsigned int lang_mask,
 281                                     const struct cl_option_handlers *handlers,
 282                                     struct gcc_options *opts,
 283                                     struct gcc_options *opts_set,
 284                                     diagnostic_context *dc);
 285 extern void print_ignored_options (void);
 286 extern void handle_common_deferred_options (void);
 287 extern bool common_handle_option (struct gcc_options *opts,
 288                                   struct gcc_options *opts_set,
 289                                   const struct cl_decoded_option *decoded,
 290                                   unsigned int lang_mask, int kind,
 291                                   location_t loc,
 292                                   const struct cl_option_handlers *handlers,
 293                                   diagnostic_context *dc);
 294 extern bool target_handle_option (struct gcc_options *opts,
 295                                   struct gcc_options *opts_set,
 296                                   const struct cl_decoded_option *decoded,
 297                                   unsigned int lang_mask, int kind,
 298                                   location_t loc,
 299                                   const struct cl_option_handlers *handlers,
 300                                   diagnostic_context *dc);
 301 extern void finish_options (struct gcc_options *opts,
 302                             struct gcc_options *opts_set,
 303                             location_t loc);
 304 extern void default_options_optimization (struct gcc_options *opts,
 305                                           struct gcc_options *opts_set,
 306                                           struct cl_decoded_option *decoded_options,
 307                                           unsigned int decoded_options_count,
 308                                           location_t loc,
 309                                           unsigned int lang_mask,
 310                                           const struct cl_option_handlers *handlers,
 311                                           diagnostic_context *dc);
 312 extern void set_struct_debug_option (struct gcc_options *opts,
 313                                      location_t loc,
 314                                      const char *value);
 315 #endif