OSDN Git Service

920dba5df55c6e10aa27b5c91db2566b399d3425
[pf3gnuchains/gcc-fork.git] / gcc / toplev.c
1 /* Top level of GNU C compiler
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000 Free Software Foundation, Inc.
4
5 This file is part of GNU CC.
6
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING.  If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.  */
21
22 /* This is the top level of cc1/c++.
23    It parses command args, opens files, invokes the various passes
24    in the proper order, and counts the time used by each.
25    Error messages and low-level interface to malloc also handled here.  */
26
27 #include "config.h"
28 #undef FLOAT /* This is for hpux. They should change hpux.  */
29 #undef FFS  /* Some systems define this in param.h.  */
30 #include "system.h"
31 #include <signal.h>
32 #include <setjmp.h>
33
34 #ifdef HAVE_SYS_RESOURCE_H
35 # include <sys/resource.h>
36 #endif
37
38 #ifdef HAVE_SYS_TIMES_H
39 # include <sys/times.h>
40 #endif
41
42 #include "input.h"
43 #include "tree.h"
44 #include "rtl.h"
45 #include "tm_p.h"
46 #include "flags.h"
47 #include "insn-attr.h"
48 #include "insn-codes.h"
49 #include "insn-config.h"
50 #include "recog.h"
51 #include "defaults.h"
52 #include "output.h"
53 #include "except.h"
54 #include "function.h"
55 #include "toplev.h"
56 #include "expr.h"
57 #include "basic-block.h"
58 #include "intl.h"
59 #include "ggc.h"
60 #include "graph.h"
61 #include "loop.h"
62 #include "regs.h"
63
64 #ifndef ACCUMULATE_OUTGOING_ARGS
65 #define ACCUMULATE_OUTGOING_ARGS 0
66 #endif
67
68 #ifdef DWARF_DEBUGGING_INFO
69 #include "dwarfout.h"
70 #endif
71
72 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
73 #include "dwarf2out.h"
74 #endif
75
76 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
77 #include "dbxout.h"
78 #endif
79
80 #ifdef SDB_DEBUGGING_INFO
81 #include "sdbout.h"
82 #endif
83
84 #ifdef XCOFF_DEBUGGING_INFO
85 #include "xcoffout.h"
86 #endif
87 \f
88 #ifdef VMS
89 /* The extra parameters substantially improve the I/O performance.  */
90 static FILE *
91 vms_fopen (fname, type)
92      char * fname;
93      char * type;
94 {
95   /* The <stdio.h> in the gcc-vms-1.42 distribution prototypes fopen with two
96      fixed arguments, which matches ANSI's specification but not VAXCRTL's
97      pre-ANSI implementation.  This hack circumvents the mismatch problem.  */
98   FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
99
100   if (*type == 'w')
101     return (*vmslib_fopen) (fname, type, "mbc=32",
102                             "deq=64", "fop=tef", "shr=nil");
103   else
104     return (*vmslib_fopen) (fname, type, "mbc=32");
105 }
106 #define fopen vms_fopen
107 #endif  /* VMS */
108
109 #ifndef DEFAULT_GDB_EXTENSIONS
110 #define DEFAULT_GDB_EXTENSIONS 1
111 #endif
112
113 /* If more than one debugging type is supported, you must define
114    PREFERRED_DEBUGGING_TYPE to choose a format in a system-dependent way. 
115
116    This is one long line cause VAXC can't handle a \-newline.  */
117 #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) + defined (DWARF_DEBUGGING_INFO) + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO))
118 #ifndef PREFERRED_DEBUGGING_TYPE
119 You Lose!  You must define PREFERRED_DEBUGGING_TYPE!
120 #endif /* no PREFERRED_DEBUGGING_TYPE */
121 #else /* Only one debugging format supported.  Define PREFERRED_DEBUGGING_TYPE
122          so the following code needn't care.  */
123 #ifdef DBX_DEBUGGING_INFO
124 #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
125 #endif
126 #ifdef SDB_DEBUGGING_INFO
127 #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG
128 #endif
129 #ifdef DWARF_DEBUGGING_INFO
130 #define PREFERRED_DEBUGGING_TYPE DWARF_DEBUG
131 #endif
132 #ifdef DWARF2_DEBUGGING_INFO
133 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
134 #endif
135 #ifdef XCOFF_DEBUGGING_INFO
136 #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG
137 #endif
138 #endif /* More than one debugger format enabled.  */
139
140 /* If still not defined, must have been because no debugging formats
141    are supported.  */
142 #ifndef PREFERRED_DEBUGGING_TYPE
143 #define PREFERRED_DEBUGGING_TYPE NO_DEBUG
144 #endif
145
146 #ifdef NEED_DECLARATION_ENVIRON
147 extern char **environ;
148 #endif
149
150 /* Carry information from ASM_DECLARE_OBJECT_NAME
151    to ASM_FINISH_DECLARE_OBJECT.  */
152
153 extern int size_directive_output;
154 extern tree last_assemble_variable_decl;
155
156 static void set_target_switch PARAMS ((const char *));
157 static const char *decl_name PARAMS ((tree, int));
158
159 static void float_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
160 static void pipe_closed PARAMS ((int)) ATTRIBUTE_NORETURN;
161 #ifdef ASM_IDENTIFY_LANGUAGE
162 /* This might or might not be used in ASM_IDENTIFY_LANGUAGE. */
163 static void output_lang_identify PARAMS ((FILE *)) ATTRIBUTE_UNUSED;
164 #endif
165 static void compile_file PARAMS ((char *));
166 static void display_help PARAMS ((void));
167 static void mark_file_stack PARAMS ((void *));
168
169 static void decode_d_option PARAMS ((const char *));
170 static int decode_f_option PARAMS ((const char *));
171 static int decode_W_option PARAMS ((const char *));
172 static int decode_g_option PARAMS ((const char *));
173 static unsigned int independent_decode_option PARAMS ((int, char **,
174                                                        unsigned int));
175
176 static void print_version PARAMS ((FILE *, const char *));
177 static int print_single_switch PARAMS ((FILE *, int, int, const char *,
178                                       const char *, const char *,
179                                       const char *, const char *));
180 static void print_switch_values PARAMS ((FILE *, int, int, const char *,
181                                        const char *, const char *));
182
183 /* Length of line when printing switch values.  */
184 #define MAX_LINE 75
185
186 /* Name of program invoked, sans directories.  */
187
188 const char *progname;
189
190 /* Copy of arguments to main.  */
191 int save_argc;
192 char **save_argv;
193 \f
194 /* Name of current original source file (what was input to cpp).
195    This comes from each #-command in the actual input.  */
196
197 char *input_filename;
198
199 /* Name of top-level original source file (what was input to cpp).
200    This comes from the #-command at the beginning of the actual input.
201    If there isn't any there, then this is the cc1 input file name.  */
202
203 char *main_input_filename;
204
205 /* Current line number in real source file.  */
206
207 int lineno;
208
209 /* Nonzero if it is unsafe to create any new pseudo registers.  */
210 int no_new_pseudos;
211
212 /* Stack of currently pending input files.  */
213
214 struct file_stack *input_file_stack;
215
216 /* Incremented on each change to input_file_stack.  */
217 int input_file_stack_tick;
218
219 /* Name to use as base of names for dump output files.  */
220
221 const char *dump_base_name;
222
223 /* Bit flags that specify the machine subtype we are compiling for.
224    Bits are tested using macros TARGET_... defined in the tm.h file
225    and set by `-m...' switches.  Must be defined in rtlanal.c.  */
226
227 extern int target_flags;
228
229 /* Describes a dump file.  */
230
231 struct dump_file_info
232 {
233   /* The unique extension to apply, e.g. ".jump".  */
234   const char * const extension;
235
236   /* The -d<c> character that enables this dump file.  */
237   char const debug_switch;
238
239   /* True if there is a corresponding graph dump file.  */
240   char const graph_dump_p;
241
242   /* True if the user selected this dump.  */
243   char enabled;
244
245   /* True if the files have been initialized (ie truncated).  */
246   char initialized;
247 };
248
249 /* Enumerate the extant dump files.  */
250
251 enum dump_file_index
252 {
253   DFI_rtl,
254   DFI_jump,
255   DFI_cse,
256   DFI_addressof,
257   DFI_ssa,
258   DFI_ussa,
259   DFI_gcse,
260   DFI_loop,
261   DFI_cse2,
262   DFI_bp,
263   DFI_flow,
264   DFI_combine,
265   DFI_regmove,
266   DFI_sched,
267   DFI_lreg,
268   DFI_greg,
269   DFI_flow2,
270   DFI_peephole2,
271   DFI_sched2,
272   DFI_bbro,
273   DFI_rnreg,
274   DFI_jump2,
275   DFI_mach,
276   DFI_dbr,
277   DFI_stack,
278   DFI_MAX
279 };
280
281 /* Describes all the dump files.  Should be kept in order of the
282    pass and in sync with dump_file_index above.  */
283
284 struct dump_file_info dump_file[DFI_MAX] = 
285 {
286   { "rtl",      'r', 0, 0, 0 },
287   { "jump",     'j', 0, 0, 0 },
288   { "cse",      's', 0, 0, 0 },
289   { "addressof", 'F', 0, 0, 0 },
290   { "ssa",      'e', 1, 0, 0 },
291   { "ussa",     'e', 1, 0, 0 }, /* Yes, duplicate enable switch.  */
292   { "gcse",     'G', 1, 0, 0 },
293   { "loop",     'L', 1, 0, 0 },
294   { "cse2",     't', 1, 0, 0 },
295   { "bp",       'b', 1, 0, 0 },
296   { "flow",     'f', 1, 0, 0 },
297   { "combine",  'c', 1, 0, 0 },
298   { "regmove",  'N', 1, 0, 0 },
299   { "sched",    'S', 1, 0, 0 },
300   { "lreg",     'l', 1, 0, 0 },
301   { "greg",     'g', 1, 0, 0 },
302   { "flow2",    'w', 1, 0, 0 },
303   { "peephole2", 'z', 1, 0, 0 },
304   { "sched2",   'R', 1, 0, 0 },
305   { "bbro",     'B', 1, 0, 0 },
306   { "rnreg",    'n', 1, 0, 0 },
307   { "jump2",    'J', 1, 0, 0 },
308   { "mach",     'M', 1, 0, 0 },
309   { "dbr",      'd', 0, 0, 0 },
310   { "stack",    'k', 1, 0, 0 },
311 };
312
313 static int open_dump_file PARAMS ((enum dump_file_index, tree));
314 static void close_dump_file PARAMS ((enum dump_file_index,
315                                      void (*) (FILE *, rtx), rtx));
316
317 /* Other flags saying which kinds of debugging dump have been requested.  */
318
319 int rtl_dump_and_exit;
320 int flag_print_asm_name;
321 static int flag_print_mem;
322 static int version_flag;
323 static char * filename;
324 enum graph_dump_types graph_dump_format;
325
326 /* Name for output file of assembly code, specified with -o.  */
327
328 char *asm_file_name;
329
330 /* Value of the -G xx switch, and whether it was passed or not.  */
331 int g_switch_value;
332 int g_switch_set;
333
334 /* Type(s) of debugging information we are producing (if any).
335    See flags.h for the definitions of the different possible
336    types of debugging information.  */
337 enum debug_info_type write_symbols = NO_DEBUG;
338
339 /* Level of debugging information we are producing.  See flags.h
340    for the definitions of the different possible levels.  */
341 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
342
343 /* Nonzero means use GNU-only extensions in the generated symbolic
344    debugging information.  */
345 /* Currently, this only has an effect when write_symbols is set to
346    DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */
347 int use_gnu_debug_info_extensions = 0;
348
349 /* Nonzero means do optimizations.  -O.
350    Particular numeric values stand for particular amounts of optimization;
351    thus, -O2 stores 2 here.  However, the optimizations beyond the basic
352    ones are not controlled directly by this variable.  Instead, they are
353    controlled by individual `flag_...' variables that are defaulted
354    based on this variable.  */
355
356 int optimize = 0;
357
358 /* Nonzero means optimize for size.  -Os.
359    The only valid values are zero and non-zero. When optimize_size is
360    non-zero, optimize defaults to 2, but certain individual code
361    bloating optimizations are disabled.  */
362
363 int optimize_size = 0;
364
365 /* Number of error messages and warning messages so far.  */
366
367 int errorcount = 0;
368 int warningcount = 0;
369 int sorrycount = 0;
370
371 /* The FUNCTION_DECL for the function currently being compiled,
372    or 0 if between functions.  */
373 tree current_function_decl;
374
375 /* Set to the FUNC_BEGIN label of the current function, or NULL_TREE
376    if none.  */
377 tree current_function_func_begin_label;
378
379 /* Pointer to function to compute the name to use to print a declaration.
380    DECL is the declaration in question.
381    VERBOSITY determines what information will be printed:
382      0: DECL_NAME, demangled as necessary.
383      1: and scope information.
384      2: and any other information that might be interesting, such as function
385         parameter types in C++.  */
386
387 const char *(*decl_printable_name)      PARAMS ((tree, int));
388
389 /* Pointer to function to compute rtl for a language-specific tree code.  */
390
391 typedef rtx (*lang_expand_expr_t)
392   PARAMS ((union tree_node *, rtx, enum machine_mode,
393           enum expand_modifier modifier));
394
395 lang_expand_expr_t lang_expand_expr = 0;
396
397 tree (*lang_expand_constant) PARAMS ((tree)) = 0;
398
399 /* Pointer to function to finish handling an incomplete decl at the
400    end of compilation.  */
401
402 void (*incomplete_decl_finalize_hook) PARAMS ((tree)) = 0;
403
404 /* Nonzero if generating code to do profiling.  */
405
406 int profile_flag = 0;
407
408 /* Nonzero if generating code to do profiling on a line-by-line basis.  */
409
410 int profile_block_flag;
411
412 /* Nonzero if generating code to profile program flow graph arcs.  */
413
414 int profile_arc_flag = 0;
415
416 /* Nonzero if generating info for gcov to calculate line test coverage.  */
417
418 int flag_test_coverage = 0;
419
420 /* Nonzero indicates that branch taken probabilities should be calculated.  */
421
422 int flag_branch_probabilities = 0;
423
424 /* Nonzero if basic blocks should be reordered. */
425
426 int flag_reorder_blocks = 0;
427
428 /* Nonzero if registers should be renamed */
429
430 int flag_rename_registers = 0;
431
432 /* Nonzero for -pedantic switch: warn about anything
433    that standard spec forbids.  */
434
435 int pedantic = 0;
436
437 /* Temporarily suppress certain warnings.
438    This is set while reading code from a system header file.  */
439
440 int in_system_header = 0;
441
442 /* Don't print functions as they are compiled and don't print
443    times taken by the various passes.  -quiet.  */
444
445 int quiet_flag = 0;
446 \f
447 /* -f flags.  */
448
449 /* Nonzero means `char' should be signed.  */
450
451 int flag_signed_char;
452
453 /* Nonzero means give an enum type only as many bytes as it needs.  */
454
455 int flag_short_enums;
456
457 /* Nonzero for -fcaller-saves: allocate values in regs that need to
458    be saved across function calls, if that produces overall better code.
459    Optional now, so people can test it.  */
460
461 #ifdef DEFAULT_CALLER_SAVES
462 int flag_caller_saves = 1;
463 #else
464 int flag_caller_saves = 0;
465 #endif
466
467 /* Nonzero if structures and unions should be returned in memory.
468
469    This should only be defined if compatibility with another compiler or
470    with an ABI is needed, because it results in slower code.  */
471
472 #ifndef DEFAULT_PCC_STRUCT_RETURN
473 #define DEFAULT_PCC_STRUCT_RETURN 1
474 #endif
475
476 /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
477
478 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
479
480 /* Nonzero for -fforce-mem: load memory value into a register
481    before arithmetic on it.  This makes better cse but slower compilation.  */
482
483 int flag_force_mem = 0;
484
485 /* Nonzero for -fforce-addr: load memory address into a register before
486    reference to memory.  This makes better cse but slower compilation.  */
487
488 int flag_force_addr = 0;
489
490 /* Nonzero for -fdefer-pop: don't pop args after each function call;
491    instead save them up to pop many calls' args with one insns.  */
492
493 int flag_defer_pop = 0;
494
495 /* Nonzero for -ffloat-store: don't allocate floats and doubles
496    in extended-precision registers.  */
497
498 int flag_float_store = 0;
499
500 /* Nonzero for -fcse-follow-jumps:
501    have cse follow jumps to do a more extensive job.  */
502
503 int flag_cse_follow_jumps;
504
505 /* Nonzero for -fcse-skip-blocks:
506    have cse follow a branch around a block.  */
507 int flag_cse_skip_blocks;
508
509 /* Nonzero for -fexpensive-optimizations:
510    perform miscellaneous relatively-expensive optimizations.  */
511 int flag_expensive_optimizations;
512
513 /* Nonzero for -fthread-jumps:
514    have jump optimize output of loop.  */
515
516 int flag_thread_jumps;
517
518 /* Nonzero enables strength-reduction in loop.c.  */
519
520 int flag_strength_reduce = 0;
521
522 /* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
523    number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
524    UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
525    unrolled.  */
526
527 int flag_unroll_loops;
528
529 /* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
530    This is generally not a win.  */
531
532 int flag_unroll_all_loops;
533
534 /* Nonzero forces all invariant computations in loops to be moved
535    outside the loop. */
536
537 int flag_move_all_movables = 0;
538
539 /* Nonzero forces all general induction variables in loops to be
540    strength reduced. */
541
542 int flag_reduce_all_givs = 0;
543
544 /* Nonzero to perform full register move optimization passes.  This is the
545    default for -O2.  */
546
547 int flag_regmove = 0;
548
549 /* Nonzero for -fwritable-strings:
550    store string constants in data segment and don't uniquize them.  */
551
552 int flag_writable_strings = 0;
553
554 /* Nonzero means don't put addresses of constant functions in registers.
555    Used for compiling the Unix kernel, where strange substitutions are
556    done on the assembly output.  */
557
558 int flag_no_function_cse = 0;
559
560 /* Nonzero for -fomit-frame-pointer:
561    don't make a frame pointer in simple functions that don't require one.  */
562
563 int flag_omit_frame_pointer = 0;
564
565 /* Nonzero means place each function into its own section on those platforms
566    which support arbitrary section names and unlimited numbers of sections.  */
567
568 int flag_function_sections = 0;
569
570 /* ... and similar for data.  */
571  
572 int flag_data_sections = 0;
573
574 /* Nonzero to inhibit use of define_optimization peephole opts.  */
575
576 int flag_no_peephole = 0;
577
578 /* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math
579    operations in the interest of optimization.  For example it allows
580    GCC to assume arguments to sqrt are nonnegative numbers, allowing
581    faster code for sqrt to be generated.  */
582
583 int flag_fast_math = 0;
584
585 /* Nonzero allows GCC to optimize sibling and tail recursive calls.  */
586
587 int flag_optimize_sibling_calls = 0;
588
589 /* Nonzero means the front end generally wants `errno' maintained by math
590    operations, like built-in SQRT, unless overridden by flag_fast_math.  */
591
592 int flag_errno_math = 1;
593
594 /* 0 means straightforward implementation of complex divide acceptable.
595    1 means wide ranges of inputs must work for complex divide.
596    2 means C9X-like requirements for complex divide (not yet implemented).  */
597
598 int flag_complex_divide_method = 0;
599
600 /* Nonzero means all references through pointers are volatile.  */
601
602 int flag_volatile;
603
604 /* Nonzero means treat all global and extern variables as volatile.  */
605
606 int flag_volatile_global;
607
608 /* Nonzero means treat all static variables as volatile.  */
609
610 int flag_volatile_static;
611
612 /* Nonzero means just do syntax checking; don't output anything.  */
613
614 int flag_syntax_only = 0;
615
616 /* Nonzero means perform global cse.  */
617
618 static int flag_gcse;
619
620 /* Nonzero means to use global dataflow analysis to eliminate
621    useless null pointer tests.  */
622
623 static int flag_delete_null_pointer_checks;
624
625 /* Nonzero means to rerun cse after loop optimization.  This increases
626    compilation time about 20% and picks up a few more common expressions.  */
627
628 static int flag_rerun_cse_after_loop;
629
630 /* Nonzero means to run loop optimizations twice.  */
631
632 int flag_rerun_loop_opt;
633
634 /* Nonzero for -finline-functions: ok to inline functions that look like
635    good inline candidates.  */
636
637 int flag_inline_functions;
638
639 /* Nonzero for -fkeep-inline-functions: even if we make a function
640    go inline everywhere, keep its definition around for debugging
641    purposes.  */
642
643 int flag_keep_inline_functions;
644
645 /* Nonzero means that functions will not be inlined.  */
646
647 int flag_no_inline;
648
649 /* Nonzero means that we should emit static const variables
650    regardless of whether or not optimization is turned on.  */
651
652 int flag_keep_static_consts = 1;
653
654 /* Nonzero means we should be saving declaration info into a .X file.  */
655
656 int flag_gen_aux_info = 0;
657
658 /* Specified name of aux-info file.  */
659
660 static char *aux_info_file_name;
661
662 /* Nonzero means make the text shared if supported.  */
663
664 int flag_shared_data;
665
666 /* Nonzero means schedule into delayed branch slots if supported.  */
667
668 int flag_delayed_branch;
669
670 /* Nonzero if we are compiling pure (sharable) code.
671    Value is 1 if we are doing reasonable (i.e. simple
672    offset into offset table) pic.  Value is 2 if we can
673    only perform register offsets.  */
674
675 int flag_pic;
676
677 /* Nonzero means generate extra code for exception handling and enable
678    exception handling.  */
679
680 int flag_exceptions;
681
682 /* Nonzero means use the new model for exception handling. Replaces 
683    -DNEW_EH_MODEL as a compile option. */
684
685 int flag_new_exceptions = 1;
686
687 /* Nonzero means generate frame unwind info table when supported */
688
689 int flag_unwind_tables = 0;
690
691 /* Nonzero means don't place uninitialized global data in common storage
692    by default.  */
693
694 int flag_no_common;
695
696 /* Nonzero means pretend it is OK to examine bits of target floats,
697    even if that isn't true.  The resulting code will have incorrect constants,
698    but the same series of instructions that the native compiler would make.  */
699
700 int flag_pretend_float;
701
702 /* Nonzero means change certain warnings into errors.
703    Usually these are warnings about failure to conform to some standard.  */
704
705 int flag_pedantic_errors = 0;
706
707 /* flag_schedule_insns means schedule insns within basic blocks (before
708    local_alloc).
709    flag_schedule_insns_after_reload means schedule insns after
710    global_alloc.  */
711
712 int flag_schedule_insns = 0;
713 int flag_schedule_insns_after_reload = 0;
714
715 /* The following flags have effect only for scheduling before register
716    allocation:
717
718    flag_schedule_interblock means schedule insns accross basic blocks.
719    flag_schedule_speculative means allow speculative motion of non-load insns.
720    flag_schedule_speculative_load means allow speculative motion of some
721    load insns.
722    flag_schedule_speculative_load_dangerous allows speculative motion of more
723    load insns.  */
724
725 int flag_schedule_interblock = 1;
726 int flag_schedule_speculative = 1;
727 int flag_schedule_speculative_load = 0;
728 int flag_schedule_speculative_load_dangerous = 0;
729
730 /* flag_on_branch_count_reg means try to replace add-1,compare,branch tupple
731    by a cheaper branch, on a count register. */
732 int flag_branch_on_count_reg;
733
734 /* -finhibit-size-directive inhibits output of .size for ELF.
735    This is used only for compiling crtstuff.c, 
736    and it may be extended to other effects
737    needed for crtstuff.c on other systems.  */
738 int flag_inhibit_size_directive = 0;
739
740 /* -fverbose-asm causes extra commentary information to be produced in
741    the generated assembly code (to make it more readable).  This option
742    is generally only of use to those who actually need to read the
743    generated assembly code (perhaps while debugging the compiler itself).
744    -fno-verbose-asm, the default, causes the extra information
745    to be omitted and is useful when comparing two assembler files.  */
746
747 int flag_verbose_asm = 0;
748
749 /* -dA causes debug commentary information to be produced in
750    the generated assembly code (to make it more readable).  This option
751    is generally only of use to those who actually need to read the
752    generated assembly code (perhaps while debugging the compiler itself).
753    Currently, this switch is only used by dwarfout.c; however, it is intended
754    to be a catchall for printing debug information in the assembler file.  */
755
756 int flag_debug_asm = 0;
757
758 /* -fgnu-linker specifies use of the GNU linker for initializations.
759    (Or, more generally, a linker that handles initializations.)
760    -fno-gnu-linker says that collect2 will be used.  */
761 #ifdef USE_COLLECT2
762 int flag_gnu_linker = 0;
763 #else
764 int flag_gnu_linker = 1;
765 #endif
766
767 /* Enable SSA.  */
768 int flag_ssa = 0;
769
770 /* Tag all structures with __attribute__(packed) */
771 int flag_pack_struct = 0;
772
773 /* Emit code to check for stack overflow; also may cause large objects
774    to be allocated dynamically.  */
775 int flag_stack_check;
776
777 /* When non-NULL, indicates that whenever space is allocated on the
778    stack, the resulting stack pointer must not pass this
779    address---that is, for stacks that grow downward, the stack pointer
780    must always be greater than or equal to this address; for stacks
781    that grow upward, the stack pointer must be less than this address.
782    At present, the rtx may be either a REG or a SYMBOL_REF, although
783    the support provided depends on the backend.  */
784 rtx stack_limit_rtx;
785
786 /* -fcheck-memory-usage causes extra code to be generated in order to check
787    memory accesses.  This is used by a detector of bad memory accesses such
788    as Checker.  */
789 int flag_check_memory_usage = 0;
790
791 /* -fprefix-function-name causes function name to be prefixed.  This
792    can be used with -fcheck-memory-usage to isolate code compiled with
793    -fcheck-memory-usage.  */
794 int flag_prefix_function_name = 0;
795
796 /* 0 if pointer arguments may alias each other.  True in C.
797    1 if pointer arguments may not alias each other but may alias
798    global variables.
799    2 if pointer arguments may not alias each other and may not
800    alias global variables.  True in Fortran.
801    This defaults to 0 for C.  */
802 int flag_argument_noalias = 0;
803
804 /* Nonzero if we should do (language-dependent) alias analysis.
805    Typically, this analysis will assume that expressions of certain
806    types do not alias expressions of certain other types.  Only used
807    if alias analysis (in general) is enabled.  */
808 int flag_strict_aliasing = 0;
809
810 /* Instrument functions with calls at entry and exit, for profiling.  */
811 int flag_instrument_function_entry_exit = 0;
812
813 /* Nonzero means ignore `#ident' directives.  0 means handle them.
814    On SVR4 targets, it also controls whether or not to emit a
815    string identifying the compiler.  */
816
817 int flag_no_ident = 0;
818
819 /* This will perform a peephole pass before sched2. */
820 int flag_peephole2 = 0;
821
822 /* -fbounded-pointers causes gcc to compile pointers as composite
823    objects occupying three words: the pointer value, the base address
824    of the referent object, and the address immediately beyond the end
825    of the referent object.  The base and extent allow us to perform
826    runtime bounds checking.  -fbounded-pointers implies -fcheck-bounds.  */
827 int flag_bounded_pointers = 0;
828
829 /* -fcheck-bounds causes gcc to generate array bounds checks.
830    For C, C++: defaults to value of flag_bounded_pointers.
831    For ObjC: defaults to off.
832    For Java: defaults to on.
833    For Fortran: defaults to off.
834    For CHILL: defaults to off.  */
835 int flag_bounds_check = 0;
836
837 /* If one, renumber instruction UIDs to reduce the number of
838    unused UIDs if there are a lot of instructions.  If greater than
839    one, unconditionally renumber instruction UIDs.  */
840 int flag_renumber_insns = 1;
841
842 /* Values of the -falign-* flags: how much to align labels in code. 
843    0 means `use default', 1 means `don't align'.  
844    For each variable, there is an _log variant which is the power
845    of two not less than the variable, for .align output.  */
846
847 int align_loops;
848 int align_loops_log;
849 int align_jumps;
850 int align_jumps_log;
851 int align_labels;
852 int align_labels_log;
853 int align_functions;
854 int align_functions_log;
855
856 /* Table of supported debugging formats.  */
857 static struct
858 {
859   const char * arg;
860   /* Since PREFERRED_DEBUGGING_TYPE isn't necessarily a
861      constant expression, we use NO_DEBUG in its place.  */
862   enum debug_info_type debug_type;
863   int use_extensions_p;
864   const char * description;
865 } *da,
866 debug_args[] =
867 {
868   { "",       NO_DEBUG, DEFAULT_GDB_EXTENSIONS,
869     "Generate default debug format output" },
870   { "gdb",    NO_DEBUG, 1, "Generate default extended debug format output" },
871 #ifdef DBX_DEBUGGING_INFO
872   { "stabs",  DBX_DEBUG, 0, "Generate STABS format debug output" },
873   { "stabs+", DBX_DEBUG, 1, "Generate extended STABS format debug output" },
874 #endif
875 #ifdef DWARF_DEBUGGING_INFO
876   { "dwarf",  DWARF_DEBUG, 0, "Generate DWARF-1 format debug output"},
877   { "dwarf+", DWARF_DEBUG, 1,
878     "Generated extended DWARF-1 format debug output" },
879 #endif
880 #ifdef DWARF2_DEBUGGING_INFO
881   { "dwarf-2", DWARF2_DEBUG, 0, "Enable DWARF-2 debug output" },
882 #endif
883 #ifdef XCOFF_DEBUGGING_INFO
884   { "xcoff",  XCOFF_DEBUG, 0, "Generate XCOFF format debug output" },
885   { "xcoff+", XCOFF_DEBUG, 1, "Generate extended XCOFF format debug output" },
886 #endif
887 #ifdef SDB_DEBUGGING_INFO
888   { "coff", SDB_DEBUG, 0, "Generate COFF format debug output" },
889 #endif
890   { 0, 0, 0, 0 }
891 };
892
893 typedef struct
894 {
895   const char * string;
896   int *  variable;
897   int    on_value;
898   const char * description;
899 }
900 lang_independent_options;
901
902 /* Add or remove a leading underscore from user symbols.  */
903 int flag_leading_underscore = -1;
904
905 /* The user symbol prefix after having resolved same.  */
906 const char *user_label_prefix;
907
908 /* A default for same.  */
909 #ifndef USER_LABEL_PREFIX
910 #define USER_LABEL_PREFIX ""
911 #endif
912
913 /* Table of language-independent -f options.
914    STRING is the option name.  VARIABLE is the address of the variable.
915    ON_VALUE is the value to store in VARIABLE
916     if `-fSTRING' is seen as an option.
917    (If `-fno-STRING' is seen as an option, the opposite value is stored.)  */
918
919 lang_independent_options f_options[] =
920 {
921   {"float-store", &flag_float_store, 1,
922    "Do not store floats in registers" },
923   {"volatile", &flag_volatile, 1,
924    "Consider all mem refs through pointers as volatile"},
925   {"volatile-global", &flag_volatile_global, 1,
926    "Consider all mem refs to global data to be volatile" },
927   {"volatile-static", &flag_volatile_static, 1,
928    "Consider all mem refs to static data to be volatile" },
929   {"defer-pop", &flag_defer_pop, 1,
930    "Defer popping functions args from stack until later" },
931   {"omit-frame-pointer", &flag_omit_frame_pointer, 1,
932    "When possible do not generate stack frames"},
933   {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1,
934    "Optimize sibling and tail recursive calls" },
935   {"cse-follow-jumps", &flag_cse_follow_jumps, 1,
936    "When running CSE, follow jumps to their targets" },
937   {"cse-skip-blocks", &flag_cse_skip_blocks, 1,
938    "When running CSE, follow conditional jumps" },
939   {"expensive-optimizations", &flag_expensive_optimizations, 1,
940    "Perform a number of minor, expensive optimisations" },
941   {"thread-jumps", &flag_thread_jumps, 1,
942    "Perform jump threading optimisations"},
943   {"strength-reduce", &flag_strength_reduce, 1,
944    "Perform strength reduction optimisations" },
945   {"unroll-loops", &flag_unroll_loops, 1,
946    "Perform loop unrolling when iteration count is known" },
947   {"unroll-all-loops", &flag_unroll_all_loops, 1,
948    "Perform loop unrolling for all loops" },
949   {"move-all-movables", &flag_move_all_movables, 1,
950    "Force all loop invariant computations out of loops" },
951   {"reduce-all-givs", &flag_reduce_all_givs, 1,
952    "Strength reduce all loop general induction variables" },
953   {"writable-strings", &flag_writable_strings, 1,
954    "Store strings in writable data section" },
955   {"peephole", &flag_no_peephole, 0,
956    "Enable machine specific peephole optimisations" },
957   {"force-mem", &flag_force_mem, 1,
958    "Copy memory operands into registers before using" },
959   {"force-addr", &flag_force_addr, 1,
960    "Copy memory address constants into regs before using" },
961   {"function-cse", &flag_no_function_cse, 0,
962    "Allow function addresses to be held in registers" },
963   {"inline-functions", &flag_inline_functions, 1,
964    "Integrate simple functions into their callers" },
965   {"keep-inline-functions", &flag_keep_inline_functions, 1,
966    "Generate code for funcs even if they are fully inlined" },
967   {"inline", &flag_no_inline, 0,
968    "Pay attention to the 'inline' keyword"},
969   {"keep-static-consts", &flag_keep_static_consts, 1,
970    "Emit static const variables even if they are not used" },
971   {"syntax-only", &flag_syntax_only, 1,
972    "Check for syntax errors, then stop" },
973   {"shared-data", &flag_shared_data, 1,
974    "Mark data as shared rather than private" },
975   {"caller-saves", &flag_caller_saves, 1,
976    "Enable saving registers around function calls" },
977   {"pcc-struct-return", &flag_pcc_struct_return, 1,
978    "Return 'short' aggregates in memory, not registers" },
979   {"reg-struct-return", &flag_pcc_struct_return, 0,
980    "Return 'short' aggregates in registers" },
981   {"delayed-branch", &flag_delayed_branch, 1,
982    "Attempt to fill delay slots of branch instructions" },
983   {"gcse", &flag_gcse, 1,
984    "Perform the global common subexpression elimination" },
985   {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
986    "Run CSE pass after loop optimisations"},
987   {"rerun-loop-opt", &flag_rerun_loop_opt, 1,
988    "Run the loop optimiser twice"},
989   {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
990    "Delete useless null pointer checks" },
991   {"pretend-float", &flag_pretend_float, 1,
992    "Pretend that host and target use the same FP format"},
993   {"schedule-insns", &flag_schedule_insns, 1,
994    "Reschedule instructions to avoid pipeline stalls"},
995   {"schedule-insns2", &flag_schedule_insns_after_reload, 1,
996   "Run two passes of the instruction scheduler"},
997   {"sched-interblock",&flag_schedule_interblock, 1,
998    "Enable scheduling across basic blocks" },
999   {"sched-spec",&flag_schedule_speculative, 1,
1000    "Allow speculative motion of non-loads" },
1001   {"sched-spec-load",&flag_schedule_speculative_load, 1,
1002    "Allow speculative motion of some loads" },
1003   {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
1004    "Allow speculative motion of more loads" },
1005   {"branch-count-reg",&flag_branch_on_count_reg, 1,
1006    "Replace add,compare,branch with branch on count reg"},
1007   {"pic", &flag_pic, 1,
1008    "Generate position independent code, if possible"},
1009   {"PIC", &flag_pic, 2, ""},
1010   {"exceptions", &flag_exceptions, 1,
1011    "Enable exception handling" },
1012   {"new-exceptions", &flag_new_exceptions, 1,
1013    "Use the new model for exception handling" },
1014   {"unwind-tables", &flag_unwind_tables, 1,
1015     "Just generate unwind tables for exception handling" },
1016   {"sjlj-exceptions", &exceptions_via_longjmp, 1,
1017    "Use setjmp/longjmp to handle exceptions" },
1018   {"asynchronous-exceptions", &asynchronous_exceptions, 1,
1019    "Support asynchronous exceptions" },
1020   {"profile-arcs", &profile_arc_flag, 1,
1021    "Insert arc based program profiling code" },
1022   {"test-coverage", &flag_test_coverage, 1,
1023    "Create data files needed by gcov" },
1024   {"branch-probabilities", &flag_branch_probabilities, 1,
1025    "Use profiling information for branch probabilities" },
1026   {"reorder-blocks", &flag_reorder_blocks, 1,
1027    "Reorder basic blocks to improve code placement" },
1028   {"rename-registers", &flag_rename_registers, 1,
1029    "Do the register renaming optimization pass"},
1030   {"fast-math", &flag_fast_math, 1,
1031    "Improve FP speed by violating ANSI & IEEE rules" },
1032   {"common", &flag_no_common, 0,
1033    "Do not put unitialised globals in the common section" },
1034   {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
1035    "Do not generate .size directives" },
1036   {"function-sections", &flag_function_sections, 1,
1037    "place each function into its own section" },
1038   {"data-sections", &flag_data_sections, 1,
1039    "place data items into their own section" },
1040   {"verbose-asm", &flag_verbose_asm, 1,
1041    "Add extra commentry to assembler output"},
1042   {"gnu-linker", &flag_gnu_linker, 1,
1043    "Output GNU ld formatted global initialisers"},
1044   {"regmove", &flag_regmove, 1,
1045    "Enables a register move optimisation"},
1046   {"optimize-register-move", &flag_regmove, 1,
1047    "Do the full regmove optimization pass"},
1048   {"pack-struct", &flag_pack_struct, 1,
1049    "Pack structure members together without holes" },
1050   {"stack-check", &flag_stack_check, 1,
1051    "Insert stack checking code into the program" },
1052   {"argument-alias", &flag_argument_noalias, 0,
1053    "Specify that arguments may alias each other & globals"},
1054   {"argument-noalias", &flag_argument_noalias, 1,
1055    "Assume arguments may alias globals but not each other"},
1056   {"argument-noalias-global", &flag_argument_noalias, 2,
1057    "Assume arguments do not alias each other or globals" },
1058   {"strict-aliasing", &flag_strict_aliasing, 1,
1059    "Assume strict aliasing rules apply" },
1060   {"align-loops", &align_loops, 0, 
1061    "Align the start of loops" },
1062   {"align-jumps", &align_jumps, 0, 
1063    "Align labels which are only reached by jumping" },
1064   {"align-labels", &align_labels, 0,
1065    "Align all labels" },
1066   {"align-functions", &align_functions, 0,
1067    "Align the start of functions" },
1068   {"check-memory-usage", &flag_check_memory_usage, 1,
1069    "Generate code to check every memory access" },
1070   {"prefix-function-name", &flag_prefix_function_name, 1,
1071    "Add a prefix to all function names" },
1072   {"dump-unnumbered", &flag_dump_unnumbered, 1,
1073    "Suppress output of instruction numbers and line number notes in debugging dumps"},
1074   {"instrument-functions", &flag_instrument_function_entry_exit, 1,
1075    "Instrument function entry/exit with profiling calls"},
1076   {"ssa", &flag_ssa, 1,
1077    "Enable SSA optimizations" },
1078   {"leading-underscore", &flag_leading_underscore, 1,
1079    "External symbols have a leading underscore" },
1080   {"ident", &flag_no_ident, 0,
1081    "Process #ident directives"},
1082   { "peephole2", &flag_peephole2, 1,
1083     "Enables an rtl peephole pass run before sched2" },
1084   {"math-errno", &flag_errno_math, 1,
1085    "Set errno after built-in math functions"},
1086   {"bounded-pointers", &flag_bounded_pointers, 1,
1087    "Compile pointers as triples: value, base & end" },
1088   {"bounds-check", &flag_bounds_check, 1,
1089    "Generate code to check bounds before dereferencing pointers and arrays" }
1090 };
1091
1092 #define NUM_ELEM(a)  (sizeof (a) / sizeof ((a)[0]))
1093
1094 /* Table of language-specific options.  */
1095
1096 static struct lang_opt
1097 {
1098   const char * option;
1099   const char * description;
1100 }
1101 documented_lang_options[] =
1102 {
1103   /* In order not to overload the --help output, the convention
1104      used here is to only describe those options which are not
1105      enabled by default.  */
1106
1107   { "-ansi", "Compile just for ANSI C" },
1108   { "-fallow-single-precision",
1109     "Do not promote floats to double if using -traditional" },
1110   { "-std= ", "Determine language standard"},
1111
1112   { "-fsigned-bitfields", "" },
1113   { "-funsigned-bitfields","Make bitfields by unsigned by default" },
1114   { "-fno-signed-bitfields", "" },
1115   { "-fno-unsigned-bitfields","" },
1116   { "-fsigned-char", "Make 'char' be signed by default"},
1117   { "-funsigned-char", "Make 'char' be unsigned by default"},
1118   { "-fno-signed-char", "" },
1119   { "-fno-unsigned-char", "" },
1120
1121   { "-ftraditional", "" },
1122   { "-traditional", "Attempt to support traditional K&R style C"},
1123   { "-fnotraditional", "" },
1124   { "-fno-traditional", "" },
1125
1126   { "-fasm", "" },
1127   { "-fno-asm", "Do not recognise the 'asm' keyword" },
1128   { "-fbuiltin", "" },
1129   { "-fno-builtin", "Do not recognise any built in functions" },
1130   { "-fhosted", "Assume normal C execution environment" },
1131   { "-fno-hosted", "" },
1132   { "-ffreestanding",
1133     "Assume that standard libraries & main might not exist" },
1134   { "-fno-freestanding", "" },
1135   { "-fcond-mismatch", "Allow different types as args of ? operator"},
1136   { "-fno-cond-mismatch", "" },
1137   { "-fdollars-in-identifiers", "Allow the use of $ inside identifiers" },
1138   { "-fno-dollars-in-identifiers", "" },
1139   { "-fpreprocessed", "" },
1140   { "-fno-preprocessed", "" },
1141   { "-fshort-double", "Use the same size for double as for float" },
1142   { "-fno-short-double", "" },
1143   { "-fshort-enums", "Use the smallest fitting integer to hold enums"},
1144   { "-fno-short-enums", "" },
1145   { "-fshort-wchar", "Override the underlying type for wchar_t to `unsigned short'" },
1146   { "-fno-short-wchar", "" },
1147
1148   { "-Wall", "Enable most warning messages" },
1149   { "-Wbad-function-cast",
1150     "Warn about casting functions to incompatible types" },
1151   { "-Wno-bad-function-cast", "" },
1152   { "-Wmissing-noreturn",
1153     "Warn about functions which might be candidates for attribute noreturn" },
1154   { "-Wno-missing-noreturn", "" },
1155   { "-Wcast-qual", "Warn about casts which discard qualifiers"},
1156   { "-Wno-cast-qual", "" },
1157   { "-Wchar-subscripts", "Warn about subscripts whose type is 'char'"},
1158   { "-Wno-char-subscripts", "" },
1159   { "-Wcomment", "Warn if nested comments are detected" },
1160   { "-Wno-comment", "" },
1161   { "-Wcomments", "Warn if nested comments are detected" },
1162   { "-Wno-comments", "" },
1163   { "-Wconversion", "Warn about possibly confusing type conversions" },
1164   { "-Wno-conversion", "" },
1165   { "-Wformat", "Warn about printf format anomalies" },
1166   { "-Wno-format", "" },
1167   { "-Wimplicit-function-declaration",
1168     "Warn about implicit function declarations" },
1169   { "-Wno-implicit-function-declaration", "" },
1170   { "-Werror-implicit-function-declaration", "" },
1171   { "-Wimplicit-int", "Warn when a declaration does not specify a type" },
1172   { "-Wno-implicit-int", "" },
1173   { "-Wimplicit", "" },
1174   { "-Wno-implicit", "" },
1175   { "-Wimport", "Warn about the use of the #import directive" },
1176   { "-Wno-import", "" },
1177   { "-Wlong-long","" },
1178   { "-Wno-long-long", "Do not warn about using 'long long' when -pedantic" },
1179   { "-Wmain", "Warn about suspicious declarations of main" },
1180   { "-Wno-main", "" },
1181   { "-Wmissing-braces",
1182     "Warn about possibly missing braces around initialisers" },
1183   { "-Wno-missing-braces", "" },
1184   { "-Wmissing-declarations",
1185     "Warn about global funcs without previous declarations"},
1186   { "-Wno-missing-declarations", "" },
1187   { "-Wmissing-prototypes", "Warn about global funcs without prototypes" },
1188   { "-Wno-missing-prototypes", "" },
1189   { "-Wmultichar", "Warn about use of multicharacter literals"},
1190   { "-Wno-multichar", "" },
1191   { "-Wnested-externs", "Warn about externs not at file scope level" },
1192   { "-Wno-nested-externs", "" },
1193   { "-Wparentheses", "Warn about possible missing parentheses" },
1194   { "-Wno-parentheses", "" },
1195   { "-Wpointer-arith", "Warn about function pointer arithmetic" },
1196   { "-Wno-pointer-arith", "" },
1197   { "-Wredundant-decls",
1198     "Warn about multiple declarations of the same object" },
1199   { "-Wno-redundant-decls", "" },
1200   { "-Wsign-compare", "Warn about signed/unsigned comparisons" },
1201   { "-Wno-sign-compare", "" },
1202   { "-Wfloat-equal", "Warn about testing equality of floating point numbers" },
1203   { "-Wno-float-equal", "" },
1204   { "-Wunknown-pragmas", "Warn about unrecognized pragmas" },
1205   { "-Wno-unknown-pragmas", "" },
1206   { "-Wstrict-prototypes", "Warn about non-prototyped function decls" },
1207   { "-Wno-strict-prototypes", "" },
1208   { "-Wtraditional", "Warn about constructs whose meaning change in ANSI C"},
1209   { "-Wno-traditional", "" },
1210   { "-Wtrigraphs", "Warn when trigraphs are encountered" },
1211   { "-Wno-trigraphs", "" },
1212   { "-Wundef", "" },
1213   { "-Wno-undef", "" },
1214   { "-Wwrite-strings", "Mark strings as 'const char *'"},
1215   { "-Wno-write-strings", "" },
1216   
1217 #define DEFINE_LANG_NAME(NAME) { NULL, NAME },
1218   
1219   /* These are for Objective C.  */
1220   DEFINE_LANG_NAME ("Objective C")
1221   
1222   { "-lang-objc", "" },
1223   { "-gen-decls", "Dump decls to a .decl file" },
1224   { "-fgnu-runtime", "Generate code for GNU runtime environment" },
1225   { "-fno-gnu-runtime", "" },
1226   { "-fnext-runtime", "Generate code for NeXT runtime environment" },
1227   { "-fno-next-runtime", "" },
1228   { "-Wselector", "Warn if a selector has multiple methods" },
1229   { "-Wno-selector", "" },
1230   { "-Wprotocol", "" },
1231   { "-Wno-protocol", "Do not warn if inherited methods are unimplemented"},
1232   { "-print-objc-runtime-info",
1233     "Generate C header of platform specific features" },
1234
1235 #include "options.h"
1236   
1237 };
1238
1239 /* Here is a table, controlled by the tm.h file, listing each -m switch
1240    and which bits in `target_switches' it should set or clear.
1241    If VALUE is positive, it is bits to set.
1242    If VALUE is negative, -VALUE is bits to clear.
1243    (The sign bit is not used so there is no confusion.)  */
1244
1245 struct
1246 {
1247   const char * name;
1248   int    value;
1249   const char * description;
1250 }
1251 target_switches [] = TARGET_SWITCHES;
1252
1253 /* This table is similar, but allows the switch to have a value.  */
1254
1255 #ifdef TARGET_OPTIONS
1256 struct
1257 {
1258   const char *  prefix;
1259   const char ** variable;
1260   const char *  description;
1261 }
1262 target_options [] = TARGET_OPTIONS;
1263 #endif
1264 \f
1265 /* Options controlling warnings */
1266
1267 /* Don't print warning messages.  -w.  */
1268
1269 int inhibit_warnings = 0;
1270
1271 /* Print various extra warnings.  -W.  */
1272
1273 int extra_warnings = 0;
1274
1275 /* Treat warnings as errors.  -Werror.  */
1276
1277 int warnings_are_errors = 0;
1278
1279 /* Nonzero to warn about unused local variables.  */
1280
1281 int warn_unused;
1282
1283 /* Nonzero to warn about code which is never reached.  */
1284
1285 int warn_notreached;
1286
1287 /* Nonzero to warn about variables used before they are initialized.  */
1288
1289 int warn_uninitialized;
1290
1291 /* Nonzero means warn about all declarations which shadow others.   */
1292
1293 int warn_shadow;
1294
1295 /* Warn if a switch on an enum fails to have a case for every enum value.  */
1296
1297 int warn_switch;
1298
1299 /* Nonzero means warn about function definitions that default the return type
1300    or that use a null return and have a return-type other than void.  */
1301
1302 int warn_return_type;
1303
1304 /* Nonzero means warn about pointer casts that increase the required
1305    alignment of the target type (and might therefore lead to a crash
1306    due to a misaligned access).  */
1307
1308 int warn_cast_align;
1309
1310 /* Nonzero means warn about any identifiers that match in the first N
1311    characters.  The value N is in `id_clash_len'.  */
1312
1313 int warn_id_clash;
1314 int id_clash_len;
1315
1316 /* Nonzero means warn about any objects definitions whose size is larger
1317    than N bytes.  Also want about function definitions whose returned
1318    values are larger than N bytes. The value N is in `larger_than_size'.  */
1319  
1320 int warn_larger_than;
1321 HOST_WIDE_INT larger_than_size;
1322
1323 /* Nonzero means warn if inline function is too large.  */
1324
1325 int warn_inline;
1326
1327 /* Warn if a function returns an aggregate,
1328    since there are often incompatible calling conventions for doing this.  */
1329
1330 int warn_aggregate_return;
1331
1332 /* Warn if packed attribute on struct is unnecessary and inefficient.  */
1333
1334 int warn_packed;
1335
1336 /* Warn when gcc pads a structure to an alignment boundary.  */
1337
1338 int warn_padded;
1339
1340 /* Likewise for -W.  */
1341
1342 lang_independent_options W_options[] =
1343 {
1344   {"unused", &warn_unused, 1, "Warn when a variable is unused" },
1345   {"error", &warnings_are_errors, 1, ""},
1346   {"shadow", &warn_shadow, 1, "Warn when one local variable shadows another" },
1347   {"switch", &warn_switch, 1,
1348    "Warn about enumerated switches missing a specific case" },
1349   {"aggregate-return", &warn_aggregate_return, 1,
1350    "Warn about returning structures, unions or arrays" },
1351   {"cast-align", &warn_cast_align, 1,
1352    "Warn about pointer casts which increase alignment" },
1353   {"unreachable-code", &warn_notreached, 1, 
1354    "Warn about code that will never be executed" },
1355   {"uninitialized", &warn_uninitialized, 1,
1356    "Warn about unitialized automatic variables"},
1357   {"inline", &warn_inline, 1,
1358    "Warn when an inlined function cannot be inlined"},
1359   {"packed", &warn_packed, 1,
1360    "Warn when the packed attribute has no effect on struct layout"},
1361   {"padded", &warn_padded, 1,
1362    "Warn when padding is required to align struct members"}
1363 };
1364 \f
1365 /* Output files for assembler code (real compiler output)
1366    and debugging dumps.  */
1367
1368 FILE *asm_out_file;
1369 FILE *aux_info_file;
1370 FILE *rtl_dump_file = NULL;
1371
1372 /* Decode the string P as an integral parameter.
1373    If the string is indeed an integer return its numeric value else
1374    issue an Invalid Option error for the option PNAME and return DEFVAL.
1375    If PNAME is zero just return DEFVAL, do not call error.               */
1376    
1377 int
1378 read_integral_parameter (p, pname, defval)
1379      const char *p;
1380      const char *pname;
1381      const int  defval;
1382 {
1383   const char *endp = p;
1384
1385   while (*endp)
1386     {
1387       if (*endp >= '0' && *endp <= '9')
1388         endp++;
1389       else
1390         break;
1391     }
1392
1393   if (*endp != 0)
1394     {
1395       if (pname != 0)
1396         error ("Invalid option `%s'", pname);
1397       return defval;
1398     }
1399
1400   return atoi (p);
1401 }
1402
1403
1404 /* Time accumulators, to count the total time spent in various passes.  */
1405
1406 int parse_time;
1407 int varconst_time;
1408 int integration_time;
1409 int jump_time;
1410 int cse_time;
1411 int gcse_time;
1412 int loop_time;
1413 int cse2_time;
1414 int branch_prob_time;
1415 int flow_time;
1416 int combine_time;
1417 int regmove_time;
1418 int sched_time;
1419 int local_alloc_time;
1420 int global_alloc_time;
1421 int flow2_time;
1422 int peephole2_time;
1423 int sched2_time;
1424 int dbr_sched_time;
1425 int reorder_blocks_time;
1426 int rename_registers_time;
1427 int shorten_branch_time;
1428 int stack_reg_time;
1429 int final_time;
1430 int symout_time;
1431 int dump_time;
1432 int gc_time;
1433 int all_time;
1434 \f
1435 /* Return time used so far, in microseconds.  */
1436
1437 long
1438 get_run_time ()
1439 {
1440   if (quiet_flag)
1441     return 0;
1442
1443 #ifdef __BEOS__
1444   return 0;
1445 #else /* not BeOS */
1446 #if defined (_WIN32) && !defined (__CYGWIN__)
1447   if (clock() < 0)
1448     return 0;
1449   else
1450     return (clock() * 1000);
1451 #else /* not _WIN32 */
1452 #ifdef _SC_CLK_TCK
1453   {
1454     static int tick;
1455     struct tms tms;
1456     if (tick == 0)
1457       tick = 1000000 / sysconf(_SC_CLK_TCK);
1458     times (&tms);
1459     return (tms.tms_utime + tms.tms_stime) * tick;
1460   }
1461 #else
1462 #ifdef USG
1463   {
1464     struct tms tms;
1465 #   if HAVE_SYSCONF && defined _SC_CLK_TCK
1466 #    define TICKS_PER_SECOND sysconf (_SC_CLK_TCK) /* POSIX 1003.1-1996 */
1467 #   else
1468 #    ifdef CLK_TCK
1469 #     define TICKS_PER_SECOND CLK_TCK /* POSIX 1003.1-1988; obsolescent */
1470 #    else
1471 #     define TICKS_PER_SECOND HZ /* traditional UNIX */
1472 #    endif
1473 #   endif
1474     times (&tms);
1475     return (tms.tms_utime + tms.tms_stime) * (1000000 / TICKS_PER_SECOND);
1476   }
1477 #else
1478 #ifndef VMS
1479   {
1480     struct rusage rusage;
1481     getrusage (0, &rusage);
1482     return (rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec
1483             + rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec);
1484   }
1485 #else /* VMS */
1486   {
1487     struct
1488       {
1489         int proc_user_time;
1490         int proc_system_time;
1491         int child_user_time;
1492         int child_system_time;
1493       } vms_times;
1494     times ((void *) &vms_times);
1495     return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
1496   }
1497 #endif  /* VMS */
1498 #endif  /* USG */
1499 #endif  /* _SC_CLK_TCK */
1500 #endif  /* _WIN32 */
1501 #endif  /* __BEOS__ */
1502 }
1503
1504 #define TIMEVAR(VAR, BODY)    \
1505 do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
1506
1507 void
1508 print_time (str, total)
1509      const char *str;
1510      int total;
1511 {
1512   fprintf (stderr,
1513            "time in %s: %d.%06d (%.0f%%)\n",
1514            str, total / 1000000, total % 1000000,
1515            all_time == 0 ? 0.00 : (double) total / (double) all_time * 100.0);
1516 }
1517
1518 /* This is the default decl_printable_name function.  */
1519
1520 static const char *
1521 decl_name (decl, verbosity)
1522      tree decl;
1523      int verbosity ATTRIBUTE_UNUSED;
1524 {
1525   return IDENTIFIER_POINTER (DECL_NAME (decl));
1526 }
1527 \f
1528 /* Mark P for GC.  Also mark main_input_filename and input_filename.  */
1529 static void
1530 mark_file_stack (p)
1531      void *p;
1532 {
1533   struct file_stack *stack = *(struct file_stack **)p;
1534
1535   /* We're only called for input_file_stack, so we can mark the current
1536      input_filename here as well.  */
1537   ggc_mark_string (main_input_filename);
1538   ggc_mark_string (input_filename);
1539
1540   while (stack)
1541     {
1542       ggc_mark_string (stack->name);
1543       stack = stack->next;
1544     }
1545 }
1546 \f
1547
1548 /* This calls abort and is used to avoid problems when abort if a macro.
1549    It is used when we need to pass the address of abort.  */
1550
1551 void
1552 do_abort ()
1553 {
1554   abort ();
1555 }
1556
1557 /* When `malloc.c' is compiled with `rcheck' defined,
1558    it calls this function to report clobberage.  */
1559
1560 void
1561 botch (s)
1562   const char * s ATTRIBUTE_UNUSED;
1563 {
1564   abort ();
1565 }
1566 \f
1567 /* Return the logarithm of X, base 2, considering X unsigned,
1568    if X is a power of 2.  Otherwise, returns -1.
1569
1570    This should be used via the `exact_log2' macro.  */
1571
1572 int
1573 exact_log2_wide (x)
1574      register unsigned HOST_WIDE_INT x;
1575 {
1576   register int log = 0;
1577   /* Test for 0 or a power of 2.  */
1578   if (x == 0 || x != (x & -x))
1579     return -1;
1580   while ((x >>= 1) != 0)
1581     log++;
1582   return log;
1583 }
1584
1585 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1586    If X is 0, return -1.
1587
1588    This should be used via the floor_log2 macro.  */
1589
1590 int
1591 floor_log2_wide (x)
1592      register unsigned HOST_WIDE_INT x;
1593 {
1594   register int log = -1;
1595   while (x != 0)
1596     log++,
1597     x >>= 1;
1598   return log;
1599 }
1600
1601 static int float_handler_set;
1602 int float_handled;
1603 jmp_buf float_handler;
1604
1605 /* Signals actually come here.  */
1606
1607 static void
1608 float_signal (signo)
1609      /* If this is missing, some compilers complain.  */
1610      int signo ATTRIBUTE_UNUSED;
1611 {
1612   if (float_handled == 0)
1613     abort ();
1614 #if defined (USG) || defined (hpux)
1615   signal (SIGFPE, float_signal);  /* re-enable the signal catcher */
1616 #endif
1617   float_handled = 0;
1618   signal (SIGFPE, float_signal);
1619   longjmp (float_handler, 1);
1620 }
1621
1622 /* Specify where to longjmp to when a floating arithmetic error happens.
1623    If HANDLER is 0, it means don't handle the errors any more.  */
1624
1625 void
1626 set_float_handler (handler)
1627      jmp_buf handler;
1628 {
1629   float_handled = (handler != 0);
1630   if (handler)
1631     bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
1632
1633   if (float_handled && ! float_handler_set)
1634     {
1635       signal (SIGFPE, float_signal);
1636       float_handler_set = 1;
1637     }
1638 }
1639
1640 /* This is a wrapper function for code which might elicit an
1641    arithmetic exception.  That code should be passed in as a function
1642    pointer FN, and one argument DATA.  DATA is usually a struct which
1643    contains the real input and output for function FN.  This function
1644    returns 0 (failure) if longjmp was called (i.e. an exception
1645    occured.)  It returns 1 (success) otherwise. */
1646
1647 int
1648 do_float_handler (fn, data)
1649   void (*fn) PARAMS ((PTR));
1650   PTR data;
1651 {
1652   jmp_buf buf;
1653
1654   if (setjmp (buf))
1655     {
1656       /* We got here via longjmp() caused by an exception in function fn() */
1657       set_float_handler (NULL);
1658       return 0;
1659     }
1660
1661   set_float_handler (buf);
1662   (*fn)(data);
1663   set_float_handler (NULL);
1664   return 1;
1665 }
1666
1667 /* Specify, in HANDLER, where to longjmp to when a floating arithmetic
1668    error happens, pushing the previous specification into OLD_HANDLER.
1669    Return an indication of whether there was a previous handler in effect.  */
1670
1671 int
1672 push_float_handler (handler, old_handler)
1673      jmp_buf handler, old_handler;
1674 {
1675   int was_handled = float_handled;
1676
1677   float_handled = 1;
1678   if (was_handled)
1679     memcpy ((char *) old_handler, (char *) float_handler,
1680            sizeof (float_handler));
1681
1682   memcpy ((char *) float_handler, (char *) handler, sizeof (float_handler));
1683   return was_handled;
1684 }
1685
1686 /* Restore the previous specification of whether and where to longjmp to
1687    when a floating arithmetic error happens.  */
1688
1689 void
1690 pop_float_handler (handled, handler)
1691      int handled;
1692      jmp_buf handler;
1693 {
1694   float_handled = handled;
1695   if (handled)
1696     bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
1697 }
1698
1699 /* Handler for SIGPIPE.  */
1700
1701 static void
1702 pipe_closed (signo)
1703      /* If this is missing, some compilers complain.  */
1704      int signo ATTRIBUTE_UNUSED;
1705 {
1706   fatal ("output pipe has been closed");
1707 }
1708
1709 /* Strip off a legitimate source ending from the input string NAME of
1710    length LEN.  Rather than having to know the names used by all of
1711    our front ends, we strip off an ending of a period followed by
1712    up to five characters.  (Java uses ".class".) */
1713
1714 void
1715 strip_off_ending (name, len)
1716      char *name;
1717      int len;
1718 {
1719   int i;
1720   for (i = 2;  i < 6 && len > i;  i++)
1721     {
1722       if (name[len - i] == '.')
1723         {
1724           name[len - i] = '\0';
1725           break;
1726         }
1727     }
1728 }
1729
1730 /* Output a quoted string.  */
1731
1732 void
1733 output_quoted_string (asm_file, string)
1734      FILE *asm_file;
1735      const char *string;
1736 {
1737 #ifdef OUTPUT_QUOTED_STRING
1738   OUTPUT_QUOTED_STRING (asm_file, string);
1739 #else
1740   char c;
1741
1742   putc ('\"', asm_file);
1743   while ((c = *string++) != 0)
1744     {
1745       if (c == '\"' || c == '\\')
1746         putc ('\\', asm_file);
1747       putc (c, asm_file);
1748     }
1749   putc ('\"', asm_file);
1750 #endif
1751 }
1752
1753 /* Output a file name in the form wanted by System V.  */
1754
1755 void
1756 output_file_directive (asm_file, input_name)
1757      FILE *asm_file;
1758      const char *input_name;
1759 {
1760   int len = strlen (input_name);
1761   const char *na = input_name + len;
1762
1763   /* NA gets INPUT_NAME sans directory names.  */
1764   while (na > input_name)
1765     {
1766       if (na[-1] == '/')
1767         break;
1768 #ifdef DIR_SEPARATOR
1769       if (na[-1] == DIR_SEPARATOR)
1770         break;
1771 #endif
1772       na--;
1773     }
1774
1775 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
1776   ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
1777 #else
1778 #ifdef ASM_OUTPUT_SOURCE_FILENAME
1779   ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
1780 #else
1781   fprintf (asm_file, "\t.file\t");
1782   output_quoted_string (asm_file, na);
1783   fputc ('\n', asm_file);
1784 #endif
1785 #endif
1786 }
1787 \f
1788 #ifdef ASM_IDENTIFY_LANGUAGE
1789 /* Routine to build language identifier for object file.  */
1790 static void
1791 output_lang_identify (asm_out_file)
1792      FILE *asm_out_file;
1793 {
1794   int len = strlen (lang_identify ()) + sizeof ("__gnu_compiled_") + 1;
1795   char *s = (char *) alloca (len);
1796   sprintf (s, "__gnu_compiled_%s", lang_identify ());
1797   ASM_OUTPUT_LABEL (asm_out_file, s);
1798 }
1799 #endif
1800
1801 /* Routine to open a dump file.  Return true if the dump file is enabled.  */
1802
1803 static int
1804 open_dump_file (index, decl)
1805      enum dump_file_index index;
1806      tree decl;
1807 {
1808   char *dump_name;
1809   const char *open_arg;
1810   char seq[16];
1811
1812   if (! dump_file[index].enabled)
1813     return 0;
1814
1815   TIMEVAR
1816     (dump_time,
1817       {
1818         if (rtl_dump_file != NULL)
1819           fclose (rtl_dump_file);
1820   
1821         sprintf (seq, ".%02d.", index);
1822
1823         if (! dump_file[index].initialized)
1824           {
1825             /* If we've not initialized the files, do so now.  */
1826             if (graph_dump_format != no_graph
1827                 && dump_file[index].graph_dump_p)
1828               {
1829                 dump_name = concat (seq, dump_file[index].extension, NULL);
1830                 clean_graph_dump_file (dump_base_name, dump_name);
1831                 free (dump_name);
1832               }
1833             dump_file[index].initialized = 1;
1834             open_arg = "w";
1835           }
1836         else
1837           open_arg = "a";
1838
1839         dump_name = concat (dump_base_name, seq,
1840                             dump_file[index].extension, NULL);
1841
1842         rtl_dump_file = fopen (dump_name, open_arg);
1843         if (rtl_dump_file == NULL)
1844           pfatal_with_name (dump_name);
1845        
1846         free (dump_name);
1847
1848         if (decl)
1849           fprintf (rtl_dump_file, "\n;; Function %s\n\n",
1850                    decl_printable_name (decl, 2));
1851       });
1852   
1853   return 1;
1854 }
1855
1856 /* Routine to close a dump file.  */
1857
1858 static void
1859 close_dump_file (index, func, insns)
1860      enum dump_file_index index;
1861      void (*func) PARAMS ((FILE *, rtx));
1862      rtx    insns;
1863 {
1864   if (! rtl_dump_file)
1865     return;
1866
1867   TIMEVAR
1868     (dump_time,
1869       {
1870         if (insns
1871             && graph_dump_format != no_graph
1872             && dump_file[index].graph_dump_p)
1873           {
1874             char seq[16];
1875             char *suffix;
1876
1877             sprintf (seq, ".%02d.", index);
1878             suffix = concat (seq, dump_file[index].extension, NULL);
1879             print_rtl_graph_with_bb (dump_base_name, suffix, insns);
1880             free (suffix);
1881           }
1882
1883        if (func && insns)
1884          func (rtl_dump_file, insns);
1885        
1886        fflush (rtl_dump_file);
1887        fclose (rtl_dump_file);
1888        
1889        rtl_dump_file = NULL;
1890      });
1891 }
1892
1893 /* Do any final processing required for the declarations in VEC, of
1894    which there are LEN.  We write out inline functions and variables
1895    that have been deferred until this point, but which are required.
1896    Returns non-zero if anything was put out.  */ 
1897 int
1898 wrapup_global_declarations (vec, len)
1899      tree *vec;
1900      int len;
1901 {
1902   tree decl;
1903   int i;
1904   int reconsider;
1905   int output_something = 0;
1906
1907   for (i = 0; i < len; i++)
1908     {
1909       decl = vec[i];
1910       
1911       /* We're not deferring this any longer.  */
1912       DECL_DEFER_OUTPUT (decl) = 0;
1913       
1914       if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0
1915           && incomplete_decl_finalize_hook != 0)
1916         (*incomplete_decl_finalize_hook) (decl);
1917     }
1918
1919   /* Now emit any global variables or functions that we have been
1920      putting off.  We need to loop in case one of the things emitted
1921      here references another one which comes earlier in the list.  */
1922   do
1923     {
1924       reconsider = 0;
1925       for (i = 0; i < len; i++)
1926         {
1927           decl = vec[i];
1928
1929           if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
1930             continue;
1931
1932           /* Don't write out static consts, unless we still need them.
1933
1934              We also keep static consts if not optimizing (for debugging),
1935              unless the user specified -fno-keep-static-consts.
1936              ??? They might be better written into the debug information.
1937              This is possible when using DWARF.
1938
1939              A language processor that wants static constants to be always
1940              written out (even if it is not used) is responsible for
1941              calling rest_of_decl_compilation itself.  E.g. the C front-end
1942              calls rest_of_decl_compilation from finish_decl.
1943              One motivation for this is that is conventional in some
1944              environments to write things like:
1945              static const char rcsid[] = "... version string ...";
1946              intending to force the string to be in the executable.
1947
1948              A language processor that would prefer to have unneeded
1949              static constants "optimized away" would just defer writing
1950              them out until here.  E.g. C++ does this, because static
1951              constants are often defined in header files.
1952
1953              ??? A tempting alternative (for both C and C++) would be
1954              to force a constant to be written if and only if it is
1955              defined in a main file, as opposed to an include file.  */
1956
1957           if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
1958               && (! TREE_READONLY (decl)
1959                   || TREE_PUBLIC (decl)
1960                   || (!optimize && flag_keep_static_consts)
1961                   || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1962             {
1963               reconsider = 1;
1964               rest_of_decl_compilation (decl, NULL_PTR, 1, 1);
1965             }
1966
1967           if (TREE_CODE (decl) == FUNCTION_DECL
1968               && DECL_INITIAL (decl) != 0
1969               && DECL_SAVED_INSNS (decl) != 0
1970               && (flag_keep_inline_functions
1971                   || (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
1972                   || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1973             {
1974               reconsider = 1;
1975               temporary_allocation ();
1976               output_inline_function (decl);
1977               permanent_allocation (1);
1978             }
1979         }
1980
1981       if (reconsider)
1982         output_something = 1;
1983     }
1984   while (reconsider);
1985
1986   return output_something;
1987 }
1988
1989 /* Issue appropriate warnings for the global declarations in VEC (of
1990    which there are LEN).  Output debugging information for them.  */
1991 void
1992 check_global_declarations (vec, len)
1993      tree *vec;
1994      int len;
1995 {
1996   tree decl;
1997   int i;
1998
1999   for (i = 0; i < len; i++)
2000     {
2001       decl = vec[i];
2002
2003       if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
2004           && ! TREE_ASM_WRITTEN (decl))
2005         /* Cancel the RTL for this decl so that, if debugging info
2006            output for global variables is still to come,
2007            this one will be omitted.  */
2008         DECL_RTL (decl) = NULL;
2009
2010       /* Warn about any function
2011          declared static but not defined.
2012          We don't warn about variables,
2013          because many programs have static variables
2014          that exist only to get some text into the object file.  */
2015       if (TREE_CODE (decl) == FUNCTION_DECL
2016           && (warn_unused
2017               || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2018           && DECL_INITIAL (decl) == 0
2019           && DECL_EXTERNAL (decl)
2020           && ! DECL_ARTIFICIAL (decl)
2021           && ! TREE_PUBLIC (decl))
2022         {
2023           if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2024             pedwarn_with_decl (decl,
2025                                "`%s' used but never defined");
2026           else
2027             warning_with_decl (decl,
2028                                "`%s' declared `static' but never defined");
2029           /* This symbol is effectively an "extern" declaration now.  */
2030           TREE_PUBLIC (decl) = 1;
2031           assemble_external (decl);
2032         }
2033
2034       /* Warn about static fns or vars defined but not used,
2035          but not about inline functions or static consts
2036          since defining those in header files is normal practice.  */
2037       if (warn_unused
2038           && ((TREE_CODE (decl) == FUNCTION_DECL && ! DECL_INLINE (decl))
2039               || (TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
2040           && ! DECL_IN_SYSTEM_HEADER (decl)
2041           && ! DECL_EXTERNAL (decl)
2042           && ! TREE_PUBLIC (decl)
2043           && ! TREE_USED (decl)
2044           && (TREE_CODE (decl) == FUNCTION_DECL || ! DECL_REGISTER (decl))
2045           /* The TREE_USED bit for file-scope decls
2046              is kept in the identifier, to handle multiple
2047              external decls in different scopes.  */
2048           && ! TREE_USED (DECL_NAME (decl)))
2049         warning_with_decl (decl, "`%s' defined but not used");
2050
2051 #ifdef SDB_DEBUGGING_INFO
2052       /* The COFF linker can move initialized global vars to the end.
2053          And that can screw up the symbol ordering.
2054          By putting the symbols in that order to begin with,
2055          we avoid a problem.  mcsun!unido!fauern!tumuc!pes@uunet.uu.net.  */
2056       if (write_symbols == SDB_DEBUG && TREE_CODE (decl) == VAR_DECL
2057           && TREE_PUBLIC (decl) && DECL_INITIAL (decl)
2058           && ! DECL_EXTERNAL (decl)
2059           && DECL_RTL (decl) != 0)
2060         TIMEVAR (symout_time, sdbout_symbol (decl, 0));
2061
2062       /* Output COFF information for non-global
2063          file-scope initialized variables.  */
2064       if (write_symbols == SDB_DEBUG
2065           && TREE_CODE (decl) == VAR_DECL
2066           && DECL_INITIAL (decl)
2067           && ! DECL_EXTERNAL (decl)
2068           && DECL_RTL (decl) != 0
2069           && GET_CODE (DECL_RTL (decl)) == MEM)
2070         TIMEVAR (symout_time, sdbout_toplevel_data (decl));
2071 #endif /* SDB_DEBUGGING_INFO */
2072 #ifdef DWARF_DEBUGGING_INFO
2073       /* Output DWARF information for file-scope tentative data object
2074          declarations, file-scope (extern) function declarations (which
2075          had no corresponding body) and file-scope tagged type declarations
2076          and definitions which have not yet been forced out.  */
2077
2078       if (write_symbols == DWARF_DEBUG
2079           && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)))
2080         TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 1));
2081 #endif
2082 #ifdef DWARF2_DEBUGGING_INFO
2083       /* Output DWARF2 information for file-scope tentative data object
2084          declarations, file-scope (extern) function declarations (which
2085          had no corresponding body) and file-scope tagged type declarations
2086          and definitions which have not yet been forced out.  */
2087
2088       if (write_symbols == DWARF2_DEBUG
2089           && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)))
2090         TIMEVAR (symout_time, dwarf2out_decl (decl));
2091 #endif
2092     }
2093 }
2094
2095 /* Save the current INPUT_FILENAME and LINENO on the top entry in the
2096    INPUT_FILE_STACK.  Push a new entry for FILE and LINE, and set the
2097    INPUT_FILENAME and LINENO accordingly.  */
2098
2099 void
2100 push_srcloc (file, line)
2101      char *file;
2102      int line;
2103 {
2104   struct file_stack *fs;
2105
2106   if (input_file_stack)
2107     {
2108       input_file_stack->name = input_filename;
2109       input_file_stack->line = lineno;
2110     }
2111
2112   fs = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2113   fs->name = input_filename = file;
2114   fs->line = lineno = line;
2115   fs->indent_level = 0;
2116   fs->next = input_file_stack;
2117   input_file_stack = fs;
2118   input_file_stack_tick++;
2119 }
2120
2121 /* Pop the top entry off the stack of presently open source files.
2122    Restore the INPUT_FILENAME and LINENO from the new topmost entry on
2123    the stack.  */
2124
2125 void
2126 pop_srcloc ()
2127 {
2128   struct file_stack *fs;
2129   
2130   fs = input_file_stack;
2131   input_file_stack = fs->next;
2132   free (fs);
2133   input_file_stack_tick++;
2134   /* The initial souce file is never popped.  */
2135   if (!input_file_stack)
2136     abort ();
2137   input_filename = input_file_stack->name;
2138   lineno = input_file_stack->line;
2139 }
2140
2141 /* Compile an entire file of output from cpp, named NAME.
2142    Write a file of assembly output and various debugging dumps.  */
2143
2144 static void
2145 compile_file (name)
2146      char *name;
2147 {
2148   tree globals;
2149   int start_time;
2150
2151   int name_specified = name != 0;
2152
2153   if (dump_base_name == 0)
2154     dump_base_name = name ? name : "gccdump";
2155
2156   parse_time = 0;
2157   varconst_time = 0;
2158   integration_time = 0;
2159   jump_time = 0;
2160   cse_time = 0;
2161   gcse_time = 0;
2162   loop_time = 0;
2163   cse2_time = 0;
2164   branch_prob_time = 0;
2165   flow_time = 0;
2166   combine_time = 0;
2167   regmove_time = 0;
2168   sched_time = 0;
2169   local_alloc_time = 0;
2170   global_alloc_time = 0;
2171   flow2_time = 0;
2172   peephole2_time = 0;
2173   sched2_time = 0;
2174   dbr_sched_time = 0;
2175   reorder_blocks_time = 0;
2176   rename_registers_time = 0;
2177   shorten_branch_time = 0;
2178   stack_reg_time = 0;
2179   final_time = 0;
2180   symout_time = 0;
2181   dump_time = 0;
2182
2183   /* Initialize data in various passes.  */
2184
2185   init_obstacks ();
2186   init_tree_codes ();
2187   name = init_parse (name);
2188   init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
2189                   || debug_info_level == DINFO_LEVEL_VERBOSE
2190                   || flag_test_coverage
2191                   || warn_notreached);
2192   init_regs ();
2193   init_decl_processing ();
2194   init_optabs ();
2195   init_stmt ();
2196   init_eh ();
2197   init_loop ();
2198   init_reload ();
2199   init_alias_once ();
2200   init_function_once ();
2201   init_stor_layout_once ();
2202   init_varasm_once ();
2203
2204   /* The following initialization functions need to generate rtl, so
2205      provide a dummy function context for them.  */
2206   init_dummy_function_start ();
2207   init_expmed ();
2208   init_expr_once ();
2209   if (flag_caller_saves)
2210     init_caller_save ();
2211   expand_dummy_function_end ();
2212
2213   /* If auxiliary info generation is desired, open the output file.
2214      This goes in the same directory as the source file--unlike
2215      all the other output files.  */
2216   if (flag_gen_aux_info)
2217     {
2218       aux_info_file = fopen (aux_info_file_name, "w");
2219       if (aux_info_file == 0)
2220         pfatal_with_name (aux_info_file_name);
2221     }
2222
2223   /* Open assembler code output file.  */
2224
2225   if (flag_syntax_only)
2226     asm_out_file = NULL;
2227   else
2228     {
2229       if (! name_specified && asm_file_name == 0)
2230         asm_out_file = stdout;
2231       else
2232         {
2233           if (asm_file_name == 0)
2234             {
2235               int len = strlen (dump_base_name);
2236               char *dumpname = (char *) xmalloc (len + 6);
2237               memcpy (dumpname, dump_base_name, len + 1);
2238               strip_off_ending (dumpname, len);
2239               strcat (dumpname, ".s");
2240               asm_file_name = dumpname;
2241             }
2242           if (!strcmp (asm_file_name, "-"))
2243             asm_out_file = stdout;
2244           else
2245             asm_out_file = fopen (asm_file_name, "w");
2246           if (asm_out_file == 0)
2247             pfatal_with_name (asm_file_name);
2248         }
2249
2250 #ifdef IO_BUFFER_SIZE
2251       setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
2252                _IOFBF, IO_BUFFER_SIZE);
2253 #endif
2254     }
2255
2256   if (ggc_p)
2257     name = ggc_alloc_string (name, strlen (name));
2258   input_filename = name;
2259
2260   /* Put an entry on the input file stack for the main input file.  */
2261   push_srcloc (input_filename, 0);
2262
2263   /* Perform language-specific initialization.
2264      This may set main_input_filename.  */
2265   lang_init ();
2266
2267   /* If the input doesn't start with a #line, use the input name
2268      as the official input file name.  */
2269   if (main_input_filename == 0)
2270     main_input_filename = name;
2271
2272   if (flag_syntax_only)
2273     {
2274       write_symbols = NO_DEBUG;
2275       profile_flag = 0;
2276       profile_block_flag = 0;
2277     }
2278   else
2279     {
2280       ASM_FILE_START (asm_out_file);
2281
2282 #ifdef ASM_COMMENT_START
2283       if (flag_verbose_asm)
2284         {
2285           /* Print the list of options in effect.  */
2286           print_version (asm_out_file, ASM_COMMENT_START);
2287           print_switch_values (asm_out_file, 0, MAX_LINE,
2288                                ASM_COMMENT_START, " ", "\n");
2289           /* Add a blank line here so it appears in assembler output but not
2290              screen output.  */
2291           fprintf (asm_out_file, "\n");
2292         }
2293 #endif
2294
2295       /* Output something to inform GDB that this compilation was by GCC.  */
2296 #ifndef ASM_IDENTIFY_GCC
2297       fprintf (asm_out_file, "gcc2_compiled.:\n");
2298 #else
2299       ASM_IDENTIFY_GCC (asm_out_file);
2300 #endif
2301
2302   /* Output something to identify which front-end produced this file.  */
2303 #ifdef ASM_IDENTIFY_LANGUAGE
2304       ASM_IDENTIFY_LANGUAGE (asm_out_file);
2305 #endif
2306     } /* ! flag_syntax_only */
2307
2308 #ifndef ASM_OUTPUT_SECTION_NAME
2309   if (flag_function_sections)
2310     {
2311       warning ("-ffunction-sections not supported for this target.");
2312       flag_function_sections = 0;
2313     }
2314   if (flag_data_sections)
2315     {
2316       warning ("-fdata-sections not supported for this target.");
2317       flag_data_sections = 0;
2318     }
2319 #endif
2320
2321   if (flag_function_sections
2322       && (profile_flag || profile_block_flag))
2323     {
2324       warning ("-ffunction-sections disabled; it makes profiling impossible.");
2325       flag_function_sections = 0;
2326     }
2327
2328 #ifndef OBJECT_FORMAT_ELF
2329   if (flag_function_sections && write_symbols != NO_DEBUG)
2330     warning ("-ffunction-sections may affect debugging on some targets.");
2331 #endif
2332
2333   /* ??? Note: There used to be a conditional here
2334       to call assemble_zeros without fail if DBX_DEBUGGING_INFO is defined.
2335       This was to guarantee separation between gcc_compiled. and
2336       the first function, for the sake of dbx on Suns.
2337       However, having the extra zero here confused the Emacs
2338       code for unexec, and might confuse other programs too.
2339       Therefore, I took out that change.
2340       In future versions we should find another way to solve
2341       that dbx problem.  -- rms, 23 May 93.  */
2342       
2343   /* Don't let the first function fall at the same address
2344      as gcc_compiled., if profiling.  */
2345   if (profile_flag || profile_block_flag)
2346     {
2347       /* It's best if we can write a nop here since some
2348          assemblers don't tolerate zeros in the text section.  */
2349       output_asm_insn (get_insn_template (CODE_FOR_nop, NULL), NULL_PTR);
2350     }
2351
2352   /* If dbx symbol table desired, initialize writing it
2353      and output the predefined types.  */
2354 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2355   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2356     TIMEVAR (symout_time, dbxout_init (asm_out_file, main_input_filename,
2357                                        getdecls ()));
2358 #endif
2359 #ifdef SDB_DEBUGGING_INFO
2360   if (write_symbols == SDB_DEBUG)
2361     TIMEVAR (symout_time, sdbout_init (asm_out_file, main_input_filename,
2362                                        getdecls ()));
2363 #endif
2364 #ifdef DWARF_DEBUGGING_INFO
2365   if (write_symbols == DWARF_DEBUG)
2366     TIMEVAR (symout_time, dwarfout_init (asm_out_file, main_input_filename));
2367 #endif
2368 #ifdef DWARF2_UNWIND_INFO
2369   if (dwarf2out_do_frame ())
2370     dwarf2out_frame_init ();
2371 #endif
2372 #ifdef DWARF2_DEBUGGING_INFO
2373   if (write_symbols == DWARF2_DEBUG)
2374     TIMEVAR (symout_time, dwarf2out_init (asm_out_file, main_input_filename));
2375 #endif
2376
2377   /* Initialize yet another pass.  */
2378
2379   init_final (main_input_filename);
2380   init_branch_prob (dump_base_name);
2381
2382   start_time = get_run_time ();
2383
2384   /* Call the parser, which parses the entire file
2385      (calling rest_of_compilation for each function).  */
2386
2387   if (yyparse () != 0)
2388     {
2389       if (errorcount == 0)
2390         fnotice (stderr, "Errors detected in input file (your bison.simple is out of date)\n");
2391
2392       /* In case there were missing closebraces,
2393          get us back to the global binding level.  */
2394       while (! global_bindings_p ())
2395         poplevel (0, 0, 0);
2396     }
2397
2398   /* Compilation is now finished except for writing
2399      what's left of the symbol table output.  */
2400
2401   parse_time += get_run_time () - start_time;
2402
2403   parse_time -= integration_time;
2404   parse_time -= varconst_time;
2405
2406   if (flag_syntax_only)
2407     goto finish_syntax;
2408
2409   globals = getdecls ();
2410
2411   /* Really define vars that have had only a tentative definition.
2412      Really output inline functions that must actually be callable
2413      and have not been output so far.  */
2414
2415   {
2416     int len = list_length (globals);
2417     tree *vec = (tree *) xmalloc (sizeof (tree) * len);
2418     int i;
2419     tree decl;
2420
2421     /* Process the decls in reverse order--earliest first.
2422        Put them into VEC from back to front, then take out from front.  */
2423
2424     for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
2425       vec[len - i - 1] = decl;
2426
2427     wrapup_global_declarations (vec, len);
2428
2429     /* This must occur after the loop to output deferred functions.  Else
2430        the profiler initializer would not be emitted if all the functions
2431        in this compilation unit were deferred.
2432
2433        output_func_start_profiler can not cause any additional functions or
2434        data to need to be output, so it need not be in the deferred function
2435        loop above.  */
2436     output_func_start_profiler ();
2437
2438     /* Now that all possible functions have been output, we can dump
2439        the exception table.  */
2440
2441     output_exception_table ();
2442
2443     check_global_declarations (vec, len);
2444
2445     /* Clean up.  */
2446     free (vec);
2447   }
2448
2449   /* Write out any pending weak symbol declarations.  */
2450
2451   weak_finish ();
2452
2453   /* Do dbx symbols */
2454 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2455   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2456     TIMEVAR (symout_time,
2457              {
2458                dbxout_finish (asm_out_file, main_input_filename);
2459              });
2460 #endif
2461
2462 #ifdef DWARF_DEBUGGING_INFO
2463   if (write_symbols == DWARF_DEBUG)
2464     TIMEVAR (symout_time,
2465              {
2466                dwarfout_finish ();
2467              });
2468 #endif
2469
2470 #ifdef DWARF2_UNWIND_INFO
2471   if (dwarf2out_do_frame ())
2472     dwarf2out_frame_finish ();
2473 #endif
2474
2475 #ifdef DWARF2_DEBUGGING_INFO
2476   if (write_symbols == DWARF2_DEBUG)
2477     TIMEVAR (symout_time,
2478              {
2479                dwarf2out_finish ();
2480              });
2481 #endif
2482
2483   /* Output some stuff at end of file if nec.  */
2484
2485   end_final (dump_base_name);
2486    
2487   if (flag_test_coverage || flag_branch_probabilities)
2488     {
2489       open_dump_file (DFI_bp, NULL);
2490    
2491       TIMEVAR (dump_time, end_branch_prob (rtl_dump_file));
2492    
2493       close_dump_file (DFI_bp, NULL, NULL_RTX);
2494     }
2495    
2496 #ifdef ASM_FILE_END
2497   ASM_FILE_END (asm_out_file);
2498 #endif
2499
2500   /* Language-specific end of compilation actions.  */
2501  finish_syntax:
2502   lang_finish ();
2503
2504   /* Close the dump files.  */
2505
2506   if (flag_gen_aux_info)
2507     {
2508       fclose (aux_info_file);
2509       if (errorcount)
2510         unlink (aux_info_file_name);
2511     }
2512
2513   if (optimize > 0 && open_dump_file (DFI_combine, NULL))
2514     {
2515       TIMEVAR (dump_time, dump_combine_total_stats (rtl_dump_file));
2516       close_dump_file (DFI_combine, NULL, NULL_RTX);
2517     }
2518
2519   /* Close non-debugging input and output files.  Take special care to note
2520      whether fclose returns an error, since the pages might still be on the
2521      buffer chain while the file is open.  */
2522
2523   finish_parse ();
2524
2525   if (! flag_syntax_only
2526       && (ferror (asm_out_file) != 0 || fclose (asm_out_file) != 0))
2527     fatal_io_error (asm_file_name);
2528
2529   /* Do whatever is necessary to finish printing the graphs.  */
2530   if (graph_dump_format != no_graph)
2531     {
2532       int i;
2533
2534       for (i = 0; i < DFI_MAX; ++i)
2535         if (dump_file[i].initialized && dump_file[i].graph_dump_p)
2536           {
2537             char seq[16];
2538             char *suffix;
2539
2540             sprintf (seq, ".%02d.", i);
2541             suffix = concat (seq, dump_file[i].extension, NULL);
2542             finish_graph_dump_file (dump_base_name, suffix);
2543             free (suffix);
2544           }
2545     }
2546
2547   /* Free up memory for the benefit of leak detectors.  */
2548   free_reg_info ();
2549
2550   /* Print the times.  */
2551
2552   if (! quiet_flag)
2553     {
2554       all_time = get_run_time ();
2555
2556       fprintf (stderr,"\n");
2557
2558       print_time ("parse", parse_time);
2559       print_time ("integration", integration_time);
2560       print_time ("jump", jump_time);
2561       print_time ("cse", cse_time);
2562       print_time ("gcse", gcse_time);
2563       print_time ("loop", loop_time);
2564       print_time ("cse2", cse2_time);
2565       print_time ("branch-prob", branch_prob_time);
2566       print_time ("flow", flow_time);
2567       print_time ("combine", combine_time);
2568       print_time ("regmove", regmove_time);
2569 #ifdef INSN_SCHEDULING
2570       print_time ("sched", sched_time);
2571 #endif
2572       print_time ("local-alloc", local_alloc_time);
2573       print_time ("global-alloc", global_alloc_time);
2574       print_time ("flow2", flow2_time);
2575 #ifdef HAVE_peephole2
2576       print_time ("peephole2", peephole2_time);
2577 #endif
2578 #ifdef INSN_SCHEDULING
2579       print_time ("sched2", sched2_time);
2580 #endif
2581 #ifdef DELAY_SLOTS
2582       print_time ("dbranch", dbr_sched_time);
2583 #endif
2584       print_time ("bbro", reorder_blocks_time);
2585       print_time ("rnreg", rename_registers_time);
2586       print_time ("shorten-branch", shorten_branch_time);
2587 #ifdef STACK_REGS
2588       print_time ("stack-reg", stack_reg_time);
2589 #endif
2590       print_time ("final", final_time);
2591       print_time ("varconst", varconst_time);
2592       print_time ("symout", symout_time);
2593       print_time ("dump", dump_time);
2594       if (ggc_p)
2595         print_time ("gc", gc_time);
2596     }
2597 }
2598 \f
2599 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
2600    and TYPE_DECL nodes.
2601
2602    This does nothing for local (non-static) variables, unless the
2603    variable is a register variable with an ASMSPEC.  In that case, or
2604    if the variable is not an automatice, it sets up the RTL and
2605    outputs any assembler code (label definition, storage allocation
2606    and initialization).
2607
2608    DECL is the declaration.  If ASMSPEC is nonzero, it specifies
2609    the assembler symbol name to be used.  TOP_LEVEL is nonzero
2610    if this declaration is not within a function.  */
2611
2612 void
2613 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
2614      tree decl;
2615      const char *asmspec;
2616      int top_level;
2617      int at_end;
2618 {
2619   /* Declarations of variables, and of functions defined elsewhere.  */
2620
2621 /* The most obvious approach, to put an #ifndef around where
2622    this macro is used, doesn't work since it's inside a macro call.  */
2623 #ifndef ASM_FINISH_DECLARE_OBJECT
2624 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP, END)
2625 #endif
2626
2627   /* Forward declarations for nested functions are not "external",
2628      but we need to treat them as if they were.  */
2629   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
2630       || TREE_CODE (decl) == FUNCTION_DECL)
2631     TIMEVAR (varconst_time,
2632              {
2633                make_decl_rtl (decl, asmspec, top_level);
2634                /* Initialized extern variable exists to be replaced
2635                   with its value, or represents something that will be
2636                   output in another file.  */
2637                if (! (TREE_CODE (decl) == VAR_DECL
2638                       && DECL_EXTERNAL (decl) && TREE_READONLY (decl)
2639                       && DECL_INITIAL (decl) != 0
2640                       && DECL_INITIAL (decl) != error_mark_node))
2641                  /* Don't output anything
2642                     when a tentative file-scope definition is seen.
2643                     But at end of compilation, do output code for them.  */
2644                  if (! (! at_end && top_level
2645                         && (DECL_INITIAL (decl) == 0
2646                             || DECL_INITIAL (decl) == error_mark_node)))
2647                    assemble_variable (decl, top_level, at_end, 0);
2648                if (decl == last_assemble_variable_decl)
2649                  {
2650                    ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
2651                                               top_level, at_end);
2652                  }
2653              });
2654   else if (DECL_REGISTER (decl) && asmspec != 0)
2655     {
2656       if (decode_reg_name (asmspec) >= 0)
2657         {
2658           DECL_RTL (decl) = 0;
2659           make_decl_rtl (decl, asmspec, top_level);
2660         }
2661       else
2662         error ("invalid register name `%s' for register variable", asmspec);
2663     }
2664 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2665   else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2666            && TREE_CODE (decl) == TYPE_DECL)
2667     TIMEVAR (symout_time, dbxout_symbol (decl, 0));
2668 #endif
2669 #ifdef SDB_DEBUGGING_INFO
2670   else if (write_symbols == SDB_DEBUG && top_level
2671            && TREE_CODE (decl) == TYPE_DECL)
2672     TIMEVAR (symout_time, sdbout_symbol (decl, 0));
2673 #endif
2674 }
2675
2676 /* Called after finishing a record, union or enumeral type.  */
2677
2678 void
2679 rest_of_type_compilation (type, toplev)
2680 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO) || defined (SDB_DEBUGGING_INFO)
2681      tree type;
2682      int toplev;
2683 #else
2684      tree type ATTRIBUTE_UNUSED;
2685      int toplev ATTRIBUTE_UNUSED;
2686 #endif
2687 {
2688 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2689   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2690     TIMEVAR (symout_time, dbxout_symbol (TYPE_STUB_DECL (type), !toplev));
2691 #endif
2692 #ifdef SDB_DEBUGGING_INFO
2693   if (write_symbols == SDB_DEBUG)
2694     TIMEVAR (symout_time, sdbout_symbol (TYPE_STUB_DECL (type), !toplev));
2695 #endif
2696 }
2697
2698 /* DECL is an inline function, whose body is present, but which is not
2699    being output at this point.  (We're putting that off until we need
2700    to do it.)  If there are any actions that need to take place,
2701    including the emission of debugging information for the function,
2702    this is where they should go.  This function may be called by
2703    language-dependent code for front-ends that do not even generate
2704    RTL for functions that don't need to be put out.  */
2705
2706 void
2707 note_deferral_of_defined_inline_function (decl)
2708      tree decl ATTRIBUTE_UNUSED;
2709 {
2710 #ifdef DWARF_DEBUGGING_INFO
2711   /* Generate the DWARF info for the "abstract" instance of a function
2712      which we may later generate inlined and/or out-of-line instances
2713      of.  */
2714   if (write_symbols == DWARF_DEBUG)
2715     {
2716       /* The front-end may not have set CURRENT_FUNCTION_DECL, but the
2717          DWARF code expects it to be set in this case.  Intuitively,
2718          DECL is the function we just finished defining, so setting
2719          CURRENT_FUNCTION_DECL is sensible.  */
2720       tree saved_cfd = current_function_decl;
2721       current_function_decl = decl;
2722
2723       /* Let the DWARF code do its work.  */
2724       set_decl_abstract_flags (decl, 1);
2725       dwarfout_file_scope_decl (decl, 0);
2726       set_decl_abstract_flags (decl, 0);
2727
2728       /* Reset CURRENT_FUNCTION_DECL.  */
2729       current_function_decl = saved_cfd;
2730     }
2731 #endif
2732 }
2733
2734 /* This is called from finish_function (within yyparse)
2735    after each top-level definition is parsed.
2736    It is supposed to compile that function or variable
2737    and output the assembler code for it.
2738    After we return, the tree storage is freed.  */
2739
2740 void
2741 rest_of_compilation (decl)
2742      tree decl;
2743 {
2744   register rtx insns;
2745   int start_time = get_run_time ();
2746   int tem;
2747   int failure = 0;
2748   int rebuild_label_notes_after_reload;
2749
2750   /* When processing delayed functions, prepare_function_start() won't
2751      have been run to re-initialize it.  */
2752   cse_not_expected = ! optimize;
2753
2754   /* First, make sure that NOTE_BLOCK is set correctly for each
2755      NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note.  */
2756   if (!cfun->x_whole_function_mode_p)
2757     identify_blocks ();
2758
2759   /* Then remove any notes we don't need.  That will make iterating
2760      over the instruction sequence faster, and allow the garbage
2761      collector to reclaim the memory used by the notes.  */
2762   remove_unncessary_notes ();
2763
2764   /* In function-at-a-time mode, we do not attempt to keep the BLOCK
2765      tree in sensible shape.  So, we just recalculate it here.  */
2766   if (cfun->x_whole_function_mode_p)
2767     reorder_blocks ();
2768
2769   /* If we are reconsidering an inline function
2770      at the end of compilation, skip the stuff for making it inline.  */
2771
2772   if (DECL_SAVED_INSNS (decl) == 0)
2773     {
2774       int inlinable = 0;
2775       tree parent;
2776       const char *lose;
2777
2778       /* If this is nested inside an inlined external function, pretend
2779          it was only declared.  Since we cannot inline such functions,
2780          generating code for this one is not only not necessary but will
2781          confuse some debugging output writers.  */
2782       for (parent = DECL_CONTEXT (current_function_decl);
2783            parent != NULL_TREE; 
2784            parent = get_containing_scope (parent))
2785         if (TREE_CODE (parent) == FUNCTION_DECL
2786             && DECL_INLINE (parent) && DECL_EXTERNAL (parent))
2787           {
2788             DECL_INITIAL (decl) = 0;
2789             goto exit_rest_of_compilation;
2790           }
2791
2792       /* If requested, consider whether to make this function inline.  */
2793       if (DECL_INLINE (decl) || flag_inline_functions)
2794         TIMEVAR (integration_time,
2795                  {
2796                    lose = function_cannot_inline_p (decl);
2797                    if (lose || ! optimize)
2798                      {
2799                        if (warn_inline && DECL_INLINE (decl))
2800                          warning_with_decl (decl, lose);
2801                        DECL_ABSTRACT_ORIGIN (decl) = 0;
2802                        /* Don't really compile an extern inline function.
2803                           If we can't make it inline, pretend
2804                           it was only declared.  */
2805                        if (DECL_EXTERNAL (decl))
2806                          {
2807                            DECL_INITIAL (decl) = 0;
2808                            goto exit_rest_of_compilation;
2809                          }
2810                      }
2811                    else
2812                      /* ??? Note that this has the effect of making it look
2813                         like "inline" was specified for a function if we choose
2814                         to inline it.  This isn't quite right, but it's
2815                         probably not worth the trouble to fix.  */
2816                      inlinable = DECL_INLINE (decl) = 1;
2817                  });
2818
2819       insns = get_insns ();
2820
2821       /* Dump the rtl code if we are dumping rtl.  */
2822
2823       if (open_dump_file (DFI_rtl, decl))
2824         {
2825           if (DECL_SAVED_INSNS (decl))
2826             fprintf (rtl_dump_file, ";; (integrable)\n\n");
2827           close_dump_file (DFI_rtl, print_rtl, insns);
2828         }
2829
2830       /* If function is inline, and we don't yet know whether to
2831          compile it by itself, defer decision till end of compilation.
2832          finish_compilation will call rest_of_compilation again
2833          for those functions that need to be output.  Also defer those
2834          functions that we are supposed to defer.  */
2835
2836       if (inlinable
2837           || (DECL_INLINE (decl)
2838               && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
2839                    && ! flag_keep_inline_functions)
2840                   || DECL_EXTERNAL (decl))))
2841         DECL_DEFER_OUTPUT (decl) = 1;
2842
2843       if (DECL_DEFER_OUTPUT (decl))
2844         {
2845           /* If -Wreturn-type, we have to do a bit of compilation.
2846              However, if we just fall through we will call
2847              save_for_inline_copying() which results in excessive
2848              memory use.  Instead, we just want to call
2849              jump_optimize() to figure out whether or not we can fall
2850              off the end of the function; we do the minimum amount of
2851              work necessary to make that safe.  And, we set optimize
2852              to zero to keep jump_optimize from working too hard.  */
2853           if (warn_return_type)
2854             {
2855               int saved_optimize = optimize;
2856               optimize = 0;
2857               find_exception_handler_labels ();
2858               jump_optimize (get_insns(), !JUMP_CROSS_JUMP, !JUMP_NOOP_MOVES,
2859                              !JUMP_AFTER_REGSCAN);
2860               optimize = saved_optimize;
2861             }
2862
2863           current_function_nothrow = nothrow_function_p ();
2864           if (current_function_nothrow)
2865             /* Now we know that this can't throw; set the flag for the benefit
2866                of other functions later in this translation unit.  */
2867             TREE_NOTHROW (current_function_decl) = 1;
2868
2869           note_deferral_of_defined_inline_function (decl);
2870           TIMEVAR (integration_time, save_for_inline_nocopy (decl));
2871           DECL_SAVED_INSNS (decl)->inlinable = inlinable;
2872           goto exit_rest_of_compilation;
2873         }
2874
2875       /* If specified extern inline but we aren't inlining it, we are
2876          done.  This goes for anything that gets here with DECL_EXTERNAL
2877          set, not just things with DECL_INLINE.  */
2878       if (DECL_EXTERNAL (decl))
2879         goto exit_rest_of_compilation;
2880     }
2881
2882   /* We may have potential sibling or tail recursion sites.  Select one
2883      (of possibly multiple) methods of performing the call.  */
2884   init_EXPR_INSN_LIST_cache ();
2885   if (flag_optimize_sibling_calls)
2886     optimize_sibling_and_tail_recursive_calls ();
2887   
2888   if (ggc_p)
2889     ggc_collect ();
2890
2891   /* Initialize some variables used by the optimizers.  */
2892   init_function_for_compilation ();
2893
2894   if (! DECL_DEFER_OUTPUT (decl))
2895     TREE_ASM_WRITTEN (decl) = 1;
2896
2897   /* Now that integrate will no longer see our rtl, we need not distinguish
2898      between the return value of this function and the return value of called
2899      functions.  */
2900   rtx_equal_function_value_matters = 0;
2901
2902   /* Don't return yet if -Wreturn-type; we need to do jump_optimize.  */
2903   if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
2904     {
2905       goto exit_rest_of_compilation;
2906     }
2907
2908   /* Emit code to get eh context, if needed. */
2909   emit_eh_context ();
2910
2911 #ifdef FINALIZE_PIC
2912   /* If we are doing position-independent code generation, now
2913      is the time to output special prologues and epilogues.
2914      We do not want to do this earlier, because it just clutters
2915      up inline functions with meaningless insns.  */
2916   if (flag_pic)
2917     FINALIZE_PIC;
2918 #endif
2919
2920   /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
2921      Note that that may have been done above, in save_for_inline_copying.
2922      The call to resume_temporary_allocation near the end of this function
2923      goes back to the usual state of affairs.  This must be done after
2924      we've built up any unwinders for exception handling, and done
2925      the FINALIZE_PIC work, if necessary.  */
2926
2927   rtl_in_current_obstack ();
2928
2929   insns = get_insns ();
2930
2931   /* Copy any shared structure that should not be shared.  */
2932
2933   unshare_all_rtl (current_function_decl, insns);
2934
2935 #ifdef SETJMP_VIA_SAVE_AREA
2936   /* This must be performed before virutal register instantiation.  */
2937   if (current_function_calls_alloca)
2938     optimize_save_area_alloca (insns);
2939 #endif
2940
2941   /* Instantiate all virtual registers.  */
2942
2943   instantiate_virtual_regs (current_function_decl, get_insns ());
2944
2945   /* See if we have allocated stack slots that are not directly addressable.
2946      If so, scan all the insns and create explicit address computation
2947      for all references to such slots.  */
2948   /* fixup_stack_slots (); */
2949
2950   /* Find all the EH handlers.  */
2951   find_exception_handler_labels ();
2952
2953   open_dump_file (DFI_jump, decl);
2954
2955   /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
2956      are initialized and to compute whether control can drop off the end
2957      of the function.  */
2958   TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
2959   TIMEVAR (jump_time, jump_optimize (insns, !JUMP_CROSS_JUMP, !JUMP_NOOP_MOVES,
2960                                      JUMP_AFTER_REGSCAN));
2961
2962   /* Jump optimization, and the removal of NULL pointer checks, may
2963      have reduced the number of instructions substantially.  CSE, and
2964      future passes, allocate arrays whose dimensions involve the maximum
2965      instruction UID, so if we can reduce the maximum UID we'll save big on
2966      memory.  */
2967   renumber_insns (rtl_dump_file);
2968
2969   close_dump_file (DFI_jump, print_rtl, insns);
2970
2971   /* Now is when we stop if -fsyntax-only and -Wreturn-type.  */
2972   if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
2973     goto exit_rest_of_compilation;
2974
2975   /* Try to identify useless null pointer tests and delete them.  */
2976   if (flag_delete_null_pointer_checks)
2977     TIMEVAR (jump_time, delete_null_pointer_checks (get_insns ()));
2978
2979   if (ggc_p)
2980     ggc_collect ();
2981
2982   /* Perform common subexpression elimination.
2983      Nonzero value from `cse_main' means that jumps were simplified
2984      and some code may now be unreachable, so do
2985      jump optimization again.  */
2986
2987   if (optimize > 0)
2988     {
2989       open_dump_file (DFI_cse, decl);
2990
2991       TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 1));
2992
2993       if (flag_thread_jumps)
2994         TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 1));
2995
2996       TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (),
2997                                          0, rtl_dump_file));
2998       /* If we are not running the second CSE pass, then we are no longer
2999          expecting CSE to be run.  */
3000       cse_not_expected = !flag_rerun_cse_after_loop;
3001
3002       if (tem || optimize > 1)
3003         TIMEVAR (jump_time, jump_optimize (insns, !JUMP_CROSS_JUMP,
3004                                            !JUMP_NOOP_MOVES,
3005                                            !JUMP_AFTER_REGSCAN));
3006  
3007       /* Run this after jump optmizations remove all the unreachable code
3008          so that unreachable code will not keep values live.  */
3009       TIMEVAR (cse_time, delete_trivially_dead_insns (insns, max_reg_num ()));
3010
3011       /* Try to identify useless null pointer tests and delete them.  */
3012       if (flag_delete_null_pointer_checks)
3013         TIMEVAR (jump_time, delete_null_pointer_checks (get_insns ()));
3014
3015       /* The second pass of jump optimization is likely to have
3016          removed a bunch more instructions.  */
3017       renumber_insns (rtl_dump_file);
3018
3019       close_dump_file (DFI_cse, print_rtl, insns);
3020     }
3021
3022   open_dump_file (DFI_addressof, decl);
3023
3024   purge_addressof (insns);
3025   reg_scan (insns, max_reg_num (), 1);
3026
3027   close_dump_file (DFI_addressof, print_rtl, insns);
3028
3029   if (ggc_p)
3030     ggc_collect ();
3031
3032   if (flag_ssa)
3033     {
3034       open_dump_file (DFI_ssa, decl);
3035       convert_to_ssa ();
3036       close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
3037
3038       open_dump_file (DFI_ussa, decl);
3039       convert_from_ssa ();
3040       /* New registers have been created.  Rescan their usage.  */
3041       reg_scan (insns, max_reg_num (), 1);
3042       close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
3043
3044       /* Life analysis used in SSA adds log_links but these shouldn't
3045          be there until the flow stage, so clear them away.  */
3046       clear_log_links (insns);
3047
3048       if (ggc_p)
3049         ggc_collect ();
3050     }
3051
3052   /* Perform global cse.  */
3053
3054   if (optimize > 0 && flag_gcse)
3055     {
3056       open_dump_file (DFI_gcse, decl);
3057
3058       TIMEVAR (gcse_time, tem = gcse_main (insns, rtl_dump_file));
3059
3060       /* If gcse altered any jumps, rerun jump optimizations to clean
3061          things up.  */
3062       if (tem)
3063         {
3064           TIMEVAR (jump_time, jump_optimize (insns, !JUMP_CROSS_JUMP,
3065                                              !JUMP_NOOP_MOVES,
3066                                              !JUMP_AFTER_REGSCAN));
3067         }
3068
3069       close_dump_file (DFI_gcse, print_rtl, insns);
3070
3071       if (ggc_p)
3072         ggc_collect ();
3073     }
3074   /* Move constant computations out of loops.  */
3075
3076   if (optimize > 0)
3077     {
3078       open_dump_file (DFI_loop, decl);
3079
3080       TIMEVAR
3081         (loop_time,
3082          {
3083            if (flag_rerun_loop_opt)
3084              {
3085                /* We only want to perform unrolling once.  */
3086                
3087                loop_optimize (insns, rtl_dump_file, 0, 0);
3088                
3089         
3090                /* The first call to loop_optimize makes some instructions
3091                   trivially dead.  We delete those instructions now in the
3092                   hope that doing so will make the heuristics in loop work
3093                   better and possibly speed up compilation.  */
3094                delete_trivially_dead_insns (insns, max_reg_num ());
3095
3096                /* The regscan pass is currently necessary as the alias
3097                   analysis code depends on this information.  */
3098                reg_scan (insns, max_reg_num (), 1);
3099              }
3100            loop_optimize (insns, rtl_dump_file, flag_unroll_loops, 1);
3101          });
3102
3103       close_dump_file (DFI_loop, print_rtl, insns);
3104
3105       if (ggc_p)
3106         ggc_collect ();
3107     }
3108
3109   /* ??? Well, nearly.  If HAVE_conditional_arithmetic, jump_optimize
3110      has put off all if-conversion until "after CSE".  If we put this
3111      off any longer we may miss out doing if-conversion entirely.  */
3112   cse_not_expected = 1;
3113
3114   if (optimize > 0)
3115     {
3116       open_dump_file (DFI_cse2, decl);
3117
3118       if (flag_rerun_cse_after_loop)
3119         {
3120           /* Running another jump optimization pass before the second
3121              cse pass sometimes simplifies the RTL enough to allow
3122              the second CSE pass to do a better job.  Jump_optimize can change
3123              max_reg_num so we must rerun reg_scan afterwards.
3124              ??? Rework to not call reg_scan so often.  */
3125           TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
3126           TIMEVAR (jump_time, jump_optimize (insns, !JUMP_CROSS_JUMP,
3127                                              !JUMP_NOOP_MOVES,
3128                                              JUMP_AFTER_REGSCAN));
3129           
3130           TIMEVAR (cse2_time, reg_scan (insns, max_reg_num (), 0));
3131           TIMEVAR (cse2_time, tem = cse_main (insns, max_reg_num (),
3132                                               1, rtl_dump_file));
3133           if (tem)
3134             TIMEVAR (jump_time, jump_optimize (insns, !JUMP_CROSS_JUMP,
3135                                                !JUMP_NOOP_MOVES,
3136                                                !JUMP_AFTER_REGSCAN));
3137         }
3138
3139       if (flag_thread_jumps)
3140         {
3141           /* This pass of jump threading straightens out code
3142              that was kinked by loop optimization.  */
3143           TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
3144           TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0));
3145         }
3146
3147       close_dump_file (DFI_cse2, print_rtl, insns);
3148
3149       if (ggc_p)
3150         ggc_collect ();
3151     }
3152
3153   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
3154     {
3155       open_dump_file (DFI_bp, decl);
3156
3157       TIMEVAR
3158         (branch_prob_time,
3159          {
3160            branch_prob (insns, rtl_dump_file);
3161          });
3162
3163       close_dump_file (DFI_bp, print_rtl, insns);
3164
3165       if (ggc_p)
3166         ggc_collect ();
3167     }
3168
3169   regclass_init ();
3170
3171   /* Print function header into flow dump now
3172      because doing the flow analysis makes some of the dump.  */
3173
3174   open_dump_file (DFI_flow, decl);
3175   
3176   /* Do control and data flow analysis; wrote some of the results to
3177      the dump file.  */
3178
3179   TIMEVAR
3180     (flow_time,
3181      {
3182        find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
3183        cleanup_cfg (insns);
3184        if (optimize)
3185          calculate_loop_depth (rtl_dump_file);
3186        life_analysis (insns, max_reg_num (), rtl_dump_file, 1);
3187        mark_constant_function ();
3188      });
3189
3190   if (warn_uninitialized || extra_warnings)
3191     {
3192       uninitialized_vars_warning (DECL_INITIAL (decl));
3193       if (extra_warnings)
3194         setjmp_args_warning ();
3195     }
3196
3197   close_dump_file (DFI_flow, print_rtl_with_bb, insns);
3198
3199   if (ggc_p)
3200     ggc_collect ();
3201
3202   /* The first life analysis pass has finished.  From now on we can not
3203      generate any new pseudos.  */
3204   no_new_pseudos = 1;
3205
3206   /* If -opt, try combining insns through substitution.  */
3207
3208   if (optimize > 0)
3209     {
3210       int rebuild_jump_labels_after_combine = 0;
3211
3212       open_dump_file (DFI_combine, decl);
3213
3214       TIMEVAR (combine_time, 
3215                {
3216                  rebuild_jump_labels_after_combine
3217                    = combine_instructions (insns, max_reg_num ());
3218                });
3219       
3220       /* Combining insns may have turned an indirect jump into a
3221          direct jump.  Rebuid the JUMP_LABEL fields of jumping
3222          instructions.  */
3223       if (rebuild_jump_labels_after_combine)
3224         {
3225           TIMEVAR (jump_time, rebuild_jump_labels (insns));
3226         }
3227
3228       close_dump_file (DFI_combine, print_rtl_with_bb, insns);
3229
3230       if (ggc_p)
3231         ggc_collect ();
3232     }
3233
3234   /* Register allocation pre-pass, to reduce number of moves
3235      necessary for two-address machines.  */
3236   if (optimize > 0 && (flag_regmove || flag_expensive_optimizations))
3237     {
3238       open_dump_file (DFI_regmove, decl);
3239
3240       TIMEVAR (regmove_time, regmove_optimize (insns, max_reg_num (),
3241                                                rtl_dump_file));
3242
3243       close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
3244
3245       if (ggc_p)
3246         ggc_collect ();
3247     }
3248
3249   if (optimize && n_basic_blocks)
3250     {
3251       TIMEVAR (gcse_time, optimize_mode_switching (NULL_PTR));
3252     }
3253
3254 #ifdef INSN_SCHEDULING
3255
3256   /* Print function header into sched dump now
3257      because doing the sched analysis makes some of the dump.  */
3258   if (optimize > 0 && flag_schedule_insns)
3259     {
3260       open_dump_file (DFI_sched, decl);
3261
3262       /* Do control and data sched analysis,
3263          and write some of the results to dump file.  */
3264
3265       TIMEVAR (sched_time, schedule_insns (rtl_dump_file));
3266
3267       close_dump_file (DFI_sched, print_rtl_with_bb, insns);
3268
3269       if (ggc_p)
3270         ggc_collect ();
3271     }
3272 #endif
3273
3274   /* Determine if the current function is a leaf before running reload
3275      since this can impact optimizations done by the prologue and
3276      epilogue thus changing register elimination offsets.  */
3277   current_function_is_leaf = leaf_function_p ();
3278
3279   open_dump_file (DFI_lreg, decl);
3280
3281   /* Allocate pseudo-regs that are used only within 1 basic block. 
3282
3283      RUN_JUMP_AFTER_RELOAD records whether or not we need to rerun the
3284      jump optimizer after register allocation and reloading are finished.  */
3285
3286   TIMEVAR (local_alloc_time,
3287            {
3288              /* We recomputed reg usage as part of updating the rest
3289                 of life info during sched.  */
3290              if (! flag_schedule_insns)
3291                recompute_reg_usage (insns, ! optimize_size);
3292              regclass (insns, max_reg_num (), rtl_dump_file);
3293              rebuild_label_notes_after_reload = local_alloc ();
3294            });
3295
3296   if (dump_file[DFI_lreg].enabled)
3297     {
3298       TIMEVAR (dump_time, dump_flow_info (rtl_dump_file));
3299       TIMEVAR (dump_time, dump_local_alloc (rtl_dump_file));
3300
3301       close_dump_file (DFI_lreg, print_rtl_with_bb, insns);
3302     }
3303
3304   if (ggc_p)
3305     ggc_collect ();
3306
3307   open_dump_file (DFI_greg, decl);
3308
3309   /* If optimizing, allocate remaining pseudo-regs.  Do the reload
3310      pass fixing up any insns that are invalid.  */
3311
3312   TIMEVAR (global_alloc_time,
3313            {
3314              if (optimize)
3315                failure = global_alloc (rtl_dump_file);
3316              else
3317                {
3318                  build_insn_chain (insns);
3319                  failure = reload (insns, 0, rtl_dump_file);
3320                }
3321            });
3322
3323   if (failure)
3324     goto exit_rest_of_compilation;
3325
3326   if (ggc_p)
3327     ggc_collect ();
3328
3329   /* Do a very simple CSE pass over just the hard registers.  */
3330   if (optimize > 0)
3331     reload_cse_regs (insns);
3332
3333   /* If optimizing and we are performing instruction scheduling after
3334      reload, then go ahead and split insns now since we are about to
3335      recompute flow information anyway.
3336
3337      reload_cse_regs may expose more splitting opportunities, expecially
3338      for double-word operations.  */
3339   if (optimize > 0 && flag_schedule_insns_after_reload)
3340     split_all_insns (0);
3341
3342   /* Register allocation and reloading may have turned an indirect jump into
3343      a direct jump.  If so, we must rebuild the JUMP_LABEL fields of
3344      jumping instructions.  */
3345   if (rebuild_label_notes_after_reload)
3346     TIMEVAR (jump_time, rebuild_jump_labels (insns));
3347
3348   if (dump_file[DFI_greg].enabled)
3349     {
3350       TIMEVAR (dump_time, dump_global_regs (rtl_dump_file));
3351       close_dump_file (DFI_greg, print_rtl_with_bb, insns);
3352     }
3353
3354   /* Re-create the death notes which were deleted during reload.  */
3355   open_dump_file (DFI_flow2, decl);
3356   
3357   TIMEVAR (flow2_time,
3358            {
3359              find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
3360            });
3361
3362   /* On some machines, the prologue and epilogue code, or parts thereof,
3363      can be represented as RTL.  Doing so lets us schedule insns between
3364      it and the rest of the code and also allows delayed branch
3365      scheduling to operate in the epilogue.  */
3366   thread_prologue_and_epilogue_insns (insns);
3367
3368   if (optimize)
3369     {
3370       TIMEVAR (flow2_time,
3371                {
3372                  cleanup_cfg (insns);
3373                  life_analysis (insns, max_reg_num (), rtl_dump_file, 1);
3374                });
3375
3376       /* This is kind of heruistics.  We need to run combine_stack_adjustments
3377          even for machines with possibly nonzero RETURN_POPS_ARGS
3378          and ACCUMULATE_OUTGOING_ARGS.  We expect that only ports having
3379          push instructions will have popping returns.  */
3380 #ifndef PUSH_ROUNDING
3381       if (!ACCUMULATE_OUTGOING_ARGS)
3382 #endif
3383         TIMEVAR (flow2_time, { combine_stack_adjustments (); });
3384
3385       if (ggc_p)
3386         ggc_collect ();
3387     }
3388
3389   flow2_completed = 1;
3390
3391   close_dump_file (DFI_flow2, print_rtl_with_bb, insns);
3392
3393 #ifdef HAVE_peephole2
3394   if (optimize > 0 && flag_peephole2)
3395     {
3396       open_dump_file (DFI_peephole2, decl);
3397
3398       TIMEVAR (peephole2_time, peephole2_optimize (rtl_dump_file));
3399
3400       close_dump_file (DFI_peephole2, print_rtl_with_bb, insns);
3401     }
3402 #endif
3403
3404 #ifdef INSN_SCHEDULING
3405   if (optimize > 0 && flag_schedule_insns_after_reload)
3406     {
3407       open_dump_file (DFI_sched2, decl);
3408
3409       /* Do control and data sched analysis again,
3410          and write some more of the results to dump file.  */
3411
3412       TIMEVAR (sched2_time, schedule_insns (rtl_dump_file));
3413
3414       close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
3415
3416       if (ggc_p)
3417         ggc_collect ();
3418     }
3419 #endif
3420
3421 #ifdef LEAF_REGISTERS
3422   current_function_uses_only_leaf_regs
3423     = optimize > 0 && only_leaf_regs_used () && leaf_function_p ();
3424 #endif
3425
3426   if (optimize > 0 && flag_reorder_blocks)
3427     {
3428       open_dump_file (DFI_bbro, decl);
3429
3430       TIMEVAR (reorder_blocks_time, reorder_basic_blocks ());
3431
3432       close_dump_file (DFI_bbro, print_rtl_with_bb, insns);
3433     }    
3434
3435   if (optimize > 0 && flag_rename_registers)
3436     {
3437       open_dump_file (DFI_rnreg, decl);
3438
3439       TIMEVAR (rename_registers_time, regrename_optimize ());
3440
3441       close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
3442     }    
3443
3444   /* One more attempt to remove jumps to .+1 left by dead-store elimination. 
3445      Also do cross-jumping this time and delete no-op move insns.  */
3446
3447   if (optimize > 0)
3448     {
3449       open_dump_file (DFI_jump2, decl);
3450
3451       TIMEVAR (jump_time, jump_optimize (insns, JUMP_CROSS_JUMP,
3452                                          JUMP_NOOP_MOVES,
3453                                          !JUMP_AFTER_REGSCAN));
3454
3455       close_dump_file (DFI_jump2, print_rtl_with_bb, insns);
3456     }
3457
3458   /* If a machine dependent reorganization is needed, call it.  */
3459 #ifdef MACHINE_DEPENDENT_REORG
3460   open_dump_file (DFI_mach, decl);
3461
3462   MACHINE_DEPENDENT_REORG (insns);
3463
3464   close_dump_file (DFI_mach, print_rtl_with_bb, insns);
3465
3466   if (ggc_p)
3467     ggc_collect ();
3468 #endif
3469
3470   /* If a scheduling pass for delayed branches is to be done,
3471      call the scheduling code.  */
3472
3473 #ifdef DELAY_SLOTS
3474   if (optimize > 0 && flag_delayed_branch)
3475     {
3476       open_dump_file (DFI_dbr, decl);
3477
3478       TIMEVAR
3479         (dbr_sched_time,
3480          {
3481            dbr_schedule (insns, rtl_dump_file);
3482          });
3483
3484       close_dump_file (DFI_dbr, print_rtl_with_bb, insns);
3485
3486       if (ggc_p)
3487         ggc_collect ();
3488     }
3489 #endif
3490
3491   /* Shorten branches. 
3492
3493      Note this must run before reg-stack because of death note (ab)use
3494      in the ia32 backend.  */
3495   TIMEVAR (shorten_branch_time,
3496            {
3497              shorten_branches (get_insns ());
3498            });
3499
3500 #ifdef STACK_REGS
3501   open_dump_file (DFI_stack, decl);
3502
3503   TIMEVAR (stack_reg_time, reg_to_stack (insns, rtl_dump_file));
3504
3505   close_dump_file (DFI_stack, print_rtl_with_bb, insns);
3506
3507   if (ggc_p)
3508     ggc_collect ();
3509 #endif
3510
3511   current_function_nothrow = nothrow_function_p ();
3512   if (current_function_nothrow)
3513     /* Now we know that this can't throw; set the flag for the benefit
3514        of other functions later in this translation unit.  */
3515     TREE_NOTHROW (current_function_decl) = 1;
3516
3517   /* Now turn the rtl into assembler code.  */
3518
3519   TIMEVAR (final_time,
3520            {
3521              rtx x;
3522              const char *fnname;
3523
3524              /* Get the function's name, as described by its RTL.
3525                 This may be different from the DECL_NAME name used
3526                 in the source file.  */
3527
3528              x = DECL_RTL (decl);
3529              if (GET_CODE (x) != MEM)
3530                abort ();
3531              x = XEXP (x, 0);
3532              if (GET_CODE (x) != SYMBOL_REF)
3533                abort ();
3534              fnname = XSTR (x, 0);
3535
3536              assemble_start_function (decl, fnname);
3537              final_start_function (insns, asm_out_file, optimize);
3538              final (insns, asm_out_file, optimize, 0);
3539              final_end_function (insns, asm_out_file, optimize);
3540              assemble_end_function (decl, fnname);
3541              if (! quiet_flag)
3542                fflush (asm_out_file);
3543
3544              /* Release all memory allocated by flow.  */
3545              free_basic_block_vars (0);
3546
3547              /* Release all memory held by regsets now */
3548              regset_release_memory ();
3549            });
3550
3551   if (ggc_p)
3552     ggc_collect ();
3553
3554   /* Write DBX symbols if requested */
3555
3556   /* Note that for those inline functions where we don't initially
3557      know for certain that we will be generating an out-of-line copy,
3558      the first invocation of this routine (rest_of_compilation) will
3559      skip over this code by doing a `goto exit_rest_of_compilation;'.
3560      Later on, finish_compilation will call rest_of_compilation again
3561      for those inline functions that need to have out-of-line copies
3562      generated.  During that call, we *will* be routed past here.  */
3563
3564 #ifdef DBX_DEBUGGING_INFO
3565   if (write_symbols == DBX_DEBUG)
3566     TIMEVAR (symout_time, dbxout_function (decl));
3567 #endif
3568
3569 #ifdef DWARF_DEBUGGING_INFO
3570   if (write_symbols == DWARF_DEBUG)
3571     TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
3572 #endif
3573
3574 #ifdef DWARF2_DEBUGGING_INFO
3575   if (write_symbols == DWARF2_DEBUG)
3576     TIMEVAR (symout_time, dwarf2out_decl (decl));
3577 #endif
3578
3579  exit_rest_of_compilation:
3580
3581   /* In case the function was not output,
3582      don't leave any temporary anonymous types
3583      queued up for sdb output.  */
3584 #ifdef SDB_DEBUGGING_INFO
3585   if (write_symbols == SDB_DEBUG)
3586     sdbout_types (NULL_TREE);
3587 #endif
3588
3589   reload_completed = 0;
3590   flow2_completed = 0;
3591   no_new_pseudos = 0;
3592
3593   TIMEVAR (final_time,
3594            {
3595               /* Clear out the insn_length contents now that they are no
3596                  longer valid.  */
3597               init_insn_lengths ();
3598
3599               /* Clear out the real_constant_chain before some of the rtx's
3600                  it runs through become garbage.  */
3601               clear_const_double_mem ();
3602
3603               /* Cancel the effect of rtl_in_current_obstack.  */
3604               resume_temporary_allocation ();
3605
3606               /* Show no temporary slots allocated.  */
3607               init_temp_slots ();
3608
3609               free_basic_block_vars (0);
3610            });
3611
3612   /* Make sure volatile mem refs aren't considered valid operands for
3613      arithmetic insns.  We must call this here if this is a nested inline
3614      function, since the above code leaves us in the init_recog state
3615      (from final.c), and the function context push/pop code does not
3616      save/restore volatile_ok.
3617
3618      ??? Maybe it isn't necessary for expand_start_function to call this
3619      anymore if we do it here?  */
3620
3621   init_recog_no_volatile ();
3622
3623   /* We're done with this function.  Free up memory if we can.  */
3624   free_after_parsing (cfun);
3625   if (! DECL_DEFER_OUTPUT (decl))
3626     free_after_compilation (cfun);
3627   cfun = 0;
3628
3629   if (ggc_p)
3630     ggc_collect ();
3631
3632   /* The parsing time is all the time spent in yyparse
3633      *except* what is spent in this function.  */
3634
3635   parse_time -= get_run_time () - start_time;
3636 }
3637 \f
3638 static void
3639 display_help ()
3640 {
3641   int    undoc;
3642   unsigned long  i;
3643   const char * lang;
3644   
3645 #ifndef USE_CPPLIB  
3646   printf ("Usage: %s input [switches]\n", progname);
3647   printf ("Switches:\n");
3648 #endif
3649   printf ("  -ffixed-<register>      Mark <register> as being unavailable to the compiler\n");
3650   printf ("  -fcall-used-<register>  Mark <register> as being corrupted by function calls\n");
3651   printf ("  -fcall-saved-<register> Mark <register> as being preserved across functions\n");
3652   printf ("  -finline-limit=<number> Limits the size of inlined functions to <number>\n");
3653
3654   for (i = NUM_ELEM (f_options); i--;)
3655     {
3656       const char * description = f_options[i].description;
3657       
3658       if (description != NULL && * description != 0)
3659         printf ("  -f%-21s %s\n",
3660                 f_options[i].string, description);
3661     }
3662   
3663   printf ("  -O[number]              Set optimisation level to [number]\n");
3664   printf ("  -Os                     Optimise for space rather than speed\n");
3665   printf ("  -pedantic               Issue warnings needed by strict compliance to ANSI C\n");
3666   printf ("  -pedantic-errors        Like -pedantic except that errors are produced\n");
3667   printf ("  -w                      Suppress warnings\n");
3668   printf ("  -W                      Enable extra warnings\n");
3669   
3670   for (i = NUM_ELEM (W_options); i--;)
3671     {
3672       const char * description = W_options[i].description;
3673       
3674       if (description != NULL && * description != 0)
3675         printf ("  -W%-21s %s\n",
3676                 W_options[i].string, description);
3677     }
3678   
3679   printf ("  -Wid-clash-<num>        Warn if 2 identifiers have the same first <num> chars\n");
3680   printf ("  -Wlarger-than-<number>  Warn if an object is larger than <number> bytes\n");
3681   printf ("  -p                      Enable function profiling\n");
3682 #if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER)
3683   printf ("  -a                      Enable block profiling \n");
3684 #endif  
3685 #if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER) || defined FUNCTION_BLOCK_PROFILER_EXIT
3686   printf ("  -ax                     Enable jump profiling \n");
3687 #endif  
3688   printf ("  -o <file>               Place output into <file> \n");
3689   printf ("  -G <number>             Put global and static data smaller than <number>\n");
3690   printf ("                           bytes into a special section (on some targets)\n");
3691   
3692   for (i = NUM_ELEM (debug_args); i--;)
3693     {
3694       if (debug_args[i].description != NULL)
3695         printf ("  -g%-21s %s\n", debug_args[i].arg, debug_args[i].description);
3696     }
3697   
3698   printf ("  -aux-info <file>        Emit declaration info into <file>.X\n");
3699   printf ("  -quiet                  Do not display functions compiled or elapsed time\n");
3700   printf ("  -version                Display the compiler's version\n");
3701   printf ("  -d[letters]             Enable dumps from specific passes of the compiler\n");
3702   printf ("  -dumpbase <file>        Base name to be used for dumps from specific passes\n");
3703 #if defined INSN_SCHEDULING
3704   printf ("  -sched-verbose=<number> Set the verbosity level of the scheduler\n");
3705 #endif
3706   printf ("  --help                  Display this information\n");
3707
3708   undoc = 0;
3709   lang  = "language";
3710   
3711   /* Display descriptions of language specific options.
3712      If there is no description, note that there is an undocumented option.
3713      If the description is empty, do not display anything.  (This allows
3714      options to be deliberately undocumented, for whatever reason).
3715      If the option string is missing, then this is a marker, indicating
3716      that the description string is in fact the name of a language, whose
3717      language specific options are to follow.  */
3718   
3719   if (NUM_ELEM (documented_lang_options) > 1)
3720     {
3721       printf ("\nLanguage specific options:\n");
3722
3723       for (i = 0; i < NUM_ELEM (documented_lang_options); i++)
3724         {
3725           const char * description = documented_lang_options[i].description;
3726           const char * option      = documented_lang_options[i].option;
3727
3728           if (description == NULL)
3729             {
3730               undoc = 1;
3731
3732               if (extra_warnings)
3733                 printf ("  %-23.23s [undocumented]\n", option);
3734             }
3735           else if (* description == 0)
3736             continue;
3737           else if (option == NULL)
3738             {
3739               if (undoc)
3740                 printf
3741                   ("\nThere are undocumented %s specific options as well.\n",
3742                         lang);
3743               undoc = 0;
3744               
3745               printf ("\n Options for %s:\n", description);
3746
3747               lang = description;
3748             }
3749           else
3750             printf ("  %-23.23s %s\n", option, description);
3751         }
3752     }
3753
3754   if (undoc)
3755     printf ("\nThere are undocumented %s specific options as well.\n", lang);
3756
3757   if (NUM_ELEM (target_switches) > 1
3758 #ifdef TARGET_OPTIONS
3759       || NUM_ELEM (target_options) > 1
3760 #endif
3761       )
3762     {
3763       int doc = 0;
3764       
3765       undoc = 0;
3766   
3767       printf ("\nTarget specific options:\n");
3768
3769       for (i = NUM_ELEM (target_switches); i--;)
3770         {
3771           const char * option      = target_switches[i].name;
3772           const char * description = target_switches[i].description;
3773
3774           if (option == NULL || * option == 0)
3775             continue;
3776           else if (description == NULL)
3777             {
3778               undoc = 1;
3779               
3780               if (extra_warnings)
3781                 printf ("  -m%-21.21s [undocumented]\n", option);
3782             }
3783           else if (* description != 0)
3784             doc += printf ("  -m%-21.21s %s\n", option, description);
3785         }
3786       
3787 #ifdef TARGET_OPTIONS      
3788       for (i = NUM_ELEM (target_options); i--;)
3789         {
3790           const char * option      = target_options[i].prefix;
3791           const char * description = target_options[i].description;
3792
3793           if (option == NULL || * option == 0)
3794             continue;
3795           else if (description == NULL)
3796             {
3797               undoc = 1;
3798               
3799               if (extra_warnings)
3800                 printf ("  -m%-21.21s [undocumented]\n", option);
3801             }
3802           else if (* description != 0)
3803             doc += printf ("  -m%-21.21s %s\n", option, description);
3804         }
3805 #endif
3806       if (undoc)
3807         {
3808           if (doc)
3809             printf ("\nThere are undocumented target specific options as well.\n");
3810           else
3811             printf ("  They exist, but they are not documented.\n");
3812         }
3813     }
3814 }
3815 \f
3816 /* Parse a -d... comand line switch.  */
3817
3818 static void
3819 decode_d_option (arg)
3820      const char * arg;
3821 {
3822   int i, c, matched;
3823
3824   while (*arg)
3825     switch (c = *arg++)
3826       {
3827       case 'a':
3828         for (i = 0; i < DFI_MAX; ++i)
3829           dump_file[i].enabled = 1;
3830         break;
3831       case 'A':
3832         flag_debug_asm = 1;
3833         break;
3834       case 'm':
3835         flag_print_mem = 1;
3836         break;
3837       case 'p':
3838         flag_print_asm_name = 1;
3839         break;
3840       case 'v':
3841         graph_dump_format = vcg;
3842         break;
3843       case 'x':
3844         rtl_dump_and_exit = 1;
3845         break;
3846       case 'y':
3847         set_yydebug (1);
3848         break;
3849       case 'D': /* These are handled by the preprocessor.  */
3850       case 'I':
3851         break;
3852
3853       default:
3854         matched = 0;
3855         for (i = 0; i < DFI_MAX; ++i)
3856           if (c == dump_file[i].debug_switch)
3857             {
3858               dump_file[i].enabled = 1;
3859               matched = 1;
3860             }
3861
3862         if (! matched)
3863           warning ("unrecognized gcc debugging option: %c", c);
3864         break;
3865       }
3866 }
3867
3868 /* Parse a -f... comand line switch.  ARG is the value after the -f.
3869    It is safe to access 'ARG - 2' to generate the full switch name.
3870    Return the number of strings consumed.  */
3871
3872 static int
3873 decode_f_option (arg)
3874      const char * arg;
3875 {
3876   int j;
3877
3878   /* Search for the option in the table of binary f options.  */
3879   for (j = sizeof (f_options) / sizeof (f_options[0]); j--;)
3880     {
3881       if (!strcmp (arg, f_options[j].string))
3882         {
3883           *f_options[j].variable = f_options[j].on_value;
3884           return 1;
3885         }
3886     
3887       if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
3888           && ! strcmp (arg + 3, f_options[j].string))
3889         {
3890           *f_options[j].variable = ! f_options[j].on_value;
3891           return 1;
3892         }
3893     }
3894
3895   if (!strncmp (arg, "inline-limit-", 13)
3896       || !strncmp (arg, "inline-limit=", 13))
3897     inline_max_insns =
3898       read_integral_parameter (arg + 13, arg - 2, inline_max_insns);
3899 #ifdef INSN_SCHEDULING
3900   else if (!strncmp (arg, "sched-verbose=", 14))
3901     fix_sched_param ("verbose", (const char *)(arg + 14));
3902 #endif
3903   else if (!strncmp (arg, "fixed-", 6))
3904     fix_register ((const char *)(arg + 6), 1, 1);
3905   else if (!strncmp (arg, "call-used-", 10))
3906     fix_register ((const char *)(arg + 10), 0, 1);
3907   else if (!strncmp (arg, "call-saved-", 11))
3908     fix_register ((const char *)(arg + 11), 0, 0);
3909   else if (!strncmp (arg, "align-loops=", 12))
3910     align_loops = read_integral_parameter (arg + 12, arg - 2, align_loops);
3911   else if (!strncmp (arg, "align-functions=", 16))
3912     align_functions
3913       = read_integral_parameter (arg + 16, arg - 2, align_functions);
3914   else if (!strncmp (arg, "align-jumps=", 12))
3915     align_jumps = read_integral_parameter (arg + 12, arg - 2, align_jumps);
3916   else if (!strncmp (arg, "align-labels=", 13))
3917     align_labels = read_integral_parameter (arg + 13, arg - 2, align_labels);
3918   else if (!strncmp (arg, "stack-limit-register=", 21))
3919     {
3920       int reg = decode_reg_name (arg + 21);
3921       if (reg < 0)
3922         error ("unrecognized register name `%s'", arg + 21);
3923       else
3924         stack_limit_rtx = gen_rtx_REG (Pmode, reg);
3925     }
3926   else if (!strncmp (arg, "stack-limit-symbol=", 19))
3927     {
3928       char *nm;
3929       if (ggc_p)
3930         nm = ggc_alloc_string (arg + 19, strlen (arg + 19));
3931       else
3932         nm = xstrdup (arg + 19);
3933       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, nm);
3934     }
3935   else if (!strcmp (arg, "no-stack-limit"))
3936     stack_limit_rtx = NULL_RTX;
3937   else if (!strcmp (arg, "preprocessed"))
3938     /* Recognise this switch but do nothing.  This prevents warnings
3939        about an unrecognized switch if cpplib has not been linked in.  */
3940     ;
3941   else
3942     return 0;
3943
3944   return 1;
3945 }
3946
3947 /* Parse a -W... comand line switch.  ARG is the value after the -W.
3948    It is safe to access 'ARG - 2' to generate the full switch name.
3949    Return the number of strings consumed.  */
3950
3951 static int
3952 decode_W_option (arg)
3953      const char * arg;
3954 {
3955   int j;
3956   
3957   /* Search for the option in the table of binary W options.  */
3958
3959   for (j = sizeof (W_options) / sizeof (W_options[0]); j--;)
3960     {
3961       if (!strcmp (arg, W_options[j].string))
3962         {
3963           *W_options[j].variable = W_options[j].on_value;
3964           return 1;
3965         }
3966
3967       if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
3968           && ! strcmp (arg + 3, W_options[j].string))
3969         {
3970           *W_options[j].variable = ! W_options[j].on_value;
3971           return 1;
3972         }
3973     }
3974
3975   if (!strncmp (arg, "id-clash-", 9))
3976     {
3977       id_clash_len = read_integral_parameter (arg + 9, arg - 2, -1);
3978       
3979       if (id_clash_len != -1)
3980         warn_id_clash = 1;
3981     }
3982   else if (!strncmp (arg, "larger-than-", 12))
3983     {
3984       larger_than_size = read_integral_parameter (arg + 12, arg - 2, -1);
3985
3986       if (larger_than_size != -1)
3987         warn_larger_than = 1;
3988     }
3989   else
3990     return 0;
3991
3992   return 1;
3993 }
3994
3995 /* Parse a -g... comand line switch.  ARG is the value after the -g.
3996    It is safe to access 'ARG - 2' to generate the full switch name.
3997    Return the number of strings consumed.  */
3998
3999 static int
4000 decode_g_option (arg)
4001      const char * arg;
4002 {
4003   unsigned level;
4004   /* A lot of code assumes write_symbols == NO_DEBUG if the
4005      debugging level is 0 (thus -gstabs1 -gstabs0 would lose track
4006      of what debugging type has been selected).  This records the
4007      selected type.  It is an error to specify more than one
4008      debugging type.  */
4009   static enum debug_info_type selected_debug_type = NO_DEBUG;
4010   /* Non-zero if debugging format has been explicitly set.
4011      -g and -ggdb don't explicitly set the debugging format so
4012      -gdwarf -g3 is equivalent to -gdwarf3.  */
4013   static int type_explicitly_set_p = 0;
4014   /* Indexed by enum debug_info_type.  */
4015   static const char * debug_type_names[] =
4016   {
4017     "none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff"
4018   };
4019   
4020   /* The maximum admissible debug level value.  */
4021   static const unsigned max_debug_level = 3;
4022   
4023   /* Look up ARG in the table.  */
4024   for (da = debug_args; da->arg; da++)
4025     {
4026       const int da_len = strlen (da->arg);
4027
4028       if (da_len == 0 || ! strncmp (arg, da->arg, da_len))
4029         {
4030           enum debug_info_type type = da->debug_type;
4031           const char * p = arg + da_len;
4032           
4033           if (*p && (*p < '0' || *p > '9'))
4034             continue;
4035           
4036           /* A debug flag without a level defaults to level 2.
4037              Note we do not want to call read_integral_parameter
4038              for that case since it will call atoi which 
4039              will return zero.
4040              
4041              ??? We may want to generalize the interface to 
4042              read_integral_parameter to better handle this case
4043              if this case shows up often.  */
4044           if (*p)
4045             level = read_integral_parameter (p, 0, max_debug_level + 1);
4046           else
4047             level = 2;
4048           
4049           if (da_len > 1 && *p && !strncmp (arg, "dwarf", da_len))
4050             {
4051               error ("use -gdwarf -g%d for DWARF v1, level %d",
4052                      level, level);
4053               if (level == 2)
4054                 error ("use -gdwarf-2   for DWARF v2");
4055             }
4056           
4057           if (level > max_debug_level)
4058             {
4059               warning ("\
4060 ignoring option `%s' due to invalid debug level specification",
4061                        arg - 2);
4062               level = debug_info_level;
4063             }
4064
4065           if (type == NO_DEBUG)
4066             {
4067               type = PREFERRED_DEBUGGING_TYPE;
4068               
4069               if (da_len > 1 && strncmp (arg, "gdb", da_len) == 0)
4070                 {
4071 #if defined (DWARF2_DEBUGGING_INFO) && !defined (LINKER_DOES_NOT_WORK_WITH_DWARF2)
4072                   type = DWARF2_DEBUG;
4073 #else
4074 #ifdef DBX_DEBUGGING_INFO
4075                   type = DBX_DEBUG;
4076 #endif
4077 #endif
4078                 }
4079             }
4080           
4081           if (type == NO_DEBUG)
4082             warning ("`%s': unknown or unsupported -g option", arg - 2);
4083
4084           /* Does it conflict with an already selected type?  */
4085           if (type_explicitly_set_p
4086               /* -g/-ggdb don't conflict with anything */
4087               && da->debug_type != NO_DEBUG
4088               && type != selected_debug_type)
4089             warning ("`%s' ignored, conflicts with `-g%s'",
4090                      arg - 2, debug_type_names[(int) selected_debug_type]);
4091           else
4092             {
4093               /* If the format has already been set, -g/-ggdb
4094                  only change the debug level.  */
4095               if (type_explicitly_set_p && da->debug_type == NO_DEBUG)
4096                 ; /* don't change debugging type */
4097               else
4098                 {
4099                   selected_debug_type = type;
4100                   type_explicitly_set_p = da->debug_type != NO_DEBUG;
4101                 }
4102               
4103               write_symbols = (level == 0
4104                                ? NO_DEBUG
4105                                : selected_debug_type);
4106               use_gnu_debug_info_extensions = da->use_extensions_p;
4107               debug_info_level = (enum debug_info_level) level;
4108             }
4109           
4110           break;
4111         }
4112     }
4113   
4114   if (! da->arg)
4115     warning ("`%s': unknown or unsupported -g option", arg - 2);
4116
4117   return 1;
4118 }
4119
4120 /* Decode the first argument in the argv as a language-independent option.
4121    Return the number of strings consumed.  'strings_processed' is the
4122    number of strings that have already been decoded in a language
4123    specific fashion before this function was invoked.  */
4124    
4125 static unsigned int
4126 independent_decode_option (argc, argv, strings_processed)
4127      int argc;
4128      char **argv;
4129      unsigned int strings_processed;
4130 {
4131   char *arg = argv[0];
4132   
4133   if (arg[0] != '-' || arg[1] == 0)
4134     {
4135       if (arg[0] == '+')
4136         return 0;
4137       
4138       filename = arg;
4139
4140       return 1;
4141     }
4142
4143   arg ++;
4144   
4145   if (!strcmp (arg, "-help"))
4146     {
4147       display_help ();
4148       exit (0);
4149     }
4150
4151   if (* arg == 'Y')
4152     arg ++;
4153   
4154   switch (*arg)
4155     {
4156     default:
4157       return 0;
4158       
4159     case 'O':
4160       /* Already been treated in main (). Do nothing.  */
4161       break;
4162           
4163     case 'm':
4164       set_target_switch (arg + 1);
4165       break;
4166
4167     case 'f':
4168       return decode_f_option (arg + 1);
4169             
4170     case 'g':
4171       if (strings_processed == 0)
4172         return decode_g_option (arg + 1);
4173       else
4174         return strings_processed;
4175
4176     case 'd':
4177       if (!strcmp (arg, "dumpbase"))
4178         {
4179           if (argc == 1)
4180             return 0;
4181           
4182           dump_base_name = argv[1];
4183           return 2;
4184         }
4185       else
4186         decode_d_option (arg + 1);
4187       break;
4188
4189     case 'p':
4190       if (!strcmp (arg, "pedantic"))
4191         pedantic = 1;
4192       else if (!strcmp (arg, "pedantic-errors"))
4193         flag_pedantic_errors = pedantic = 1;
4194       else if (arg[1] == 0)
4195         profile_flag = 1;
4196       else
4197         return 0;
4198       break;
4199
4200     case 'q':
4201       if (!strcmp (arg, "quiet"))
4202         quiet_flag = 1;
4203       else
4204         return 0;
4205       break;
4206
4207     case 'v':
4208       if (!strcmp (arg, "version"))
4209         version_flag = 1;
4210       else
4211         return 0;
4212       break;
4213
4214     case 'w':
4215       if (arg[1] == 0)
4216         inhibit_warnings = 1;
4217       else
4218         return 0;
4219       break;
4220
4221     case 'W':
4222       if (arg[1] == 0)
4223         {
4224           extra_warnings = 1;
4225           /* We save the value of warn_uninitialized, since if they put
4226              -Wuninitialized on the command line, we need to generate a
4227              warning about not using it without also specifying -O.  */
4228           if (warn_uninitialized != 1)
4229             warn_uninitialized = 2;
4230         }
4231       else
4232         return decode_W_option (arg + 1);
4233       break;
4234           
4235     case 'a':
4236       if (arg[1] == 0)
4237         {
4238 #if !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
4239           warning ("`-a' option (basic block profile) not supported");
4240 #else
4241           profile_block_flag = (profile_block_flag < 2) ? 1 : 3;
4242 #endif
4243         }
4244       else if (!strcmp (arg, "ax"))
4245         {
4246 #if !defined (FUNCTION_BLOCK_PROFILER_EXIT) || !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
4247           warning ("`-ax' option (jump profiling) not supported");
4248 #else
4249           profile_block_flag = (!profile_block_flag 
4250                                 || profile_block_flag == 2) ? 2 : 3;
4251 #endif
4252         }
4253       else if (!strncmp (arg, "aux-info", 8))
4254         {
4255           flag_gen_aux_info = 1;
4256           if (arg[8] == '\0')
4257             {
4258               if (argc == 1)
4259                 return 0;
4260               
4261               aux_info_file_name = argv[1];
4262               return 2;
4263             }
4264           else
4265             aux_info_file_name = arg + 8;
4266         }
4267       else
4268         return 0;
4269       break;
4270
4271     case 'o':
4272       if (arg[1] == 0)
4273         {
4274           if (argc == 1)
4275             return 0;
4276           
4277           asm_file_name = argv[1];
4278           return 2;
4279         }
4280       return 0;
4281
4282     case 'G':
4283       {
4284         int g_switch_val;
4285         int return_val;
4286             
4287         if (arg[1] == 0)
4288           {
4289             if (argc == 1)
4290               return 0;
4291             
4292             g_switch_val = read_integral_parameter (argv[1], 0, -1);
4293             return_val = 2;
4294           }
4295         else
4296           {
4297             g_switch_val = read_integral_parameter (arg + 1, 0, -1);
4298             return_val = 1;
4299           }
4300             
4301         if (g_switch_val == -1)
4302           return_val = 0;
4303         else
4304           {
4305             g_switch_set = TRUE;
4306             g_switch_value = g_switch_val;
4307           }
4308             
4309         return return_val;
4310       }
4311     }
4312   
4313   return 1;
4314 }
4315 \f
4316 /* Entry point of cc1/c++.  Decode command args, then call compile_file.
4317    Exit code is 35 if can't open files, 34 if fatal error,
4318    33 if had nonfatal errors, else success.  */
4319
4320 extern int main PARAMS ((int, char **));
4321
4322 int
4323 main (argc, argv)