gcc/flags.h

   1 /* Compilation switch flag definitions for GCC.
   2    Copyright (C) 1987, 1988, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
   3    2003
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to the Free
  20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21 02111-1307, USA.  */
  22
  23 #ifndef GCC_FLAGS_H
  24 #define GCC_FLAGS_H
  25
  26 enum debug_info_type
  27 {
  28   NO_DEBUG,         /* Write no debug info.  */
  29   DBX_DEBUG,        /* Write BSD .stabs for DBX (using dbxout.c).  */
  30   SDB_DEBUG,        /* Write COFF for (old) SDB (using sdbout.c).  */
  31   DWARF_DEBUG,      /* Write Dwarf debug info (using dwarfout.c).  */
  32   DWARF2_DEBUG,     /* Write Dwarf v2 debug info (using dwarf2out.c).  */
  33   XCOFF_DEBUG,      /* Write IBM/Xcoff debug info (using dbxout.c).  */
  34   VMS_DEBUG,        /* Write VMS debug info (using vmsdbgout.c).  */
  35   VMS_AND_DWARF2_DEBUG /* Write VMS debug info (using vmsdbgout.c).
  36                           and DWARF v2 debug info (using dwarf2out.c).  */
  37 };
  38
  39 /* Specify which kind of debugging info to generate.  */
  40 extern enum debug_info_type write_symbols;
  41
  42 /* Names of debug_info_type, for error messages.  */
  43 extern const char *const debug_type_names[];
  44
  45 enum debug_info_level
  46 {
  47   DINFO_LEVEL_NONE,     /* Write no debugging info.  */
  48   DINFO_LEVEL_TERSE,    /* Write minimal info to support tracebacks only.  */
  49   DINFO_LEVEL_NORMAL,   /* Write info for all declarations (and line table).  */
  50   DINFO_LEVEL_VERBOSE   /* Write normal info plus #define/#undef info.  */
  51 };
  52
  53 /* Specify how much debugging info to generate.  */
  54 extern enum debug_info_level debug_info_level;
  55
  56 /* Nonzero means use GNU-only extensions in the generated symbolic
  57    debugging information.  */
  58 extern int use_gnu_debug_info_extensions;
  59
  60 /* Nonzero means do optimizations.  -opt.  */
  61
  62 extern int optimize;
  63
  64 /* Nonzero means optimize for size.  -Os.  */
  65
  66 extern int optimize_size;
  67
  68 /* Don't print functions as they are compiled and don't print
  69    times taken by the various passes.  -quiet.  */
  70
  71 extern int quiet_flag;
  72
  73 /* Print memory still in use at end of compilation (which may have little
  74    to do with peak memory consumption).  -fmem-report.  */
  75
  76 extern int mem_report;
  77
  78 /* Don't print warning messages.  -w.  */
  79
  80 extern bool inhibit_warnings;
  81
  82 /* Don't suppress warnings from system headers.  -Wsystem-headers.  */
  83
  84 extern bool warn_system_headers;
  85
  86 /* Do print extra warnings (such as for uninitialized variables).
  87    -W/-Wextra.  */
  88
  89 extern bool extra_warnings;
  90
  91 /* If -Werror.  */
  92
  93 extern bool warnings_are_errors;
  94
  95 /* Nonzero to warn about unused variables, functions et.al.  Use
  96    set_Wunused() to update the -Wunused-* flags that correspond to the
  97    -Wunused option.  */
  98
  99 extern void set_Wunused PARAMS ((int setting));
 100
 101 extern bool warn_unused_function;
 102 extern bool warn_unused_label;
 103 extern bool warn_unused_parameter;
 104 extern bool warn_unused_variable;
 105 extern bool warn_unused_value;
 106
 107 /* Nonzero to warn about code which is never reached.  */
 108
 109 extern bool warn_notreached;
 110
 111 /* Nonzero means warn if inline function is too large.  */
 112
 113 extern bool warn_inline;
 114
 115 /* Nonzero to warn about variables used before they are initialized.  */
 116
 117 extern int warn_uninitialized;
 118
 119 /* Nonzero means warn about all declarations which shadow others.  */
 120
 121 extern bool warn_shadow;
 122
 123 /* Warn if a switch on an enum, that does not have a default case,
 124    fails to have a case for every enum value.  */
 125
 126 extern bool warn_switch;
 127
 128 /* Warn if a switch does not have a default case.  */
 129
 130 extern bool warn_switch_default;
 131
 132 /* Warn if a switch on an enum fails to have a case for every enum
 133    value (regardless of the presence or otherwise of a default case).  */
 134
 135 extern bool warn_switch_enum;
 136
 137 /* Nonzero means warn about function definitions that default the return type
 138    or that use a null return and have a return-type other than void.  */
 139
 140 extern int warn_return_type;
 141
 142 /* Warn about functions which might be candidates for attribute noreturn.  */
 143
 144 extern bool warn_missing_noreturn;
 145
 146 /* Nonzero means warn about pointer casts that increase the required
 147    alignment of the target type (and might therefore lead to a crash
 148    due to a misaligned access).  */
 149
 150 extern bool warn_cast_align;
 151
 152 /* Nonzero means warn about any objects definitions whose size is larger
 153    than N bytes.  Also want about function definitions whose returned
 154    values are larger than N bytes. The value N is in `larger_than_size'.  */
 155
 156 extern bool warn_larger_than;
 157 extern HOST_WIDE_INT larger_than_size;
 158
 159 /* Warn if a function returns an aggregate,
 160    since there are often incompatible calling conventions for doing this.  */
 161
 162 extern bool warn_aggregate_return;
 163
 164 /* Warn if packed attribute on struct is unnecessary and inefficient.  */
 165
 166 extern bool warn_packed;
 167
 168 /* Warn when gcc pads a structure to an alignment boundary.  */
 169
 170 extern bool warn_padded;
 171
 172 /* Warn when an optimization pass is disabled.  */
 173
 174 extern bool warn_disabled_optimization;
 175
 176 /* Nonzero means warn about uses of __attribute__((deprecated))
 177    declarations.  */
 178
 179 extern bool warn_deprecated_decl;
 180
 181 /* Nonzero means warn about constructs which might not be strict
 182    aliasing safe.  */
 183
 184 extern bool warn_strict_aliasing;
 185
 186 /* Nonzero if generating code to do profiling.  */
 187
 188 extern int profile_flag;
 189
 190 /* Nonzero if generating code to profile program flow graph arcs.  */
 191
 192 extern int profile_arc_flag;
 193
 194 /* Nonzero if generating info for gcov to calculate line test coverage.  */
 195
 196 extern int flag_test_coverage;
 197
 198 /* Nonzero indicates that branch taken probabilities should be calculated.  */
 199
 200 extern int flag_branch_probabilities;
 201
 202 /* Nonzero if basic blocks should be reordered.  */
 203
 204 extern int flag_reorder_blocks;
 205
 206 /* Nonzero if functions should be reordered.  */
 207
 208 extern int flag_reorder_functions;
 209
 210 /* Nonzero if registers should be renamed.  */
 211
 212 extern int flag_rename_registers;
 213
 214 /* Nonzero for -pedantic switch: warn about anything
 215    that standard C forbids.  */
 216
 217 extern int pedantic;
 218
 219 /* Temporarily suppress certain warnings.
 220    This is set while reading code from a system header file.  */
 221
 222 extern int in_system_header;
 223
 224 /* Nonzero for -dp: annotate the assembly with a comment describing the
 225    pattern and alternative used.  */
 226
 227 extern int flag_print_asm_name;
 228 \f
 229 /* Now the symbols that are set with `-f' switches.  */
 230
 231 /* Nonzero means `char' should be signed.  */
 232
 233 extern int flag_signed_char;
 234
 235 /* Nonzero means give an enum type only as many bytes as it needs.  */
 236
 237 extern int flag_short_enums;
 238
 239 /* Nonzero for -fcaller-saves: allocate values in regs that need to
 240    be saved across function calls, if that produces overall better code.
 241    Optional now, so people can test it.  */
 242
 243 extern int flag_caller_saves;
 244
 245 /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
 246
 247 extern int flag_pcc_struct_return;
 248
 249 /* Nonzero for -fforce-mem: load memory value into a register
 250    before arithmetic on it.  This makes better cse but slower compilation.  */
 251
 252 extern int flag_force_mem;
 253
 254 /* Nonzero for -fforce-addr: load memory address into a register before
 255    reference to memory.  This makes better cse but slower compilation.  */
 256
 257 extern int flag_force_addr;
 258
 259 /* Nonzero for -fdefer-pop: don't pop args after each function call;
 260    instead save them up to pop many calls' args with one insns.  */
 261
 262 extern int flag_defer_pop;
 263
 264 /* Nonzero for -ffloat-store: don't allocate floats and doubles
 265    in extended-precision registers.  */
 266
 267 extern int flag_float_store;
 268
 269 /* Nonzero enables strength-reduction in loop.c.  */
 270
 271 extern int flag_strength_reduce;
 272
 273 /* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
 274    number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
 275    UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
 276    unrolled.  */
 277
 278 extern int flag_old_unroll_loops;
 279
 280 /* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
 281    This is generally not a win.  */
 282
 283 extern int flag_old_unroll_all_loops;
 284
 285 /* Nonzero forces all invariant computations in loops to be moved
 286    outside the loop.  */
 287
 288 extern int flag_move_all_movables;
 289
 290 /* Nonzero enables prefetch optimizations for arrays in loops.  */
 291
 292 extern int flag_prefetch_loop_arrays;
 293
 294 /* Nonzero forces all general induction variables in loops to be
 295    strength reduced.  */
 296
 297 extern int flag_reduce_all_givs;
 298
 299 /* Nonzero for -fcse-follow-jumps:
 300    have cse follow jumps to do a more extensive job.  */
 301
 302 extern int flag_cse_follow_jumps;
 303
 304 /* Nonzero for -fcse-skip-blocks:
 305    have cse follow a branch around a block.  */
 306
 307 extern int flag_cse_skip_blocks;
 308
 309 /* Nonzero for -fexpensive-optimizations:
 310    perform miscellaneous relatively-expensive optimizations.  */
 311 extern int flag_expensive_optimizations;
 312
 313 /* Nonzero for -fwritable-strings:
 314    store string constants in data segment and don't uniquize them.  */
 315
 316 extern int flag_writable_strings;
 317
 318 /* Nonzero means don't put addresses of constant functions in registers.
 319    Used for compiling the Unix kernel, where strange substitutions are
 320    done on the assembly output.  */
 321
 322 extern int flag_no_function_cse;
 323
 324 /* Nonzero for -fomit-frame-pointer:
 325    don't make a frame pointer in simple functions that don't require one.  */
 326
 327 extern int flag_omit_frame_pointer;
 328
 329 /* Nonzero to inhibit use of define_optimization peephole opts.  */
 330
 331 extern int flag_no_peephole;
 332
 333 /* Nonzero allows GCC to optimize sibling and tail recursive calls.  */
 334
 335 extern int flag_optimize_sibling_calls;
 336
 337 /* Nonzero means the front end generally wants `errno' maintained by math
 338    operations, like built-in SQRT.  */
 339
 340 extern int flag_errno_math;
 341
 342 /* Nonzero means that unsafe floating-point math optimizations are allowed
 343    for the sake of speed.  IEEE compliance is not guaranteed, and operations
 344    are allowed to assume that their arguments and results are "normal"
 345    (e.g., nonnegative for SQRT).  */
 346
 347 extern int flag_unsafe_math_optimizations;
 348
 349 /* Nonzero means that no NaNs or +-Infs are expected.  */
 350
 351 extern int flag_finite_math_only;
 352
 353 /* Zero means that floating-point math operations cannot generate a
 354    (user-visible) trap.  This is the case, for example, in nonstop
 355    IEEE 754 arithmetic.  */
 356
 357 extern int flag_trapping_math;
 358
 359 /* 0 means straightforward implementation of complex divide acceptable.
 360    1 means wide ranges of inputs must work for complex divide.
 361    2 means C99-like requirements for complex divide (not yet implemented).  */
 362
 363 extern int flag_complex_divide_method;
 364
 365 /* Nonzero means to run loop optimizations twice.  */
 366
 367 extern int flag_rerun_loop_opt;
 368
 369 /* Nonzero means make functions that look like good inline candidates
 370    go inline.  */
 371
 372 extern int flag_inline_functions;
 373
 374 /* Nonzero for -fkeep-inline-functions: even if we make a function
 375    go inline everywhere, keep its definition around for debugging
 376    purposes.  */
 377
 378 extern int flag_keep_inline_functions;
 379
 380 /* Nonzero means that functions declared `inline' will be treated
 381    as `static'.  Prevents generation of zillions of copies of unused
 382    static inline functions; instead, `inlines' are written out
 383    only when actually used.  Used in conjunction with -g.  Also
 384    does the right thing with #pragma interface.  */
 385
 386 extern int flag_no_inline;
 387
 388 /* Nonzero means that we don't want inlining by virtue of -fno-inline,
 389    not just because the tree inliner turned us off.  */
 390
 391 extern int flag_really_no_inline;
 392
 393 /* Nonzero if we are only using compiler to check syntax errors.  */
 394
 395 extern int flag_syntax_only;
 396
 397 /* Nonzero means we should save auxiliary info into a .X file.  */
 398
 399 extern int flag_gen_aux_info;
 400
 401 /* Nonzero means make the text shared if supported.  */
 402
 403 extern int flag_shared_data;
 404
 405 /* flag_schedule_insns means schedule insns within basic blocks (before
 406    local_alloc).
 407    flag_schedule_insns_after_reload means schedule insns after
 408    global_alloc.  */
 409
 410 extern int flag_schedule_insns;
 411 extern int flag_schedule_insns_after_reload;
 412 extern int flag_sched2_use_superblocks;
 413 extern int flag_sched2_use_traces;
 414
 415 /* The following flags have effect only for scheduling before register
 416    allocation:
 417
 418    flag_schedule_interblock means schedule insns across basic blocks.
 419    flag_schedule_speculative means allow speculative motion of non-load insns.
 420    flag_schedule_speculative_load means allow speculative motion of some
 421    load insns.
 422    flag_schedule_speculative_load_dangerous allows speculative motion of more
 423    load insns.  */
 424
 425 extern int flag_schedule_interblock;
 426 extern int flag_schedule_speculative;
 427 extern int flag_schedule_speculative_load;
 428 extern int flag_schedule_speculative_load_dangerous;
 429
 430 /* flag_branch_on_count_reg means try to replace add-1,compare,branch tupple
 431    by a cheaper branch, on a count register.  */
 432 extern int flag_branch_on_count_reg;
 433
 434 /* This option is set to 1 on -fsingle-precision-constant option which is
 435    used to convert the floating point constants to single precision
 436    constants.  */
 437
 438 extern int flag_single_precision_constant;
 439
 440 /* Nonzero means put things in delayed-branch slots if supported.  */
 441
 442 extern int flag_delayed_branch;
 443
 444 /* Nonzero means suppress output of instruction numbers and line number
 445    notes in debugging dumps.  */
 446
 447 extern int flag_dump_unnumbered;
 448
 449 /* Nonzero means change certain warnings into errors.
 450    Usually these are warnings about failure to conform to some standard.  */
 451
 452 extern int flag_pedantic_errors;
 453
 454 /* Nonzero means generate position-independent code.  1 vs 2 for a
 455    target-dependent "small" or "large" mode.  */
 456
 457 extern int flag_pic;
 458
 459 /* Nonzero if we are compiling position independent code for executable.
 460    1 vs 2 for a target-dependent "small" or "large" mode.  */
 461
 462 extern int flag_pie;
 463
 464 /* Nonzero if we are compiling code for a shared library, zero for
 465    executable.  */
 466
 467 extern int flag_shlib;
 468
 469 /* Nonzero means generate extra code for exception handling and enable
 470    exception handling.  */
 471
 472 extern int flag_exceptions;
 473
 474 /* Nonzero means generate frame unwind info table when supported */
 475
 476 extern int flag_unwind_tables;
 477
 478 /* Nonzero means generate frame unwind info table exact at each insn boundary */
 479
 480 extern int flag_asynchronous_unwind_tables;
 481
 482 /* Nonzero means don't place uninitialized global data in common storage
 483    by default.  */
 484
 485 extern int flag_no_common;
 486
 487 /* -finhibit-size-directive inhibits output of .size for ELF.
 488    This is used only for compiling crtstuff.c,
 489    and it may be extended to other effects
 490    needed for crtstuff.c on other systems.  */
 491 extern int flag_inhibit_size_directive;
 492
 493 /* Nonzero means place each function into its own section on those platforms
 494    which support arbitrary section names and unlimited numbers of sections.  */
 495
 496 extern int flag_function_sections;
 497
 498 /* ... and similar for data.  */
 499
 500 extern int flag_data_sections;
 501
 502 /* -fverbose-asm causes extra commentary information to be produced in
 503    the generated assembly code (to make it more readable).  This option
 504    is generally only of use to those who actually need to read the
 505    generated assembly code (perhaps while debugging the compiler itself).
 506    -fno-verbose-asm, the default, causes the extra information
 507    to not be added and is useful when comparing two assembler files.  */
 508
 509 extern int flag_verbose_asm;
 510
 511 /* -dA causes debug information to be produced in
 512    the generated assembly code (to make it more readable).  This option
 513    is generally only of use to those who actually need to read the
 514    generated assembly code (perhaps while debugging the compiler itself).
 515    Currently, this switch is only used by dwarfout.c; however, it is intended
 516    to be a catchall for printing debug information in the assembler file.  */
 517
 518 extern int flag_debug_asm;
 519
 520 extern int flag_dump_rtl_in_asm;
 521
 522 /* Greater than zero if user symbols are prepended by a leading underscore
 523    in generated assembly code.  */
 524 extern int flag_leading_underscore;
 525
 526 /* -fgnu-linker specifies use of the GNU linker for initializations.
 527    -fno-gnu-linker says that collect will be used.  */
 528 extern int flag_gnu_linker;
 529
 530 /* Tag all structures with __attribute__(packed) */
 531 extern int flag_pack_struct;
 532
 533 /* This flag is only tested if alias checking is enabled.
 534    0 if pointer arguments may alias each other.  True in C.
 535    1 if pointer arguments may not alias each other but may alias
 536    global variables.
 537    2 if pointer arguments may not alias each other and may not
 538    alias global variables.  True in Fortran.
 539    The value is ignored if flag_alias_check is 0.  */
 540 extern int flag_argument_noalias;
 541
 542 /* Nonzero if we should do (language-dependent) alias analysis.
 543    Typically, this analysis will assume that expressions of certain
 544    types do not alias expressions of certain other types.  Only used
 545    if alias analysis (in general) is enabled.  */
 546 extern int flag_strict_aliasing;
 547
 548 /* Emit code to probe the stack, to help detect stack overflow; also
 549    may cause large objects to be allocated dynamically.  */
 550 extern int flag_stack_check;
 551
 552 /* Do the full regmove optimization pass.  */
 553 extern int flag_regmove;
 554
 555 /* Instrument functions with calls at entry and exit, for profiling.  */
 556 extern int flag_instrument_function_entry_exit;
 557
 558 /* Perform a peephole pass before sched2.  */
 559 extern int flag_peephole2;
 560
 561 /* Try to guess branch probabilities.  */
 562 extern int flag_guess_branch_prob;
 563
 564 /* -fcheck-bounds causes gcc to generate array bounds checks.
 565    For C, C++ and ObjC: defaults off.
 566    For Java: defaults to on.
 567    For Fortran: defaults to off.  */
 568 extern int flag_bounds_check;
 569
 570 /* This will attempt to merge constant section constants, if 1 only
 571    string constants and constants from constant pool, if 2 also constant
 572    variables.  */
 573 extern int flag_merge_constants;
 574
 575 /* If one, renumber instruction UIDs to reduce the number of
 576    unused UIDs if there are a lot of instructions.  If greater than
 577    one, unconditionally renumber instruction UIDs.  */
 578 extern int flag_renumber_insns;
 579 \f
 580 /* Other basic status info about current function.  */
 581
 582 /* Nonzero means current function must be given a frame pointer.
 583    Set in stmt.c if anything is allocated on the stack there.
 584    Set in reload1.c if anything is allocated on the stack there.  */
 585
 586 extern int frame_pointer_needed;
 587
 588 /* Nonzero if the generated code should trap on signed overflow
 589    for PLUS / SUB / MULT.  */
 590 extern int flag_trapv;
 591
 592 /* Nonzero if the signed arithmetic overflow should wrap around.  */
 593 extern int flag_wrapv;
 594
 595 /* Value of the -G xx switch, and whether it was passed or not.  */
 596 extern unsigned HOST_WIDE_INT g_switch_value;
 597 extern bool g_switch_set;
 598
 599 /* Values of the -falign-* flags: how much to align labels in code.
 600    0 means `use default', 1 means `don't align'.
 601    For each variable, there is an _log variant which is the power
 602    of two not less than the variable, for .align output.  */
 603
 604 extern int align_loops;
 605 extern int align_loops_log;
 606 extern int align_loops_max_skip;
 607 extern int align_jumps;
 608 extern int align_jumps_log;
 609 extern int align_jumps_max_skip;
 610 extern int align_labels;
 611 extern int align_labels_log;
 612 extern int align_labels_max_skip;
 613 extern int align_functions;
 614 extern int align_functions_log;
 615
 616 /* Like align_functions_log above, but used by front-ends to force the
 617    minimum function alignment.  Zero means no alignment is forced.  */
 618 extern int force_align_functions_log;
 619
 620 /* Nonzero if we dump in VCG format, not plain text.  */
 621 extern int dump_for_graph;
 622
 623 /* Selection of the graph form.  */
 624 enum graph_dump_types
 625 {
 626   no_graph = 0,
 627   vcg
 628 };
 629 extern enum graph_dump_types graph_dump_format;
 630
 631 /* Nonzero means ignore `#ident' directives.  0 means handle them.
 632    On SVR4 targets, it also controls whether or not to emit a
 633    string identifying the compiler.  */
 634
 635 extern int flag_no_ident;
 636
 637 /* Nonzero means perform global CSE.  */
 638
 639 extern int flag_gcse;
 640
 641 /* Nonzero if we want to perform enhanced load motion during gcse.  */
 642
 643 extern int flag_gcse_lm;
 644
 645 /* Nonzero if we want to perform store motion after gcse.  */
 646
 647 extern int flag_gcse_sm;
 648
 649 /* Perform branch target register optimization before prologue / epilogue
 650    threading.  */
 651
 652 extern int flag_branch_target_load_optimize;
 653
 654 /* Perform branch target register optimization after prologue / epilogue
 655    threading and jump2.  */
 656
 657 extern int flag_branch_target_load_optimize2;
 658
 659
 660 /* Nonzero means we should do dwarf2 duplicate elimination.  */
 661
 662 extern int flag_eliminate_dwarf2_dups;
 663
 664 /* Nonzero means we should do unused type elimination.  */
 665
 666 extern int flag_eliminate_unused_debug_types;
 667
 668 /* Nonzero means to collect statistics which might be expensive
 669    and to print them when we are done.  */
 670 extern int flag_detailed_statistics;
 671
 672 /* Nonzero means enable synchronous exceptions for non-call instructions.  */
 673 extern int flag_non_call_exceptions;
 674
 675 /* Nonzero means put zero initialized data in the bss section.  */
 676 extern int flag_zero_initialized_in_bss;
 677
 678 /* Nonzero means disable transformations observable by signaling NaNs.  */
 679 extern int flag_signaling_nans;
 680
 681 extern int flag_unit_at_a_time;
 682
 683 /* A string that's used when a random name is required.  NULL means
 684    to make it really random.  */
 685
 686 extern const char *flag_random_seed;
 687
 688 /* True if the given mode has a NaN representation and the treatment of
 689    NaN operands is important.  Certain optimizations, such as folding
 690    x * 0 into x, are not correct for NaN operands, and are normally
 691    disabled for modes with NaNs.  The user can ask for them to be
 692    done anyway using the -funsafe-math-optimizations switch.  */
 693 #define HONOR_NANS(MODE) \
 694   (MODE_HAS_NANS (MODE) && !flag_finite_math_only)
 695
 696 /* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs).  */
 697 #define HONOR_SNANS(MODE) (flag_signaling_nans && HONOR_NANS (MODE))
 698
 699 /* As for HONOR_NANS, but true if the mode can represent infinity and
 700    the treatment of infinite values is important.  */
 701 #define HONOR_INFINITIES(MODE) \
 702   (MODE_HAS_INFINITIES (MODE) && !flag_finite_math_only)
 703
 704 /* Like HONOR_NANS, but true if the given mode distinguishes between
 705    positive and negative zero, and the sign of zero is important.  */
 706 #define HONOR_SIGNED_ZEROS(MODE) \
 707   (MODE_HAS_SIGNED_ZEROS (MODE) && !flag_unsafe_math_optimizations)
 708
 709 /* Like HONOR_NANS, but true if given mode supports sign-dependent rounding,
 710    and the rounding mode is important.  */
 711 #define HONOR_SIGN_DEPENDENT_ROUNDING(MODE) \
 712   (MODE_HAS_SIGN_DEPENDENT_ROUNDING (MODE) && !flag_unsafe_math_optimizations)
 713
 714 #endif /* ! GCC_FLAGS_H */