Return to flags.h CVS log

Up to [Apple XNU] / GNUtools / cc

Annotation of GNUtools/cc/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:   XCOFF_DEBUG      /* Write IBM/Xcoff debug info (using dbxout.c).  */
        !            30: };
        !            31: 
        !            32: /* Specify which kind of debugging info to generate.  */
        !            33: extern enum debug_info_type write_symbols;
        !            34: 
        !            35: enum debug_info_level
        !            36: {
        !            37:   DINFO_LEVEL_NONE,    /* Write no debugging info.  */
        !            38:   DINFO_LEVEL_TERSE,   /* Write minimal info to support tracebacks only.  */
        !            39:   DINFO_LEVEL_NORMAL,  /* Write info for all declarations (and line table). */
        !            40:   DINFO_LEVEL_VERBOSE  /* Write normal info plus #define/#undef info.  */
        !            41: };
        !            42: 
        !            43: /* Specify how much debugging info to generate.  */
        !            44: extern enum debug_info_level debug_info_level;
        !            45: 
        !            46: /* Nonzero means use GNU-only extensions in the generated symbolic
        !            47:    debugging information.  */
        !            48: extern int use_gnu_debug_info_extensions;
        !            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 means warn if inline function is too large.  */
        !            77: 
        !            78: extern int warn_inline;
        !            79: 
        !            80: /* Nonzero to warn about variables used before they are initialized.  */
        !            81: 
        !            82: extern int warn_uninitialized;
        !            83: 
        !            84: /* Nonzero means warn about all declarations which shadow others.   */
        !            85: 
        !            86: extern int warn_shadow;
        !            87: 
        !            88: /* Warn if a switch on an enum fails to have a case for every enum value.  */
        !            89: 
        !            90: extern int warn_switch;
        !            91: 
        !            92: /* Nonzero means warn about function definitions that default the return type
        !            93:    or that use a null return and have a return-type other than void.  */
        !            94: 
        !            95: extern int warn_return_type;
        !            96: 
        !            97: /* Nonzero means warn about pointer casts that increase the required
        !            98:    alignment of the target type (and might therefore lead to a crash
        !            99:    due to a misaligned access).  */
        !           100: 
        !           101: extern int warn_cast_align;
        !           102: 
        !           103: /* Nonzero means warn that dbx info for template class methods isn't fully
        !           104:    supported yet.  */
        !           105: 
        !           106: extern int warn_template_debugging;
        !           107: 
        !           108: /* Nonzero means warn about any identifiers that match in the first N
        !           109:    characters.  The value N is in `id_clash_len'.  */
        !           110: 
        !           111: extern int warn_id_clash;
        !           112: extern int id_clash_len;
        !           113: 
        !           114: /* Warn if a function returns an aggregate,
        !           115:    since there are often incompatible calling conventions for doing this.  */
        !           116: 
        !           117: extern int warn_aggregate_return;
        !           118: 
        !           119: /* Nonzero if generating code to do profiling.  */
        !           120: 
        !           121: extern int profile_flag;
        !           122: 
        !           123: /* Nonzero if generating code to do profiling on the basis of basic blocks.  */
        !           124: 
        !           125: extern int profile_block_flag;
        !           126: 
        !           127: /* Nonzero for -pedantic switch: warn about anything
        !           128:    that standard C forbids.  */
        !           129: 
        !           130: extern int pedantic;
        !           131: 
        !           132: /* Temporarily suppress certain warnings.
        !           133:    This is set while reading code from a system header file.  */
        !           134: 
        !           135: extern int in_system_header;
        !           136: 
        !           137: /* Nonzero for -dp: annotate the assembly with a comment describing the
        !           138:    pattern and alternative used.  */
        !           139: 
        !           140: extern int flag_print_asm_name;
        !           141: 
        !           142: /* Now the symbols that are set with `-f' switches.  */
        !           143: 
        !           144: /* Nonzero means `char' should be signed.  */
        !           145: 
        !           146: extern int flag_signed_char;
        !           147: 
        !           148: /* Nonzero means give an enum type only as many bytes as it needs.  */
        !           149: 
        !           150: extern int flag_short_enums;
        !           151: 
        !           152: /* Nonzero for -fcaller-saves: allocate values in regs that need to
        !           153:    be saved across function calls, if that produces overall better code.
        !           154:    Optional now, so people can test it.  */
        !           155: 
        !           156: extern int flag_caller_saves;
        !           157: 
        !           158: /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
        !           159: 
        !           160: extern int flag_pcc_struct_return;
        !           161: 
        !           162: /* Nonzero for -fforce-mem: load memory value into a register
        !           163:    before arithmetic on it.  This makes better cse but slower compilation.  */
        !           164: 
        !           165: extern int flag_force_mem;
        !           166: 
        !           167: /* Nonzero for -fforce-addr: load memory address into a register before
        !           168:    reference to memory.  This makes better cse but slower compilation.  */
        !           169: 
        !           170: extern int flag_force_addr;
        !           171: 
        !           172: /* Nonzero for -fdefer-pop: don't pop args after each function call;
        !           173:    instead save them up to pop many calls' args with one insns.  */
        !           174: 
        !           175: extern int flag_defer_pop;
        !           176: 
        !           177: /* Nonzero for -ffloat-store: don't allocate floats and doubles
        !           178:    in extended-precision registers.  */
        !           179: 
        !           180: extern int flag_float_store;
        !           181: 
        !           182: /* Nonzero enables strength-reduction in loop.c.  */
        !           183: 
        !           184: extern int flag_strength_reduce;
        !           185: 
        !           186: /* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
        !           187:    number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
        !           188:    UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
        !           189:    unrolled.  */
        !           190: 
        !           191: extern int flag_unroll_loops;
        !           192: 
        !           193: /* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
        !           194:    This is generally not a win.  */
        !           195: 
        !           196: extern int flag_unroll_all_loops;
        !           197: 
        !           198: /* Nonzero for -fcse-follow-jumps:
        !           199:    have cse follow jumps to do a more extensive job.  */
        !           200: 
        !           201: extern int flag_cse_follow_jumps;
        !           202: 
        !           203: /* Nonzero for -fcse-skip-blocks:
        !           204:    have cse follow a branch around a block.  */
        !           205: 
        !           206: extern int flag_cse_skip_blocks;
        !           207: 
        !           208: /* Nonzero for -fexpensive-optimizations:
        !           209:    perform miscellaneous relatively-expensive optimizations.  */
        !           210: extern int flag_expensive_optimizations;
        !           211: 
        !           212: /* Nonzero for -fwritable-strings:
        !           213:    store string constants in data segment and don't uniquize them.  */
        !           214: 
        !           215: extern int flag_writable_strings;
        !           216: 
        !           217: /* Nonzero means don't put addresses of constant functions in registers.
        !           218:    Used for compiling the Unix kernel, where strange substitutions are
        !           219:    done on the assembly output.  */
        !           220: 
        !           221: extern int flag_no_function_cse;
        !           222: 
        !           223: /* Nonzero for -fomit-frame-pointer:
        !           224:    don't make a frame pointer in simple functions that don't require one.  */
        !           225: 
        !           226: extern int flag_omit_frame_pointer;
        !           227: 
        !           228: /* Nonzero to inhibit use of define_optimization peephole opts.  */
        !           229: 
        !           230: extern int flag_no_peephole;
        !           231: 
        !           232: /* Nonzero means all references through pointers are volatile.  */
        !           233: 
        !           234: extern int flag_volatile;
        !           235: 
        !           236: /* Nonzero means treat all global and extern variables as global.  */
        !           237: 
        !           238: extern int flag_volatile_global;
        !           239: 
        !           240: /* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math
        !           241:    operations in the interest of optimization.  For example it allows
        !           242:    GCC to assume arguments to sqrt are nonnegative numbers, allowing
        !           243:    faster code for sqrt to be generated. */
        !           244: 
        !           245: extern int flag_fast_math;
        !           246: 
        !           247: /* Nonzero means make functions that look like good inline candidates
        !           248:    go inline.  */
        !           249: 
        !           250: extern int flag_inline_functions;
        !           251: 
        !           252: /* Nonzero for -fkeep-inline-functions: even if we make a function
        !           253:    go inline everywhere, keep its definition around for debugging
        !           254:    purposes.  */
        !           255: 
        !           256: extern int flag_keep_inline_functions;
        !           257: 
        !           258: /* Nonzero means that functions declared `inline' will be treated
        !           259:    as `static'.  Prevents generation of zillions of copies of unused
        !           260:    static inline functions; instead, `inlines' are written out
        !           261:    only when actually used.  Used in conjunction with -g.  Also
        !           262:    does the right thing with #pragma interface.  */
        !           263: 
        !           264: extern int flag_no_inline;
        !           265: 
        !           266: /* Nonzero if we are only using compiler to check syntax errors.  */
        !           267: 
        !           268: extern int flag_syntax_only;
        !           269: 
        !           270: /* Nonzero means we should save auxiliary info into a .X file.  */
        !           271: 
        !           272: extern int flag_gen_aux_info;
        !           273: 
        !           274: /* Nonzero means make the text shared if supported.  */
        !           275: 
        !           276: extern int flag_shared_data;
        !           277: 
        !           278: /* flag_schedule_insns means schedule insns within basic blocks (before
        !           279:    local_alloc).
        !           280:    flag_schedule_insns_after_reload means schedule insns after
        !           281:    global_alloc.  */
        !           282: 
        !           283: extern int flag_schedule_insns;
        !           284: extern int flag_schedule_insns_after_reload;
        !           285: 
        !           286: /* Nonzero means put things in delayed-branch slots if supported. */
        !           287: 
        !           288: extern int flag_delayed_branch;
        !           289: 
        !           290: /* Nonzero means pretend it is OK to examine bits of target floats,
        !           291:    even if that isn't true.  The resulting code will have incorrect constants,
        !           292:    but the same series of instructions that the native compiler would make.  */
        !           293: 
        !           294: extern int flag_pretend_float;
        !           295: 
        !           296: /* Nonzero means change certain warnings into errors.
        !           297:    Usually these are warnings about failure to conform to some standard.  */
        !           298: 
        !           299: extern int flag_pedantic_errors;
        !           300: 
        !           301: /* Nonzero means generate position-independent code.
        !           302:    This is not fully implemented yet.  */
        !           303: 
        !           304: extern int flag_pic;
        !           305: 
        !           306: /* Nonzero means place uninitialized global data in the bss section.  */
        !           307: 
        !           308: extern int flag_no_common;
        !           309: 
        !           310: /* -finhibit-size-directive inhibits output of .size for ELF.
        !           311:    This is used only for compiling crtstuff.c,
        !           312:    and it may be extended to other effects
        !           313:    needed for crtstuff.c on other systems.  */
        !           314: extern int flag_inhibit_size_directive;
        !           315: 
        !           316: /* -fverbose-asm causes extra commentary information to be produced in
        !           317:    the generated assembly code (to make it more readable).  This option
        !           318:    is generally only of use to those who actually need to read the
        !           319:    generated assembly code (perhaps while debugging the compiler itself).  */
        !           320: 
        !           321: extern int flag_verbose_asm;
        !           322: 
        !           323: /* -fgnu-linker specifies use of the GNU linker for initializations.
        !           324:    -fno-gnu-linker says that collect will be used.  */
        !           325: extern int flag_gnu_linker;
        !           326: 
        !           327: /* Other basic status info about current function.  */
        !           328: 
        !           329: /* Nonzero means current function must be given a frame pointer.
        !           330:    Set in stmt.c if anything is allocated on the stack there.
        !           331:    Set in reload1.c if anything is allocated on the stack there.  */
        !           332: 
        !           333: extern int frame_pointer_needed;
        !           334: 
        !           335: /* Set nonzero if jump_optimize finds that control falls through
        !           336:    at the end of the function.  */
        !           337: 
        !           338: extern int can_reach_end;
        !           339: 
        !           340: /* Nonzero if function being compiled receives nonlocal gotos
        !           341:    from nested functions.  */
        !           342: 
        !           343: extern int current_function_has_nonlocal_label;
        !           344: 
        !           345: /* Nonzero if function being compiled has nonlocal gotos to parent
        !           346:    function.  */
        !           347: 
        !           348: extern int current_function_has_nonlocal_goto;
        !           349: 
        !           350: /* Nonzero if an floating point precision controll pass is done. */
        !           351: 
        !           352: extern int flag_fppc;

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