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