OSDN Git Service

* flags.h (flag_rerun_loop_opt): Declare.
[pf3gnuchains/gcc-fork.git] / gcc / flags.h
1 /* Compilation switch flag definitions for GNU CC.
2    Copyright (C) 1987, 88, 94, 95, 96, 1997 Free Software Foundation, Inc.
3
4 This file is part of GNU CC.
5
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING.  If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.  */
20
21 /* Name of the input .c file being compiled.  */
22 extern char *main_input_filename;
23
24 enum debug_info_type
25 {
26   NO_DEBUG,         /* Write no debug info.  */
27   DBX_DEBUG,        /* Write BSD .stabs for DBX (using dbxout.c).  */
28   SDB_DEBUG,        /* Write COFF for (old) SDB (using sdbout.c).  */
29   DWARF_DEBUG,      /* Write Dwarf debug info (using dwarfout.c).  */
30   DWARF2_DEBUG,     /* Write Dwarf v2 debug info (using dwarf2out.c).  */
31   XCOFF_DEBUG       /* Write IBM/Xcoff debug info (using dbxout.c).  */
32 };
33
34 /* Specify which kind of debugging info to generate.  */
35 extern enum debug_info_type write_symbols;
36
37 enum debug_info_level
38 {
39   DINFO_LEVEL_NONE,     /* Write no debugging info.  */
40   DINFO_LEVEL_TERSE,    /* Write minimal info to support tracebacks only.  */
41   DINFO_LEVEL_NORMAL,   /* Write info for all declarations (and line table). */
42   DINFO_LEVEL_VERBOSE   /* Write normal info plus #define/#undef info.  */
43 };
44
45 /* Specify how much debugging info to generate.  */
46 extern enum debug_info_level debug_info_level;
47
48 /* Nonzero means use GNU-only extensions in the generated symbolic
49    debugging information.  */
50 extern int use_gnu_debug_info_extensions;
51
52 /* Nonzero means do optimizations.  -opt.  */
53
54 extern int optimize;
55
56 /* Nonzero means do stupid register allocation.  -noreg.
57    Currently, this is 1 if `optimize' is 0.  */
58
59 extern int obey_regdecls;
60
61 /* Don't print functions as they are compiled and don't print
62    times taken by the various passes.  -quiet.  */
63
64 extern int quiet_flag;
65
66 /* Don't print warning messages.  -w.  */
67
68 extern int inhibit_warnings;
69
70 /* Do print extra warnings (such as for uninitialized variables).  -W.  */
71
72 extern int extra_warnings;
73
74 /* Nonzero to warn about unused local variables.  */
75
76 extern int warn_unused;
77
78 /* Nonzero means warn if inline function is too large.  */
79
80 extern int warn_inline;
81
82 /* Nonzero to warn about variables used before they are initialized.  */
83
84 extern int warn_uninitialized;
85
86 /* Nonzero means warn about all declarations which shadow others.   */
87
88 extern int warn_shadow;
89
90 /* Warn if a switch on an enum fails to have a case for every enum value.  */
91
92 extern int warn_switch;
93
94 /* Nonzero means warn about function definitions that default the return type
95    or that use a null return and have a return-type other than void.  */
96
97 extern int warn_return_type;
98
99 /* Nonzero means warn about pointer casts that increase the required
100    alignment of the target type (and might therefore lead to a crash
101    due to a misaligned access).  */
102
103 extern int warn_cast_align;
104
105 /* Nonzero means warn that dbx info for template class methods isn't fully
106    supported yet.  */
107
108 extern int warn_template_debugging;
109
110 /* Nonzero means warn about any identifiers that match in the first N
111    characters.  The value N is in `id_clash_len'.  */
112
113 extern int warn_id_clash;
114 extern unsigned id_clash_len;
115
116 /* Nonzero means warn about any objects definitions whose size is larger
117    than N bytes.  Also want about function definitions whose returned
118    values are larger than N bytes. The value N is in `larger_than_size'.  */
119
120 extern int warn_larger_than;
121 extern unsigned larger_than_size;
122
123 /* Warn if a function returns an aggregate,
124    since there are often incompatible calling conventions for doing this.  */
125
126 extern int warn_aggregate_return;
127
128 /* Nonzero if generating code to do profiling.  */
129
130 extern int profile_flag;
131
132 /* Nonzero if generating code to do profiling on the basis of basic blocks.  */
133
134 extern int profile_block_flag;
135
136 /* Nonzero if generating code to profile program flow graph arcs. */
137
138 extern int profile_arc_flag;
139
140 /* Nonzero if generating info for gcov to calculate line test coverage. */
141
142 extern int flag_test_coverage;
143
144 /* Nonzero indicates that branch taken probabilities should be calculated. */
145
146 extern int flag_branch_probabilities;
147
148 /* Nonzero for -pedantic switch: warn about anything
149    that standard C forbids.  */
150
151 extern int pedantic;
152
153 /* Temporarily suppress certain warnings.
154    This is set while reading code from a system header file.  */
155
156 extern int in_system_header;
157
158 /* Nonzero for -dp: annotate the assembly with a comment describing the
159    pattern and alternative used.  */
160
161 extern int flag_print_asm_name;
162 \f
163 /* Now the symbols that are set with `-f' switches.  */
164
165 /* Nonzero means `char' should be signed.  */
166
167 extern int flag_signed_char;
168
169 /* Nonzero means give an enum type only as many bytes as it needs.  */
170
171 extern int flag_short_enums;
172
173 /* Nonzero for -fcaller-saves: allocate values in regs that need to
174    be saved across function calls, if that produces overall better code.
175    Optional now, so people can test it.  */
176
177 extern int flag_caller_saves;
178
179 /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
180
181 extern int flag_pcc_struct_return;
182
183 /* Nonzero for -fforce-mem: load memory value into a register
184    before arithmetic on it.  This makes better cse but slower compilation.  */
185
186 extern int flag_force_mem;
187
188 /* Nonzero for -fforce-addr: load memory address into a register before
189    reference to memory.  This makes better cse but slower compilation.  */
190
191 extern int flag_force_addr;
192
193 /* Nonzero for -fdefer-pop: don't pop args after each function call;
194    instead save them up to pop many calls' args with one insns.  */
195
196 extern int flag_defer_pop;
197
198 /* Nonzero for -ffloat-store: don't allocate floats and doubles
199    in extended-precision registers.  */
200
201 extern int flag_float_store;
202
203 /* Nonzero enables strength-reduction in loop.c.  */
204
205 extern int flag_strength_reduce;
206
207 /* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
208    number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
209    UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
210    unrolled.  */
211
212 extern int flag_unroll_loops;
213
214 /* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
215    This is generally not a win.  */
216
217 extern int flag_unroll_all_loops;
218
219 /* Nonzero forces all invariant computations in loops to be moved
220    outside the loop. */
221
222 extern int flag_move_all_movables;
223
224 /* Nonzero forces all general induction variables in loops to be
225    strength reduced. */
226
227 extern int flag_reduce_all_givs;
228
229 /* Nonzero for -fcse-follow-jumps:
230    have cse follow jumps to do a more extensive job.  */
231
232 extern int flag_cse_follow_jumps;
233
234 /* Nonzero for -fcse-skip-blocks:
235    have cse follow a branch around a block.  */
236
237 extern int flag_cse_skip_blocks;
238
239 /* Nonzero for -fexpensive-optimizations:
240    perform miscellaneous relatively-expensive optimizations.  */
241 extern int flag_expensive_optimizations;
242
243 /* Nonzero for -fwritable-strings:
244    store string constants in data segment and don't uniquize them.  */
245
246 extern int flag_writable_strings;
247
248 /* Nonzero means don't put addresses of constant functions in registers.
249    Used for compiling the Unix kernel, where strange substitutions are
250    done on the assembly output.  */
251
252 extern int flag_no_function_cse;
253
254 /* Nonzero for -fomit-frame-pointer:
255    don't make a frame pointer in simple functions that don't require one.  */
256
257 extern int flag_omit_frame_pointer;
258
259 /* Nonzero to inhibit use of define_optimization peephole opts.  */
260
261 extern int flag_no_peephole;
262
263 /* Nonzero means all references through pointers are volatile.  */
264
265 extern int flag_volatile;
266
267 /* Nonzero means treat all global and extern variables as global.  */
268
269 extern int flag_volatile_global;
270
271 /* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math
272    operations in the interest of optimization.  For example it allows
273    GCC to assume arguments to sqrt are nonnegative numbers, allowing
274    faster code for sqrt to be generated. */
275
276 extern int flag_fast_math;
277
278 /* Nonzero means to run loop optimizations twice.  */
279
280 extern int flag_rerun_loop_opt;
281
282 /* Nonzero means make functions that look like good inline candidates
283    go inline.  */
284
285 extern int flag_inline_functions;
286
287 /* Nonzero for -fkeep-inline-functions: even if we make a function
288    go inline everywhere, keep its definition around for debugging
289    purposes.  */
290
291 extern int flag_keep_inline_functions;
292
293 /* Nonzero means that functions declared `inline' will be treated
294    as `static'.  Prevents generation of zillions of copies of unused
295    static inline functions; instead, `inlines' are written out
296    only when actually used.  Used in conjunction with -g.  Also
297    does the right thing with #pragma interface.  */
298
299 extern int flag_no_inline;
300
301 /* Nonzero if we are only using compiler to check syntax errors.  */
302
303 extern int flag_syntax_only;
304
305 /* Nonzero means we should save auxiliary info into a .X file.  */
306
307 extern int flag_gen_aux_info;
308
309 /* Nonzero means make the text shared if supported.  */
310
311 extern int flag_shared_data;
312
313 /* flag_schedule_insns means schedule insns within basic blocks (before
314    local_alloc).
315    flag_schedule_insns_after_reload means schedule insns after
316    global_alloc.  */
317
318 extern int flag_schedule_insns;
319 extern int flag_schedule_insns_after_reload;
320
321 #ifdef HAIFA
322 /* The following flags have effect only for scheduling before register
323    allocation:
324
325    flag_schedule_interblock means schedule insns accross basic blocks.
326    flag_schedule_speculative means allow speculative motion of non-load insns.
327    flag_schedule_speculative_load means allow speculative motion of some
328    load insns.
329    flag_schedule_speculative_load_dangerous allows speculative motion of more
330    load insns.
331    flag_schedule_reverse_before_reload means try to reverse original order
332    of insns (S).
333    flag_schedule_reverse_after_reload means try to reverse original order
334    of insns (R).  */
335
336 extern int flag_schedule_interblock;
337 extern int flag_schedule_speculative;
338 extern int flag_schedule_speculative_load;
339 extern int flag_schedule_speculative_load_dangerous;
340 extern int flag_schedule_reverse_before_reload;
341 extern int flag_schedule_reverse_after_reload;
342
343 /* flag_on_branch_count_reg means try to replace add-1,compare,branch tupple
344    by a cheaper branch, on a count register. */
345 extern int flag_branch_on_count_reg;
346 #endif  /* HAIFA */
347
348
349 /* Nonzero means put things in delayed-branch slots if supported. */
350
351 extern int flag_delayed_branch;
352
353 /* Nonzero means pretend it is OK to examine bits of target floats,
354    even if that isn't true.  The resulting code will have incorrect constants,
355    but the same series of instructions that the native compiler would make.  */
356
357 extern int flag_pretend_float;
358
359 /* Nonzero means change certain warnings into errors.
360    Usually these are warnings about failure to conform to some standard.  */
361
362 extern int flag_pedantic_errors;
363
364 /* Nonzero means generate position-independent code.
365    This is not fully implemented yet.  */
366
367 extern int flag_pic;
368
369 /* Nonzero means generate extra code for exception handling and enable
370    exception handling.  */
371
372 extern int flag_exceptions;
373
374 /* Nonzero means don't place uninitialized global data in common storage
375    by default.  */
376
377 extern int flag_no_common;
378
379 /* -finhibit-size-directive inhibits output of .size for ELF.
380    This is used only for compiling crtstuff.c,
381    and it may be extended to other effects
382    needed for crtstuff.c on other systems.  */
383 extern int flag_inhibit_size_directive;
384
385 /* Nonzero means place each function into its own section on those platforms
386    which support arbitrary section names and unlimited numbers of sections.  */
387
388 extern int flag_function_sections;
389
390 /* -fverbose-asm causes extra commentary information to be produced in
391    the generated assembly code (to make it more readable).  This option
392    is generally only of use to those who actually need to read the
393    generated assembly code (perhaps while debugging the compiler itself).
394    -fverbose-asm is the default.  -fno-verbose-asm causes the extra information
395    to not be added and is useful when comparing two assembler files.  */
396
397 extern int flag_verbose_asm;
398
399 /* -dA causes debug information to be produced in
400    the generated assembly code (to make it more readable).  This option
401    is generally only of use to those who actually need to read the
402    generated assembly code (perhaps while debugging the compiler itself).
403    Currently, this switch is only used by dwarfout.c; however, it is intended
404    to be a catchall for printing debug information in the assembler file.  */
405
406 extern int flag_debug_asm;
407
408 /* -fgnu-linker specifies use of the GNU linker for initializations.
409    -fno-gnu-linker says that collect will be used.  */
410 extern int flag_gnu_linker;
411
412 /* Tag all structures with __attribute__(packed) */
413 extern int flag_pack_struct;
414
415 /* 1 if alias checking is enabled: symbols do not alias each other
416    and parameters do not alias the current stack frame.  */
417 extern int flag_alias_check;
418
419 /* This flag is only tested if alias checking is enabled.
420    0 if pointer arguments may alias each other.  True in C.
421    1 if pointer arguments may not alias each other but may alias
422    global variables.
423    2 if pointer arguments may not alias each other and may not
424    alias global variables.  True in Fortran.
425    The value is ignored if flag_alias_check is 0.  */
426 extern int flag_argument_noalias;
427
428 /* Emit code to check for stack overflow; also may cause large objects
429    to be allocated dynamically.  */
430 extern int flag_stack_check;
431 \f
432 /* Other basic status info about current function.  */
433
434 /* Nonzero means current function must be given a frame pointer.
435    Set in stmt.c if anything is allocated on the stack there.
436    Set in reload1.c if anything is allocated on the stack there.  */
437
438 extern int frame_pointer_needed;
439
440 /* Set nonzero if jump_optimize finds that control falls through
441    at the end of the function.  */
442
443 extern int can_reach_end;
444
445 /* Nonzero if function being compiled receives nonlocal gotos
446    from nested functions.  */
447
448 extern int current_function_has_nonlocal_label;
449
450 /* Nonzero if function being compiled has nonlocal gotos to parent
451    function.  */
452
453 extern int current_function_has_nonlocal_goto;
454
455 /* Nonzero if GCC must add code to check memory access (used by Checker).  */
456
457 extern int flag_check_memory_usage;
458
459 /* Nonzero if GCC must prefix function names (used with
460    flag_check_memory_usage).  */
461
462 extern int flag_prefix_function_name;
463 /* Nonzero if the current function is a thunk, so we should try to cut
464    corners where we can.  */
465 extern int current_function_is_thunk;