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