Import of unmodified (but trimmed) gcc-2.7.2. The bigger parts of the

non-i386, non-unix, and generatable files have been trimmed, but can easily
be added in later if needed.

gcc-2.7.2.1 will follow shortly, it's a very small delta to this and it's
handy to have both available for reference for such little cost.

The freebsd-specific changes will then be committed, and once the dust has
settled, the bmakefiles will be committed to use this code.

1 files changed, 363 insertions, 0 deletions

diff --git a/contrib/gcc/flags.h b/contrib/gcc/flags.h
new file mode 100644
index 0000000..ed1cf57
--- /dev/null
+++ b/contrib/gcc/flags.h
@@ -0,0 +1,363 @@
+/* Compilation switch flag definitions for GNU CC.
+   Copyright (C) 1987, 1988, 1994, 1995 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+/* Name of the input .c file being compiled.  */
+extern char *main_input_filename;
+
+enum debug_info_type
+{
+  NO_DEBUG,	    /* Write no debug info.  */
+  DBX_DEBUG,	    /* Write BSD .stabs for DBX (using dbxout.c).  */
+  SDB_DEBUG,	    /* Write COFF for (old) SDB (using sdbout.c).  */
+  DWARF_DEBUG,	    /* Write Dwarf debug info (using dwarfout.c).  */
+  XCOFF_DEBUG	    /* Write IBM/Xcoff debug info (using dbxout.c).  */
+};
+
+/* Specify which kind of debugging info to generate.  */
+extern enum debug_info_type write_symbols;
+
+enum debug_info_level
+{
+  DINFO_LEVEL_NONE,	/* Write no debugging info.  */
+  DINFO_LEVEL_TERSE,	/* Write minimal info to support tracebacks only.  */
+  DINFO_LEVEL_NORMAL,	/* Write info for all declarations (and line table). */
+  DINFO_LEVEL_VERBOSE	/* Write normal info plus #define/#undef info.  */
+};
+
+/* Specify how much debugging info to generate.  */
+extern enum debug_info_level debug_info_level;
+
+/* Nonzero means use GNU-only extensions in the generated symbolic
+   debugging information.  */
+extern int use_gnu_debug_info_extensions;
+
+/* Nonzero means do optimizations.  -opt.  */
+
+extern int optimize;
+
+/* Nonzero means do stupid register allocation.  -noreg.
+   Currently, this is 1 if `optimize' is 0.  */
+
+extern int obey_regdecls;
+
+/* Don't print functions as they are compiled and don't print
+   times taken by the various passes.  -quiet.  */
+
+extern int quiet_flag;
+
+/* Don't print warning messages.  -w.  */
+
+extern int inhibit_warnings;
+
+/* Do print extra warnings (such as for uninitialized variables).  -W.  */
+
+extern int extra_warnings;
+
+/* Nonzero to warn about unused local variables.  */
+
+extern int warn_unused;
+
+/* Nonzero means warn if inline function is too large.  */
+
+extern int warn_inline;
+
+/* Nonzero to warn about variables used before they are initialized.  */
+
+extern int warn_uninitialized;
+
+/* Nonzero means warn about all declarations which shadow others.   */
+
+extern int warn_shadow;
+
+/* Warn if a switch on an enum fails to have a case for every enum value.  */
+
+extern int warn_switch;
+
+/* Nonzero means warn about function definitions that default the return type
+   or that use a null return and have a return-type other than void.  */
+
+extern int warn_return_type;
+
+/* Nonzero means warn about pointer casts that increase the required
+   alignment of the target type (and might therefore lead to a crash
+   due to a misaligned access).  */
+
+extern int warn_cast_align;
+
+/* Nonzero means warn that dbx info for template class methods isn't fully
+   supported yet.  */
+
+extern int warn_template_debugging;
+
+/* Nonzero means warn about any identifiers that match in the first N
+   characters.  The value N is in `id_clash_len'.  */
+
+extern int warn_id_clash;
+extern unsigned id_clash_len;
+
+/* Nonzero means warn about any objects definitions whose size is larger
+   than N bytes.  Also want about function definitions whose returned
+   values are larger than N bytes. The value N is in `larger_than_size'.  */
+
+extern int warn_larger_than;
+extern unsigned larger_than_size;
+
+/* Warn if a function returns an aggregate,
+   since there are often incompatible calling conventions for doing this.  */
+
+extern int warn_aggregate_return;
+
+/* Nonzero if generating code to do profiling.  */
+
+extern int profile_flag;
+
+/* Nonzero if generating code to do profiling on the basis of basic blocks.  */
+
+extern int profile_block_flag;
+
+/* Nonzero for -pedantic switch: warn about anything
+   that standard C forbids.  */
+
+extern int pedantic;
+
+/* Temporarily suppress certain warnings.
+   This is set while reading code from a system header file.  */
+
+extern int in_system_header;
+
+/* Nonzero for -dp: annotate the assembly with a comment describing the
+   pattern and alternative used.  */
+
+extern int flag_print_asm_name;
+
+/* Now the symbols that are set with `-f' switches.  */
+
+/* Nonzero means `char' should be signed.  */
+
+extern int flag_signed_char;
+
+/* Nonzero means give an enum type only as many bytes as it needs.  */
+
+extern int flag_short_enums;
+
+/* Nonzero for -fcaller-saves: allocate values in regs that need to
+   be saved across function calls, if that produces overall better code.
+   Optional now, so people can test it.  */
+
+extern int flag_caller_saves;
+
+/* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
+
+extern int flag_pcc_struct_return;
+
+/* Nonzero for -fforce-mem: load memory value into a register
+   before arithmetic on it.  This makes better cse but slower compilation.  */
+
+extern int flag_force_mem;
+
+/* Nonzero for -fforce-addr: load memory address into a register before
+   reference to memory.  This makes better cse but slower compilation.  */
+
+extern int flag_force_addr;
+
+/* Nonzero for -fdefer-pop: don't pop args after each function call;
+   instead save them up to pop many calls' args with one insns.  */
+
+extern int flag_defer_pop;
+
+/* Nonzero for -ffloat-store: don't allocate floats and doubles
+   in extended-precision registers.  */
+
+extern int flag_float_store;
+
+/* Nonzero enables strength-reduction in loop.c.  */
+
+extern int flag_strength_reduce;
+
+/* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
+   number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
+   UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
+   unrolled.  */
+
+extern int flag_unroll_loops;
+
+/* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
+   This is generally not a win.  */
+
+extern int flag_unroll_all_loops;
+
+/* Nonzero for -fcse-follow-jumps:
+   have cse follow jumps to do a more extensive job.  */
+
+extern int flag_cse_follow_jumps;
+
+/* Nonzero for -fcse-skip-blocks:
+   have cse follow a branch around a block.  */
+
+extern int flag_cse_skip_blocks;
+
+/* Nonzero for -fexpensive-optimizations:
+   perform miscellaneous relatively-expensive optimizations.  */
+extern int flag_expensive_optimizations;
+
+/* Nonzero for -fwritable-strings:
+   store string constants in data segment and don't uniquize them.  */
+
+extern int flag_writable_strings;
+
+/* Nonzero means don't put addresses of constant functions in registers.
+   Used for compiling the Unix kernel, where strange substitutions are
+   done on the assembly output.  */
+
+extern int flag_no_function_cse;
+
+/* Nonzero for -fomit-frame-pointer:
+   don't make a frame pointer in simple functions that don't require one.  */
+
+extern int flag_omit_frame_pointer;
+
+/* Nonzero to inhibit use of define_optimization peephole opts.  */
+
+extern int flag_no_peephole;
+
+/* Nonzero means all references through pointers are volatile.  */
+
+extern int flag_volatile;
+
+/* Nonzero means treat all global and extern variables as global.  */
+
+extern int flag_volatile_global;
+
+/* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math
+   operations in the interest of optimization.  For example it allows
+   GCC to assume arguments to sqrt are nonnegative numbers, allowing
+   faster code for sqrt to be generated. */
+
+extern int flag_fast_math;
+
+/* Nonzero means make functions that look like good inline candidates
+   go inline.  */
+
+extern int flag_inline_functions;
+
+/* Nonzero for -fkeep-inline-functions: even if we make a function
+   go inline everywhere, keep its definition around for debugging
+   purposes.  */
+
+extern int flag_keep_inline_functions;
+
+/* Nonzero means that functions declared `inline' will be treated
+   as `static'.  Prevents generation of zillions of copies of unused
+   static inline functions; instead, `inlines' are written out
+   only when actually used.  Used in conjunction with -g.  Also
+   does the right thing with #pragma interface.  */
+
+extern int flag_no_inline;
+
+/* Nonzero if we are only using compiler to check syntax errors.  */
+
+extern int flag_syntax_only;
+
+/* Nonzero means we should save auxiliary info into a .X file.  */
+
+extern int flag_gen_aux_info;
+
+/* Nonzero means make the text shared if supported.  */
+
+extern int flag_shared_data;
+
+/* flag_schedule_insns means schedule insns within basic blocks (before
+   local_alloc).
+   flag_schedule_insns_after_reload means schedule insns after
+   global_alloc.  */
+
+extern int flag_schedule_insns;
+extern int flag_schedule_insns_after_reload;
+
+/* Nonzero means put things in delayed-branch slots if supported. */
+
+extern int flag_delayed_branch;
+
+/* Nonzero means to run cleanups after CALL_EXPRs. */
+
+extern int flag_short_temps;
+
+/* Nonzero means pretend it is OK to examine bits of target floats,
+   even if that isn't true.  The resulting code will have incorrect constants,
+   but the same series of instructions that the native compiler would make.  */
+
+extern int flag_pretend_float;
+
+/* Nonzero means change certain warnings into errors.
+   Usually these are warnings about failure to conform to some standard.  */
+
+extern int flag_pedantic_errors;
+
+/* Nonzero means generate position-independent code.
+   This is not fully implemented yet.  */
+
+extern int flag_pic;
+
+/* Nonzero means place uninitialized global data in the bss section.  */
+
+extern int flag_no_common;
+
+/* -finhibit-size-directive inhibits output of .size for ELF.
+   This is used only for compiling crtstuff.c,
+   and it may be extended to other effects
+   needed for crtstuff.c on other systems.  */
+extern int flag_inhibit_size_directive;
+
+/* -fverbose-asm causes extra commentary information to be produced in
+   the generated assembly code (to make it more readable).  This option
+   is generally only of use to those who actually need to read the
+   generated assembly code (perhaps while debugging the compiler itself).  */
+
+extern int flag_verbose_asm;
+
+/* -fgnu-linker specifies use of the GNU linker for initializations.
+   -fno-gnu-linker says that collect will be used.  */
+extern int flag_gnu_linker;
+
+/* Tag all structures with __attribute__(packed) */
+extern int flag_pack_struct;
+
+/* Other basic status info about current function.  */
+
+/* Nonzero means current function must be given a frame pointer.
+   Set in stmt.c if anything is allocated on the stack there.
+   Set in reload1.c if anything is allocated on the stack there.  */
+
+extern int frame_pointer_needed;
+
+/* Set nonzero if jump_optimize finds that control falls through
+   at the end of the function.  */
+
+extern int can_reach_end;
+
+/* Nonzero if function being compiled receives nonlocal gotos
+   from nested functions.  */
+
+extern int current_function_has_nonlocal_label;
+
+/* Nonzero if function being compiled has nonlocal gotos to parent
+   function.  */
+
+extern int current_function_has_nonlocal_goto;