/* Compilation switch flag definitions for GCC.
- Copyright (C) 1987, 1988, 1994, 1995, 1996, 1997, 1998, 1999, 2000
+ Copyright (C) 1987, 1988, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002
Free Software Foundation, Inc.
This file is part of GCC.
DWARF_DEBUG, /* Write Dwarf debug info (using dwarfout.c). */
DWARF2_DEBUG, /* Write Dwarf v2 debug info (using dwarf2out.c). */
XCOFF_DEBUG, /* Write IBM/Xcoff debug info (using dbxout.c). */
- VMS_DEBUG, /* Write VMS debug info (using vmsdbgout.c). */
+ VMS_DEBUG, /* Write VMS debug info (using vmsdbgout.c). */
VMS_AND_DWARF2_DEBUG /* Write VMS debug info (using vmsdbgout.c).
- and DWARF v2 debug info (using dwarf2out.c). */
+ and DWARF v2 debug info (using dwarf2out.c). */
};
/* Specify which kind of debugging info to generate. */
extern enum debug_info_type write_symbols;
+/* Names of debug_info_type, for error messages. */
+extern const char *const debug_type_names[];
+
enum debug_info_level
{
DINFO_LEVEL_NONE, /* Write no debugging info. */
extern int quiet_flag;
-/* Print times taken by the various passes. -ftime-report. */
-
-extern int time_report;
-
/* Print memory still in use at end of compilation (which may have little
to do with peak memory consumption). -fmem-report. */
extern int warn_system_headers;
-/* Do print extra warnings (such as for uninitialized variables). -W. */
+/* Do print extra warnings (such as for uninitialized variables).
+ -W/-Wextra. */
extern int extra_warnings;
extern int warn_shadow;
-/* Warn if a switch on an enum fails to have a case for every enum value. */
+/* Warn if a switch on an enum, that does not have a default case,
+ fails to have a case for every enum value. */
extern int warn_switch;
+/* Warn if a switch does not have a default case. */
+
+extern int warn_switch_default;
+
+/* Warn if a switch on an enum fails to have a case for every enum
+ value (regardless of the presence or otherwise of a default case). */
+
+extern int warn_switch_enum;
+
/* Nonzero means warn about function definitions that default the return type
or that use a null return and have a return-type other than void. */
extern int warn_disabled_optimization;
+/* Nonzero means warn about uses of __attribute__((deprecated))
+ declarations. */
+
+extern int warn_deprecated_decl;
+
+/* Nonzero means warn about constructs which might not be strict
+ aliasing safe. */
+
+extern int warn_strict_aliasing;
+
/* Nonzero if generating code to do profiling. */
extern int profile_flag;
extern int flag_reorder_blocks;
+/* Nonzero if functions should be reordered. */
+
+extern int flag_reorder_functions;
+
/* Nonzero if registers should be renamed. */
extern int flag_rename_registers;
UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
unrolled. */
-extern int flag_unroll_loops;
+extern int flag_old_unroll_loops;
/* Nonzero enables loop unrolling in unroll.c. All loops are unrolled.
This is generally not a win. */
-extern int flag_unroll_all_loops;
+extern int flag_old_unroll_all_loops;
/* Nonzero forces all invariant computations in loops to be moved
outside the loop. */
extern int flag_move_all_movables;
+/* Nonzero enables prefetch optimizations for arrays in loops. */
+
+extern int flag_prefetch_loop_arrays;
+
/* Nonzero forces all general induction variables in loops to be
strength reduced. */
extern int flag_no_peephole;
-/* Nonzero means all references through pointers are volatile. */
-
-extern int flag_volatile;
-
-/* Nonzero means treat all global and extern variables as volatile. */
-
-extern int flag_volatile_global;
-
-/* Nonzero means treat all static variables as volatile. */
-
-extern int flag_volatile_static;
-
/* Nonzero allows GCC to optimize sibling and tail recursive calls. */
extern int flag_optimize_sibling_calls;
extern int flag_unsafe_math_optimizations;
+/* Nonzero means that no NaNs or +-Infs are expected. */
+
+extern int flag_finite_math_only;
+
/* Zero means that floating-point math operations cannot generate a
(user-visible) trap. This is the case, for example, in nonstop
IEEE 754 arithmetic. */
extern int flag_no_inline;
+/* Nonzero means that we don't want inlining by virtue of -fno-inline,
+ not just because the tree inliner turned us off. */
+
+extern int flag_really_no_inline;
+
/* Nonzero if we are only using compiler to check syntax errors. */
extern int flag_syntax_only;
extern int flag_schedule_insns;
extern int flag_schedule_insns_after_reload;
+extern int flag_sched2_use_superblocks;
+extern int flag_sched2_use_traces;
/* The following flags have effect only for scheduling before register
allocation:
- flag_schedule_interblock means schedule insns accross basic blocks.
+ flag_schedule_interblock means schedule insns across basic blocks.
flag_schedule_speculative means allow speculative motion of non-load insns.
flag_schedule_speculative_load means allow speculative motion of some
load insns.
extern int flag_dump_unnumbered;
-/* Nonzero means pretend it is OK to examine bits of target floats,
- even if that isn't true. The resulting code will have incorrect constants,
- but the same series of instructions that the native compiler would make. */
-
-extern int flag_pretend_float;
-
/* Nonzero means change certain warnings into errors.
Usually these are warnings about failure to conform to some standard. */
extern int flag_pedantic_errors;
-/* Nonzero means generate position-independent code.
- This is not fully implemented yet. */
+/* Nonzero means generate position-independent code. 1 vs 2 for a
+ target-dependent "small" or "large" mode. */
extern int flag_pic;
extern int flag_dump_rtl_in_asm;
+/* Greater than zero if user symbols are prepended by a leading underscore
+ in generated assembly code. */
+extern int flag_leading_underscore;
+
/* -fgnu-linker specifies use of the GNU linker for initializations.
-fno-gnu-linker says that collect will be used. */
extern int flag_gnu_linker;
/* Perform a peephole pass before sched2. */
extern int flag_peephole2;
-/* Try to guess branch probablities. */
+/* Try to guess branch probabilities. */
extern int flag_guess_branch_prob;
-/* -fbounded-pointers causes gcc to compile pointers as composite
- objects occupying three words: the pointer value, the base address
- of the referent object, and the address immediately beyond the end
- of the referent object. The base and extent allow us to perform
- runtime bounds checking. -fbounded-pointers implies -fcheck-bounds. */
-extern int flag_bounded_pointers;
-
/* -fcheck-bounds causes gcc to generate array bounds checks.
- For C, C++: defaults to value of flag_bounded_pointers.
- For ObjC: defaults to off.
+ For C, C++ and ObjC: defaults off.
For Java: defaults to on.
- For Fortran: defaults to off.
- For CHILL: defaults to off. */
+ For Fortran: defaults to off. */
extern int flag_bounds_check;
/* This will attempt to merge constant section constants, if 1 only
extern int align_functions;
extern int align_functions_log;
+/* Like align_functions_log above, but used by front-ends to force the
+ minimum function alignment. Zero means no alignment is forced. */
+extern int force_align_functions_log;
+
/* Nonzero if we dump in VCG format, not plain text. */
extern int dump_for_graph;
extern int flag_no_ident;
+/* Nonzero means perform global CSE. */
+
+extern int flag_gcse;
+
/* Nonzero if we want to perform enhanced load motion during gcse. */
extern int flag_gcse_lm;
extern int flag_eliminate_dwarf2_dups;
-/* Non-zero means to collect statistics which might be expensive
+/* Nonzero means we should do unused type elimination. */
+
+extern int flag_eliminate_unused_debug_types;
+
+/* Nonzero means to collect statistics which might be expensive
and to print them when we are done. */
extern int flag_detailed_statistics;
/* Nonzero means enable synchronous exceptions for non-call instructions. */
extern int flag_non_call_exceptions;
+/* Nonzero means put zero initialized data in the bss section. */
+extern int flag_zero_initialized_in_bss;
+
+/* Nonzero means disable transformations observable by signaling NaNs. */
+extern int flag_signaling_nans;
+
+extern int flag_unit_at_a_time;
+
+/* A string that's used when a random name is required. NULL means
+ to make it really random. */
+
+extern const char *flag_random_seed;
+
+/* True if the given mode has a NaN representation and the treatment of
+ NaN operands is important. Certain optimizations, such as folding
+ x * 0 into x, are not correct for NaN operands, and are normally
+ disabled for modes with NaNs. The user can ask for them to be
+ done anyway using the -funsafe-math-optimizations switch. */
+#define HONOR_NANS(MODE) \
+ (MODE_HAS_NANS (MODE) && !flag_finite_math_only)
+
+/* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */
+#define HONOR_SNANS(MODE) (flag_signaling_nans && HONOR_NANS (MODE))
+
+/* As for HONOR_NANS, but true if the mode can represent infinity and
+ the treatment of infinite values is important. */
+#define HONOR_INFINITIES(MODE) \
+ (MODE_HAS_INFINITIES (MODE) && !flag_finite_math_only)
+
+/* Like HONOR_NANS, but true if the given mode distinguishes between
+ positive and negative zero, and the sign of zero is important. */
+#define HONOR_SIGNED_ZEROS(MODE) \
+ (MODE_HAS_SIGNED_ZEROS (MODE) && !flag_unsafe_math_optimizations)
+
+/* Like HONOR_NANS, but true if given mode supports sign-dependent rounding,
+ and the rounding mode is important. */
+#define HONOR_SIGN_DEPENDENT_ROUNDING(MODE) \
+ (MODE_HAS_SIGN_DEPENDENT_ROUNDING (MODE) && !flag_unsafe_math_optimizations)
+
#endif /* ! GCC_FLAGS_H */