Annotation of researchv10dc/cmd/gcc/flags.h, revision 1.1.1.1

1.1       root        1: /* Compilation switch flag definitions for GNU CC.
                      2:    Copyright (C) 1987 Free Software Foundation, Inc.
                      3: 
                      4: This file is part of GNU CC.
                      5: 
                      6: GNU CC is distributed in the hope that it will be useful,
                      7: but WITHOUT ANY WARRANTY.  No author or distributor
                      8: accepts responsibility to anyone for the consequences of using it
                      9: or for whether it serves any particular purpose or works at all,
                     10: unless he says so in writing.  Refer to the GNU CC General Public
                     11: License for full details.
                     12: 
                     13: Everyone is granted permission to copy, modify and redistribute
                     14: GNU CC, but only under the conditions described in the
                     15: GNU CC General Public License.   A copy of this license is
                     16: supposed to have been given to you along with GNU CC so you
                     17: can know your rights and responsibilities.  It should be in a
                     18: file named COPYING.  Among other things, the copyright notice
                     19: and this notice must be preserved on all copies.  */
                     20: 
                     21: /* 1 => write gdb debugging output (using symout.c).  -g
                     22:    2 => write dbx debugging output (using dbxout.c).  -G  */
                     23: 
                     24: extern int write_symbols;
                     25: 
                     26: /* Nonzero means do optimizations.  -opt.  */
                     27: 
                     28: extern int optimize;
                     29: 
                     30: /* Nonzero means do stupid register allocation.  -noreg.
                     31:    This and `optimize' are controlled by different switches in cc1,
                     32:    but normally cc controls them both with the -O switch.  */
                     33: 
                     34: extern int obey_regdecls;
                     35: 
                     36: /* Don't print functions as they are compiled and don't print
                     37:    times taken by the various passes.  -quiet.  */
                     38: 
                     39: extern int quiet_flag;
                     40: 
                     41: /* Don't print warning messages.  -w.  */
                     42: 
                     43: extern int inhibit_warnings;
                     44: 
                     45: /* Do print extra warnings (such as for uninitialized variables).  -W.  */
                     46: 
                     47: extern int extra_warnings;
                     48: 
                     49: /* Nonzero if generating code to do profiling.  */
                     50: 
                     51: extern int profile_flag;
                     52: 
                     53: /* Nonzero for -pedantic switch: warn about anything
                     54:    that standard C forbids.  */
                     55: 
                     56: extern int pedantic;
                     57: 
                     58: /* Now the symbols that are set with `-f' switches.  */
                     59: 
                     60: /* Nonzero for -fforce-mem: load memory value into a register
                     61:    before arithmetic on it.  This makes better cse but slower compilation.  */
                     62: 
                     63: extern int flag_force_mem;
                     64: 
                     65: /* Nonzero for -fforce-addr: load memory address into a register before
                     66:    reference to memory.  This makes better cse but slower compilation.  */
                     67: 
                     68: extern int flag_force_addr;
                     69: 
                     70: /* Nonzero for -fdefer-pop: don't pop args after each function call;
                     71:    instead save them up to pop many calls' args with one insns.  */
                     72: 
                     73: extern int flag_defer_pop;
                     74: 
                     75: /* Nonzero for -ffloat-store: don't allocate floats and doubles
                     76:    in extended-precision registers.  */
                     77: 
                     78: extern int flag_float_store;
                     79: 
                     80: /* Nonzero for -fcombine-regs:
                     81:    allow instruction combiner to combine an insn
                     82:    that just copies one reg to another.  */
                     83: 
                     84: extern int flag_combine_regs;
                     85: 
                     86: /* Nonzero for -fwritable-strings:
                     87:    store string constants in data segment and don't uniquize them.  */
                     88: 
                     89: extern int flag_writable_strings;
                     90: 
                     91: /* Nonzero means don't put addresses of constant functions in registers.
                     92:    Used for compiling the Unix kernel, where strange substitutions are
                     93:    done on the assembly output.  */
                     94: 
                     95: extern int flag_no_function_cse;
                     96: 
                     97: /* Nonzero for -fomit-frame-pointer:
                     98:    don't make a frame pointer in simple functions that don't require one.  */
                     99: 
                    100: extern int flag_omit_frame_pointer;
                    101: 
                    102: /* This isn't a flag, but everyone who needs flag_omit_frame_pointer
                    103:    also needs this.
                    104:    Nonzero means current function must be given a frame pointer.
                    105:    Set in stmt.c if anything is allocated on the stack there.
                    106:    Set in reload1.c if anything is allocated on the stack there.  */
                    107: 
                    108: extern int frame_pointer_needed;
                    109: 
                    110: /* Nonzero to inhibit use of define_optimization peephole opts.  */
                    111: 
                    112: extern int flag_no_peephole;
                    113: 
                    114: /* Nonzero means `char' should be signed.  */
                    115: 
                    116: extern int flag_signed_char;
                    117: 
                    118: /* Nonzero means allow type mismatches in conditional expressions;
                    119:    just make their values `void'.   */
                    120: 
                    121: extern int flag_cond_mismatch;
                    122: 
                    123: /* Nonzero means don't recognize the keyword `asm'.  */
                    124: 
                    125: extern int flag_no_asm;
                    126: 
                    127: /* Nonzero means warn about implicit declarations.  */
                    128: 
                    129: extern int warn_implicit;
                    130: 
                    131: /* Nonzero means warn about function definitions that default the return type
                    132:    or that use a null return and have a return-type other than void.  */
                    133: 
                    134: extern int warn_return_type;
                    135: 
                    136: /* Nonzero means do some things the same way PCC does.  */
                    137: 
                    138: extern int flag_traditional;
                    139: 
                    140: /* Nonzero means all references through pointers are volatile.  */
                    141: 
                    142: extern int flag_volatile;
                    143: 
                    144: /* Nonzero means make functions that look like good inline candidates
                    145:    go inline.  */
                    146: 
                    147: extern int flag_inline_functions;
                    148: 
                    149: /* Nonzero for -fkeep-inline-functions: even if we make a function
                    150:    go inline everywhere, keep its defintion around for debugging
                    151:    purposes.  */
                    152: 
                    153: extern int flag_keep_inline_functions;

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.