Return to flags.h CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/flags.h, revision 1.1

1.1     ! root        1: /* Compilation switch flag definitions for GNU CC.
        !             2:    Copyright (C) 1987, 1988 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: /* Name of the input .c file being compiled.  */
        !            21: extern char *main_input_filename;
        !            22: 
        !            23: enum debug_info_type
        !            24: {
        !            25:   NO_DEBUG,        /* Write no debug info.  */
        !            26:   DBX_DEBUG,       /* Write BSD .stabs for DBX (using dbxout.c).  */
        !            27:   SDB_DEBUG,       /* Write COFF for (old) SDB (using sdbout.c).  */
        !            28:   DWARF_DEBUG      /* Write Dwarf debug info (using dwarfout.c).  */
        !            29: };
        !            30: 
        !            31: /* Specify which kind of debugging info to generate.  */
        !            32: extern enum debug_info_type write_symbols;
        !            33: 
        !            34: enum debug_info_level
        !            35: {
        !            36:   DINFO_LEVEL_NONE,    /* Write no debugging info.  */
        !            37:   DINFO_LEVEL_TERSE,   /* Write minimal info to support tracebacks only.  */
        !            38:   DINFO_LEVEL_NORMAL,  /* Write info for all declarations (and line table). */
        !            39:   DINFO_LEVEL_VERBOSE  /* Write normal info plus #define/#undef info.  */
        !            40: };
        !            41: 
        !            42: /* Specify how much debugging info to generate.  */
        !            43: extern enum debug_info_level debug_info_level;
        !            44: 
        !            45: #ifdef DBX_DEBUGGING_INFO
        !            46: /* Nonzero means use GDB-only extensions of DBX format.  */
        !            47: extern int use_gdb_dbx_extensions;
        !            48: #endif
        !            49: 
        !            50: /* Nonzero means do optimizations.  -opt.  */
        !            51: 
        !            52: extern int optimize;
        !            53: 
        !            54: /* Nonzero means do stupid register allocation.  -noreg.
        !            55:    Currently, this is 1 if `optimize' is 0.  */
        !            56: 
        !            57: extern int obey_regdecls;
        !            58: 
        !            59: /* Don't print functions as they are compiled and don't print
        !            60:    times taken by the various passes.  -quiet.  */
        !            61: 
        !            62: extern int quiet_flag;
        !            63: 
        !            64: /* Don't print warning messages.  -w.  */
        !            65: 
        !            66: extern int inhibit_warnings;
        !            67: 
        !            68: /* Do print extra warnings (such as for uninitialized variables).  -W.  */
        !            69: 
        !            70: extern int extra_warnings;
        !            71: 
        !            72: /* Nonzero to warn about unused local variables.  */
        !            73: 
        !            74: extern int warn_unused;
        !            75: 
        !            76: /* Nonzero to warn about variables used before they are initialized.  */
        !            77: 
        !            78: extern int warn_uninitialized;
        !            79: 
        !            80: /* Nonzero means warn about all declarations which shadow others.   */
        !            81: 
        !            82: extern int warn_shadow;
        !            83: 
        !            84: /* Warn if a switch on an enum fails to have a case for every enum value.  */
        !            85: 
        !            86: extern int warn_switch;
        !            87: 
        !            88: /* Nonzero means warn about function definitions that default the return type
        !            89:    or that use a null return and have a return-type other than void.  */
        !            90: 
        !            91: extern int warn_return_type;
        !            92: 
        !            93: /* Nonzero means warn about pointer casts that increase the required
        !            94:    alignment of the target type (and might therefore lead to a crash
        !            95:    due to a misaligned access).  */
        !            96: 
        !            97: extern int warn_cast_align;
        !            98: 
        !            99: /* Nonzero means warn about any identifiers that match in the first N
        !           100:    characters.  The value N is in `id_clash_len'.  */
        !           101: 
        !           102: extern int warn_id_clash;
        !           103: extern int id_clash_len;
        !           104: 
        !           105: /* Warn if a function returns an aggregate,
        !           106:    since there are often incompatible calling conventions for doing this.  */
        !           107: 
        !           108: extern int warn_aggregate_return;
        !           109: 
        !           110: /* Nonzero if generating code to do profiling.  */
        !           111: 
        !           112: extern int profile_flag;
        !           113: 
        !           114: /* Nonzero if generating code to do profiling on the basis of basic blocks.  */
        !           115: 
        !           116: extern int profile_block_flag;
        !           117: 
        !           118: /* Nonzero for -pedantic switch: warn about anything
        !           119:    that standard C forbids.  */
        !           120: 
        !           121: extern int pedantic;
        !           122: 
        !           123: /* Temporarily suppress certain warnings.
        !           124:    This is set while reading code from a system header file.  */
        !           125: 
        !           126: extern int in_system_header;
        !           127: 
        !           128: /* Nonzero for -dp: annotate the assembly with a comment describing the
        !           129:    pattern and alternative used.  */
        !           130: 
        !           131: extern int flag_print_asm_name;
        !           132: 
        !           133: /* Now the symbols that are set with `-f' switches.  */
        !           134: 
        !           135: /* Nonzero means `char' should be signed.  */
        !           136: 
        !           137: extern int flag_signed_char;
        !           138: 
        !           139: /* Nonzero means give an enum type only as many bytes as it needs.  */
        !           140: 
        !           141: extern int flag_short_enums;
        !           142: 
        !           143: /* Nonzero for -fcaller-saves: allocate values in regs that need to
        !           144:    be saved across function calls, if that produces overall better code.
        !           145:    Optional now, so people can test it.  */
        !           146: 
        !           147: extern int flag_caller_saves;
        !           148: 
        !           149: /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
        !           150: 
        !           151: extern int flag_pcc_struct_return;
        !           152: 
        !           153: /* Nonzero for -fforce-mem: load memory value into a register
        !           154:    before arithmetic on it.  This makes better cse but slower compilation.  */
        !           155: 
        !           156: extern int flag_force_mem;
        !           157: 
        !           158: /* Nonzero for -fforce-addr: load memory address into a register before
        !           159:    reference to memory.  This makes better cse but slower compilation.  */
        !           160: 
        !           161: extern int flag_force_addr;
        !           162: 
        !           163: /* Nonzero for -fdefer-pop: don't pop args after each function call;
        !           164:    instead save them up to pop many calls' args with one insns.  */
        !           165: 
        !           166: extern int flag_defer_pop;
        !           167: 
        !           168: /* Nonzero for -ffloat-store: don't allocate floats and doubles
        !           169:    in extended-precision registers.  */
        !           170: 
        !           171: extern int flag_float_store;
        !           172: 
        !           173: /* Nonzero enables strength-reduction in loop.c.  */
        !           174: 
        !           175: extern int flag_strength_reduce;
        !           176: 
        !           177: /* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
        !           178:    number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
        !           179:    UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
        !           180:    unrolled.  */
        !           181: 
        !           182: extern int flag_unroll_loops;
        !           183: 
        !           184: /* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
        !           185:    This is generally not a win.  */
        !           186: 
        !           187: extern int flag_unroll_all_loops;
        !           188: 
        !           189: /* Nonzero for -fcse-follow-jumps:
        !           190:    have cse follow jumps to do a more extensive job.  */
        !           191: 
        !           192: extern int flag_cse_follow_jumps;
        !           193: 
        !           194: /* Nonzero for -fexpensive-optimizations:
        !           195:    perform miscellaneous relatively-expensive optimizations.  */
        !           196: extern int flag_expensive_optimizations;
        !           197: 
        !           198: /* Nonzero for -fwritable-strings:
        !           199:    store string constants in data segment and don't uniquize them.  */
        !           200: 
        !           201: extern int flag_writable_strings;
        !           202: 
        !           203: /* Nonzero means don't put addresses of constant functions in registers.
        !           204:    Used for compiling the Unix kernel, where strange substitutions are
        !           205:    done on the assembly output.  */
        !           206: 
        !           207: extern int flag_no_function_cse;
        !           208: 
        !           209: /* Nonzero for -fomit-frame-pointer:
        !           210:    don't make a frame pointer in simple functions that don't require one.  */
        !           211: 
        !           212: extern int flag_omit_frame_pointer;
        !           213: 
        !           214: /* Nonzero to inhibit use of define_optimization peephole opts.  */
        !           215: 
        !           216: extern int flag_no_peephole;
        !           217: 
        !           218: /* Nonzero means all references through pointers are volatile.  */
        !           219: 
        !           220: extern int flag_volatile;
        !           221: 
        !           222: /* Nonzero means make functions that look like good inline candidates
        !           223:    go inline.  */
        !           224: 
        !           225: extern int flag_inline_functions;
        !           226: 
        !           227: /* Nonzero for -fkeep-inline-functions: even if we make a function
        !           228:    go inline everywhere, keep its defintion around for debugging
        !           229:    purposes.  */
        !           230: 
        !           231: extern int flag_keep_inline_functions;
        !           232: 
        !           233: /* Nonzero means that functions declared `inline' will be treated
        !           234:    as `static'.  Prevents generation of zillions of copies of unused
        !           235:    static inline functions; instead, `inlines' are written out
        !           236:    only when actually used.  Used in conjunction with -g.  Also
        !           237:    does the right thing with #pragma interface.  */
        !           238: 
        !           239: extern int flag_no_inline;
        !           240: 
        !           241: /* Nonzero if we are only using compiler to check syntax errors.  */
        !           242: 
        !           243: extern int flag_syntax_only;
        !           244: 
        !           245: /* Nonzero means we should save auxilliary info into a .X file.  */
        !           246: 
        !           247: extern int flag_gen_aux_info;
        !           248: 
        !           249: /* Nonzero means make the text shared if supported.  */
        !           250: 
        !           251: extern int flag_shared_data;
        !           252: 
        !           253: /* flag_schedule_insns means schedule insns within basic blocks (before
        !           254:    local_alloc).
        !           255:    flag_schedule_insns_after_reload means schedule insns after
        !           256:    global_alloc.  */
        !           257: 
        !           258: extern int flag_schedule_insns;
        !           259: extern int flag_schedule_insns_after_reload;
        !           260: 
        !           261: /* Nonzero means put things in delayed-branch slots if supported. */
        !           262: 
        !           263: extern int flag_delayed_branch;
        !           264: 
        !           265: /* Nonzero means pretend it is OK to examine bits of target floats,
        !           266:    even if that isn't true.  The resulting code will have incorrect constants,
        !           267:    but the same series of instructions that the native compiler would make.  */
        !           268: 
        !           269: extern int flag_pretend_float;
        !           270: 
        !           271: /* Nonzero means change certain warnings into errors.
        !           272:    Usually these are warnings about failure to conform to some standard.  */
        !           273: 
        !           274: extern int flag_pedantic_errors;
        !           275: 
        !           276: /* Nonzero means generate position-independent code.
        !           277:    This is not fully implemented yet.  */
        !           278: 
        !           279: extern int flag_pic;
        !           280: 
        !           281: /* Nonzero means place uninitialized global data in the bss section.  */
        !           282: 
        !           283: extern int flag_no_common;
        !           284: 
        !           285: /* -finhibit-size-directive inhibits output of .size for ELF.
        !           286:    This is used only for compiling crtstuff.c,
        !           287:    and it may be extended to other effects
        !           288:    needed for crtstuff.c on other systems.  */
        !           289: extern int flag_inhibit_size_directive;
        !           290: 
        !           291: /* -fgnu-linker specifies use of the GNU linker for initializations.
        !           292:    -fno-gnu-linker says that collect will be used.  */
        !           293: extern int flag_gnu_linker;
        !           294: 
        !           295: /* Other basic status info about current function.  */
        !           296: 
        !           297: /* Nonzero means current function must be given a frame pointer.
        !           298:    Set in stmt.c if anything is allocated on the stack there.
        !           299:    Set in reload1.c if anything is allocated on the stack there.  */
        !           300: 
        !           301: extern int frame_pointer_needed;
        !           302: 
        !           303: /* Set nonzero if jump_optimize finds that control falls through
        !           304:    at the end of the function.  */
        !           305: 
        !           306: extern int can_reach_end;
        !           307: 
        !           308: /* Nonzero if function being compiled receives nonlocal gotos
        !           309:    from nested functions.  */
        !           310: 
        !           311: extern int current_function_has_nonlocal_label;
        !           312: 

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