Return to flags.h CVS log

Up to [Research Unix] / researchv10dc / cmd / gcc

Annotation of researchv10dc/cmd/gcc/flags.h, revision 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;

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