OSDN Git Service

*** empty log message ***
[pf3gnuchains/gcc-fork.git] / gcc / toplev.c
1 /* Top level of GNU C compiler
2    Copyright (C) 1987, 1988, 1989, 1992 Free Software Foundation, Inc.
3
4 This file is part of GNU CC.
5
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING.  If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
19
20
21 /* This is the top level of cc1/c++.
22    It parses command args, opens files, invokes the various passes
23    in the proper order, and counts the time used by each.
24    Error messages and low-level interface to malloc also handled here.  */
25
26 #include "config.h"
27 #include <sys/types.h>
28 #include <stdio.h>
29 #include <signal.h>
30 #include <setjmp.h>
31
32 #include <sys/stat.h>
33
34 #ifdef USG
35 #undef FLOAT
36 #include <sys/param.h>
37 /* This is for hpux.  It is a real screw.  They should change hpux.  */
38 #undef FLOAT
39 #include <sys/times.h>
40 #include <time.h>   /* Correct for hpux at least.  Is it good on other USG?  */
41 #undef FFS  /* Some systems define this in param.h.  */
42 #else
43 #ifndef VMS
44 #include <sys/time.h>
45 #include <sys/resource.h>
46 #endif
47 #endif
48
49 #include "input.h"
50 #include "tree.h"
51 /* #include "c-tree.h" */
52 #include "rtl.h"
53 #include "flags.h"
54 #include "insn-attr.h"
55
56 #ifdef XCOFF_DEBUGGING_INFO
57 #include "xcoffout.h"
58 #endif
59 \f
60 #ifdef VMS
61 /* The extra parameters substantially improve the I/O performance.  */
62 static FILE *
63 VMS_fopen (fname, type)
64      char * fname;
65      char * type;
66 {
67   if (strcmp (type, "w") == 0)
68     return fopen (fname, type, "mbc=16", "deq=64", "fop=tef", "shr=nil");
69   return fopen (fname, type, "mbc=16");
70 }
71 #define fopen VMS_fopen
72 #endif
73
74 #ifndef DEFAULT_GDB_EXTENSIONS
75 #define DEFAULT_GDB_EXTENSIONS 1
76 #endif
77
78 extern int rtx_equal_function_value_matters;
79
80 extern char **environ;
81 extern char *version_string, *language_string;
82
83 extern void init_lex ();
84 extern void init_decl_processing ();
85 extern void init_obstacks ();
86 extern void init_tree_codes ();
87 extern void init_rtl ();
88 extern void init_optabs ();
89 extern void init_stmt ();
90 extern void init_reg_sets ();
91 extern void dump_flow_info ();
92 extern void dump_sched_info ();
93 extern void dump_local_alloc ();
94
95 void rest_of_decl_compilation ();
96 void error ();
97 void error_with_file_and_line ();
98 void fancy_abort ();
99 #ifndef abort
100 void abort ();
101 #endif
102 void set_target_switch ();
103 static void print_switch_values ();
104 static char *decl_name ();
105
106 /* Name of program invoked, sans directories.  */
107
108 char *progname;
109
110 /* Copy of arguments to main.  */
111 int save_argc;
112 char **save_argv;
113 \f
114 /* Name of current original source file (what was input to cpp).
115    This comes from each #-command in the actual input.  */
116
117 char *input_filename;
118
119 /* Name of top-level original source file (what was input to cpp).
120    This comes from the #-command at the beginning of the actual input.
121    If there isn't any there, then this is the cc1 input file name.  */
122
123 char *main_input_filename;
124
125 /* Stream for reading from the input file.  */
126
127 FILE *finput;
128
129 /* Current line number in real source file.  */
130
131 int lineno;
132
133 /* Stack of currently pending input files.  */
134
135 struct file_stack *input_file_stack;
136
137 /* Incremented on each change to input_file_stack.  */
138 int input_file_stack_tick;
139
140 /* FUNCTION_DECL for function now being parsed or compiled.  */
141
142 extern tree current_function_decl;
143
144 /* Name to use as base of names for dump output files.  */
145
146 char *dump_base_name;
147
148 /* Bit flags that specify the machine subtype we are compiling for.
149    Bits are tested using macros TARGET_... defined in the tm.h file
150    and set by `-m...' switches.  Must be defined in rtlanal.c.  */
151
152 extern int target_flags;
153
154 /* Flags saying which kinds of debugging dump have been requested.  */
155
156 int rtl_dump = 0;
157 int rtl_dump_and_exit = 0;
158 int jump_opt_dump = 0;
159 int cse_dump = 0;
160 int loop_dump = 0;
161 int cse2_dump = 0;
162 int flow_dump = 0;
163 int combine_dump = 0;
164 int sched_dump = 0;
165 int local_reg_dump = 0;
166 int global_reg_dump = 0;
167 int sched2_dump = 0;
168 int jump2_opt_dump = 0;
169 int dbr_sched_dump = 0;
170 int flag_print_asm_name = 0;
171 int stack_reg_dump = 0;
172
173 /* Name for output file of assembly code, specified with -o.  */
174
175 char *asm_file_name;
176
177 /* Value of the -G xx switch, and whether it was passed or not.  */
178 int g_switch_value;
179 int g_switch_set;
180
181 /* Type(s) of debugging information we are producing (if any).
182    See flags.h for the definitions of the different possible
183    types of debugging information.  */
184 enum debug_info_type write_symbols = NO_DEBUG;
185
186 /* Level of debugging information we are producing.  See flags.h
187    for the definitions of the different possible levels.  */
188 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
189
190 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
191 /* Nonzero means can use our own extensions to DBX format.
192    Relevant only when write_symbols == DBX_DEBUG or XCOFF_DEBUG.  */
193 int use_gdb_dbx_extensions = 0;
194 #endif
195
196 /* Nonzero means do optimizations.  -O.
197    Particular numeric values stand for particular amounts of optimization;
198    thus, -O2 stores 2 here.  However, the optimizations beyond the basic
199    ones are not controlled directly by this variable.  Instead, they are
200    controlled by individual `flag_...' variables that are defaulted
201    based on this variable.  */
202
203 int optimize = 0;
204
205 /* Number of error messages and warning messages so far.  */
206
207 int errorcount = 0;
208 int warningcount = 0;
209 int sorrycount = 0;
210
211 /* Pointer to function to compute the name to use to print a declaration.  */
212
213 char *(*decl_printable_name) ();
214
215 /* Pointer to function to compute rtl for a language-specific tree code.  */
216
217 struct rtx_def *(*lang_expand_expr) ();
218
219 /* Nonzero if generating code to do profiling.  */
220
221 int profile_flag = 0;
222
223 /* Nonzero if generating code to do profiling on a line-by-line basis.  */
224
225 int profile_block_flag;
226
227 /* Nonzero for -pedantic switch: warn about anything
228    that standard spec forbids.  */
229
230 int pedantic = 0;
231
232 /* Temporarily suppress certain warnings.
233    This is set while reading code from a system header file.  */
234
235 int in_system_header = 0;
236
237 /* Nonzero means do stupid register allocation.
238    Currently, this is 1 if `optimize' is 0.  */
239
240 int obey_regdecls = 0;
241
242 /* Don't print functions as they are compiled and don't print
243    times taken by the various passes.  -quiet.  */
244
245 int quiet_flag = 0;
246 \f
247 /* -f flags.  */
248
249 /* Nonzero means `char' should be signed.  */
250
251 int flag_signed_char;
252
253 /* Nonzero means give an enum type only as many bytes as it needs.  */
254
255 int flag_short_enums;
256
257 /* Nonzero for -fcaller-saves: allocate values in regs that need to
258    be saved across function calls, if that produces overall better code.
259    Optional now, so people can test it.  */
260
261 #ifdef DEFAULT_CALLER_SAVES
262 int flag_caller_saves = 1;
263 #else
264 int flag_caller_saves = 0;
265 #endif
266
267 /* Nonzero for -fpcc-struct-return: return values the same way PCC does.  */
268
269 int flag_pcc_struct_return = 0;
270
271 /* Nonzero for -fforce-mem: load memory value into a register
272    before arithmetic on it.  This makes better cse but slower compilation.  */
273
274 int flag_force_mem = 0;
275
276 /* Nonzero for -fforce-addr: load memory address into a register before
277    reference to memory.  This makes better cse but slower compilation.  */
278
279 int flag_force_addr = 0;
280
281 /* Nonzero for -fdefer-pop: don't pop args after each function call;
282    instead save them up to pop many calls' args with one insns.  */
283
284 int flag_defer_pop = 1;
285
286 /* Nonzero for -ffloat-store: don't allocate floats and doubles
287    in extended-precision registers.  */
288
289 int flag_float_store = 0;
290
291 /* Nonzero for -fcse-follow-jumps:
292    have cse follow jumps to do a more extensive job.  */
293
294 int flag_cse_follow_jumps;
295
296 /* Nonzero for -fcse-skip-blocks:
297    have cse follow a branch around a block.  */
298 int flag_cse_skip_blocks;
299
300 /* Nonzero for -fexpensive-optimizations:
301    perform miscellaneous relatively-expensive optimizations.  */
302 int flag_expensive_optimizations;
303
304 /* Nonzero for -fthread-jumps:
305    have jump optimize output of loop.  */
306
307 int flag_thread_jumps;
308
309 /* Nonzero enables strength-reduction in loop.c.  */
310
311 int flag_strength_reduce = 0;
312
313 /* Nonzero enables loop unrolling in unroll.c.  Only loops for which the
314    number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
315    UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
316    unrolled.  */
317
318 int flag_unroll_loops;
319
320 /* Nonzero enables loop unrolling in unroll.c.  All loops are unrolled.
321    This is generally not a win.  */
322
323 int flag_unroll_all_loops;
324
325 /* Nonzero for -fwritable-strings:
326    store string constants in data segment and don't uniquize them.  */
327
328 int flag_writable_strings = 0;
329
330 /* Nonzero means don't put addresses of constant functions in registers.
331    Used for compiling the Unix kernel, where strange substitutions are
332    done on the assembly output.  */
333
334 int flag_no_function_cse = 0;
335
336 /* Nonzero for -fomit-frame-pointer:
337    don't make a frame pointer in simple functions that don't require one.  */
338
339 int flag_omit_frame_pointer = 0;
340
341 /* Nonzero to inhibit use of define_optimization peephole opts.  */
342
343 int flag_no_peephole = 0;
344
345 /* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math
346    operations in the interest of optimization.  For example it allows
347    GCC to assume arguments to sqrt are nonnegative numbers, allowing
348    faster code for sqrt to be generated. */
349
350 int flag_fast_math = 0;
351
352 /* Nonzero means all references through pointers are volatile.  */
353
354 int flag_volatile;
355
356 /* Nonzero means just do syntax checking; don't output anything.  */
357
358 int flag_syntax_only = 0;
359
360 /* Nonzero means to rerun cse after loop optimization.  This increases
361    compilation time about 20% and picks up a few more common expressions.  */
362
363 static int flag_rerun_cse_after_loop;
364
365 /* Nonzero for -finline-functions: ok to inline functions that look like
366    good inline candidates.  */
367
368 int flag_inline_functions;
369
370 /* Nonzero for -fkeep-inline-functions: even if we make a function
371    go inline everywhere, keep its defintion around for debugging
372    purposes.  */
373
374 int flag_keep_inline_functions;
375
376 /* Nonzero means that functions declared `inline' will be treated
377    as `static'.  Prevents generation of zillions of copies of unused
378    static inline functions; instead, `inlines' are written out
379    only when actually used.  Used in conjunction with -g.  Also
380    does the right thing with #pragma interface.  */
381
382 int flag_no_inline;
383
384 /* Nonzero means we should be saving declaration info into a .X file.  */
385
386 int flag_gen_aux_info = 0;
387
388 /* Specified name of aux-info file.  */
389
390 static char *aux_info_file_name;
391
392 /* Nonzero means make the text shared if supported.  */
393
394 int flag_shared_data;
395
396 /* Nonzero means schedule into delayed branch slots if supported.  */
397
398 int flag_delayed_branch;
399
400 /* Nonzero if we are compiling pure (sharable) code.
401    Value is 1 if we are doing reasonable (i.e. simple
402    offset into offset table) pic.  Value is 2 if we can
403    only perform register offsets.  */
404
405 int flag_pic;
406
407 /* Nonzero means place uninitialized global data in the bss section. */
408
409 int flag_no_common;
410
411 /* Nonzero means pretend it is OK to examine bits of target floats,
412    even if that isn't true.  The resulting code will have incorrect constants,
413    but the same series of instructions that the native compiler would make.  */
414
415 int flag_pretend_float;
416
417 /* Nonzero means change certain warnings into errors.
418    Usually these are warnings about failure to conform to some standard.  */
419
420 int flag_pedantic_errors = 0;
421
422 /* flag_schedule_insns means schedule insns within basic blocks (before
423    local_alloc).
424    flag_schedule_insns_after_reload means schedule insns after
425    global_alloc.  */
426
427 int flag_schedule_insns = 0;
428 int flag_schedule_insns_after_reload = 0;
429
430 /* -finhibit-size-directive inhibits output of .size for ELF.
431    This is used only for compiling crtstuff.c, 
432    and it may be extended to other effects
433    needed for crtstuff.c on other systems.  */
434 int flag_inhibit_size_directive = 0;
435
436 /* -fverbose-asm causes extra commentary information to be produced in
437    the generated assembly code (to make it more readable).  This option
438    is generally only of use to those who actually need to read the
439    generated assembly code (perhaps while debugging the compiler itself).  */
440
441 int flag_verbose_asm = 0;
442
443 /* -fgnu-linker specifies use of the GNU linker for initializations.
444    (Or, more generally, a linker that handles initializations.)
445    -fno-gnu-linker says that collect2 will be used.  */
446 #ifdef USE_COLLECT2
447 int flag_gnu_linker = 0;
448 #else
449 int flag_gnu_linker = 1;
450 #endif
451
452 /* Table of language-independent -f options.
453    STRING is the option name.  VARIABLE is the address of the variable.
454    ON_VALUE is the value to store in VARIABLE
455     if `-fSTRING' is seen as an option.
456    (If `-fno-STRING' is seen as an option, the opposite value is stored.)  */
457
458 struct { char *string; int *variable; int on_value;} f_options[] =
459 {
460   {"float-store", &flag_float_store, 1},
461   {"volatile", &flag_volatile, 1},
462   {"defer-pop", &flag_defer_pop, 1},
463   {"omit-frame-pointer", &flag_omit_frame_pointer, 1},
464   {"cse-follow-jumps", &flag_cse_follow_jumps, 1},
465   {"cse-skip-blocks", &flag_cse_skip_blocks, 1},
466   {"expensive-optimizations", &flag_expensive_optimizations, 1},
467   {"thread-jumps", &flag_thread_jumps, 1},
468   {"strength-reduce", &flag_strength_reduce, 1},
469   {"unroll-loops", &flag_unroll_loops, 1},
470   {"unroll-all-loops", &flag_unroll_all_loops, 1},
471   {"writable-strings", &flag_writable_strings, 1},
472   {"peephole", &flag_no_peephole, 0},
473   {"force-mem", &flag_force_mem, 1},
474   {"force-addr", &flag_force_addr, 1},
475   {"function-cse", &flag_no_function_cse, 0},
476   {"inline-functions", &flag_inline_functions, 1},
477   {"keep-inline-functions", &flag_keep_inline_functions, 1},
478   {"inline", &flag_no_inline, 0},
479   {"syntax-only", &flag_syntax_only, 1},
480   {"shared-data", &flag_shared_data, 1},
481   {"caller-saves", &flag_caller_saves, 1},
482   {"pcc-struct-return", &flag_pcc_struct_return, 1},
483   {"delayed-branch", &flag_delayed_branch, 1},
484   {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1},
485   {"pretend-float", &flag_pretend_float, 1},
486   {"schedule-insns", &flag_schedule_insns, 1},
487   {"schedule-insns2", &flag_schedule_insns_after_reload, 1},
488   {"pic", &flag_pic, 1},
489   {"PIC", &flag_pic, 2},
490   {"fast-math", &flag_fast_math, 1},
491   {"common", &flag_no_common, 0},
492   {"inhibit-size-directive", &flag_inhibit_size_directive, 1},
493   {"verbose-asm", &flag_verbose_asm, 1},
494   {"gnu-linker", &flag_gnu_linker, 1}
495 };
496 \f
497 /* Options controlling warnings */
498
499 /* Don't print warning messages.  -w.  */
500
501 int inhibit_warnings = 0;
502
503 /* Print various extra warnings.  -W.  */
504
505 int extra_warnings = 0;
506
507 /* Treat warnings as errors.  -Werror.  */
508
509 int warnings_are_errors = 0;
510
511 /* Nonzero to warn about unused local variables.  */
512
513 int warn_unused;
514
515 /* Nonzero to warn about variables used before they are initialized.  */
516
517 int warn_uninitialized;
518
519 /* Nonzero means warn about all declarations which shadow others.   */
520
521 int warn_shadow;
522
523 /* Warn if a switch on an enum fails to have a case for every enum value.  */
524
525 int warn_switch;
526
527 /* Nonzero means warn about function definitions that default the return type
528    or that use a null return and have a return-type other than void.  */
529
530 int warn_return_type;
531
532 /* Nonzero means warn about pointer casts that increase the required
533    alignment of the target type (and might therefore lead to a crash
534    due to a misaligned access).  */
535
536 int warn_cast_align;
537
538 /* Nonzero means warn about any identifiers that match in the first N
539    characters.  The value N is in `id_clash_len'.  */
540
541 int warn_id_clash;
542 int id_clash_len;
543
544 /* Nonzero means warn if inline function is too large.  */
545
546 int warn_inline;
547
548 /* Warn if a function returns an aggregate,
549    since there are often incompatible calling conventions for doing this.  */
550
551 int warn_aggregate_return;
552
553 /* Likewise for -W.  */
554
555 struct { char *string; int *variable; int on_value;} W_options[] =
556 {
557   {"unused", &warn_unused, 1},
558   {"error", &warnings_are_errors, 1},
559   {"shadow", &warn_shadow, 1},
560   {"switch", &warn_switch, 1},
561   {"return-type", &warn_return_type, 1},
562   {"aggregate-return", &warn_aggregate_return, 1},
563   {"cast-align", &warn_cast_align, 1},
564   {"uninitialized", &warn_uninitialized, 1},
565   {"inline", &warn_inline, 1}
566 };
567 \f
568 /* Output files for assembler code (real compiler output)
569    and debugging dumps.  */
570
571 FILE *asm_out_file;
572 FILE *aux_info_file;
573 FILE *rtl_dump_file;
574 FILE *jump_opt_dump_file;
575 FILE *cse_dump_file;
576 FILE *loop_dump_file;
577 FILE *cse2_dump_file;
578 FILE *flow_dump_file;
579 FILE *combine_dump_file;
580 FILE *sched_dump_file;
581 FILE *local_reg_dump_file;
582 FILE *global_reg_dump_file;
583 FILE *sched2_dump_file;
584 FILE *jump2_opt_dump_file;
585 FILE *dbr_sched_dump_file;
586 FILE *stack_reg_dump_file;
587
588 /* Time accumulators, to count the total time spent in various passes.  */
589
590 int parse_time;
591 int varconst_time;
592 int integration_time;
593 int jump_time;
594 int cse_time;
595 int loop_time;
596 int cse2_time;
597 int flow_time;
598 int combine_time;
599 int sched_time;
600 int local_alloc_time;
601 int global_alloc_time;
602 int sched2_time;
603 int dbr_sched_time;
604 int shorten_branch_time;
605 int stack_reg_time;
606 int final_time;
607 int symout_time;
608 int dump_time;
609 \f
610 /* Return time used so far, in microseconds.  */
611
612 int
613 get_run_time ()
614 {
615 #ifdef USG
616   struct tms tms;
617 #else
618 #ifndef VMS
619   struct rusage rusage;
620 #else /* VMS */
621   struct
622     {
623       int proc_user_time;
624       int proc_system_time;
625       int child_user_time;
626       int child_system_time;
627     } vms_times;
628 #endif
629 #endif
630
631   if (quiet_flag)
632     return 0;
633
634 #ifdef USG
635   times (&tms);
636   return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
637 #else
638 #ifndef VMS
639   getrusage (0, &rusage);
640   return (rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec
641           + rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec);
642 #else /* VMS */
643   times (&vms_times);
644   return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
645 #endif
646 #endif
647 }
648
649 #define TIMEVAR(VAR, BODY)    \
650 do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
651
652 void
653 print_time (str, total)
654      char *str;
655      int total;
656 {
657   fprintf (stderr,
658            "time in %s: %d.%06d\n",
659            str, total / 1000000, total % 1000000);
660 }
661
662 /* Count an error or warning.  Return 1 if the message should be printed.  */
663
664 int
665 count_error (warningp)
666      int warningp;
667 {
668   if (warningp && inhibit_warnings)
669     return 0;
670
671   if (warningp && !warnings_are_errors)
672     warningcount++;
673   else
674     {
675       static int warning_message = 0;
676
677       if (warningp && !warning_message)
678         {
679           fprintf (stderr, "%s: warnings being treated as errors\n", progname);
680           warning_message = 1;
681         }
682       errorcount++;
683     }
684
685   return 1;
686 }
687
688 /* Print a fatal error message.  NAME is the text.
689    Also include a system error message based on `errno'.  */
690
691 void
692 pfatal_with_name (name)
693      char *name;
694 {
695   fprintf (stderr, "%s: ", progname);
696   perror (name);
697   exit (35);
698 }
699
700 void
701 fatal_io_error (name)
702      char *name;
703 {
704   fprintf (stderr, "%s: %s: I/O error\n", progname, name);
705   exit (35);
706 }
707
708 void
709 fatal (s, v)
710      char *s;
711      int v;
712 {
713   error (s, v);
714   exit (34);
715 }
716
717 /* Called to give a better error message when we don't have an insn to match
718    what we are looking for or if the insn's constraints aren't satisfied,
719    rather than just calling abort().  */
720
721 void
722 fatal_insn_not_found (insn)
723      rtx insn;
724 {
725   if (INSN_CODE (insn) < 0)
726     error ("internal error--unrecognizable insn:", 0);
727   else
728     error ("internal error--insn does not satisfy its constraints:", 0);
729   debug_rtx (insn);
730   if (asm_out_file)
731     fflush (asm_out_file);
732   if (aux_info_file)
733     fflush (aux_info_file);
734   if (rtl_dump_file)
735     fflush (rtl_dump_file);
736   if (jump_opt_dump_file)
737     fflush (jump_opt_dump_file);
738   if (cse_dump_file)
739     fflush (cse_dump_file);
740   if (loop_dump_file)
741     fflush (loop_dump_file);
742   if (cse2_dump_file)
743     fflush (cse2_dump_file);
744   if (flow_dump_file)
745     fflush (flow_dump_file);
746   if (combine_dump_file)
747     fflush (combine_dump_file);
748   if (sched_dump_file)
749     fflush (sched_dump_file);
750   if (local_reg_dump_file)
751     fflush (local_reg_dump_file);
752   if (global_reg_dump_file)
753     fflush (global_reg_dump_file);
754   if (sched2_dump_file)
755     fflush (sched2_dump_file);
756   if (jump2_opt_dump_file)
757     fflush (jump2_opt_dump_file);
758   if (dbr_sched_dump_file)
759     fflush (dbr_sched_dump_file);
760   if (stack_reg_dump_file)
761     fflush (stack_reg_dump_file);
762   abort ();
763 }
764
765 /* This is the default decl_printable_name function.  */
766
767 static char *
768 decl_name (decl, kind)
769      tree decl;
770      char **kind;
771 {
772   return IDENTIFIER_POINTER (DECL_NAME (decl));
773 }
774 \f
775 static int need_error_newline;
776
777 /* Function of last error message;
778    more generally, function such that if next error message is in it
779    then we don't have to mention the function name.  */
780 static tree last_error_function = NULL;
781
782 /* Used to detect when input_file_stack has changed since last described.  */
783 static int last_error_tick;
784
785 /* Called when the start of a function definition is parsed,
786    this function prints on stderr the name of the function.  */
787
788 void
789 announce_function (decl)
790      tree decl;
791 {
792   if (! quiet_flag)
793     {
794       char *junk;
795       if (rtl_dump_and_exit)
796         fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
797       else
798         fprintf (stderr, " %s", (*decl_printable_name) (decl, &junk));
799       fflush (stderr);
800       need_error_newline = 1;
801       last_error_function = current_function_decl;
802     }
803 }
804
805 /* Prints out, if necessary, the name of the current function
806    which caused an error.  Called from all error and warning functions.  */
807
808 void
809 report_error_function (file)
810      char *file;
811 {
812   struct file_stack *p;
813
814   if (need_error_newline)
815     {
816       fprintf (stderr, "\n");
817       need_error_newline = 0;
818     }
819
820   if (last_error_function != current_function_decl)
821     {
822       char *kind = "function";
823       if (current_function_decl != 0
824           && TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
825         kind = "method";
826
827       if (file)
828         fprintf (stderr, "%s: ", file);
829
830       if (current_function_decl == NULL)
831         fprintf (stderr, "At top level:\n");
832       else
833         {
834           char *name = (*decl_printable_name) (current_function_decl, &kind);
835           fprintf (stderr, "In %s `%s':\n", kind, name);
836         }
837
838       last_error_function = current_function_decl;
839     }
840   if (input_file_stack && input_file_stack->next != 0
841       && input_file_stack_tick != last_error_tick)
842     {
843       fprintf (stderr, "In file included");
844       for (p = input_file_stack->next; p; p = p->next)
845         {
846           fprintf (stderr, " from %s:%d", p->name, p->line);
847           if (p->next)
848             fprintf (stderr, ",");
849         }
850       fprintf (stderr, ":\n");
851       last_error_tick = input_file_stack_tick;
852     }
853 }
854
855 /* Report an error at the current line number.
856    S and V are a string and an arg for `printf'.  */
857
858 void
859 error (s, v, v2)
860      char *s;
861      int v;                     /* @@also used as pointer */
862      int v2;                    /* @@also used as pointer */
863 {
864   error_with_file_and_line (input_filename, lineno, s, v, v2);
865 }
866
867 /* Report an error at line LINE of file FILE.
868    S and V are a string and an arg for `printf'.  */
869
870 void
871 error_with_file_and_line (file, line, s, v, v2)
872      char *file;
873      int line;
874      char *s;
875      int v;
876      int v2;
877 {
878   count_error (0);
879
880   report_error_function (file);
881
882   if (file)
883     fprintf (stderr, "%s:%d: ", file, line);
884   else
885     fprintf (stderr, "%s: ", progname);
886   fprintf (stderr, s, v, v2);
887   fprintf (stderr, "\n");
888 }
889
890 /* Report an error at the declaration DECL.
891    S and V are a string and an arg which uses %s to substitute the declaration name.  */
892
893 void
894 error_with_decl (decl, s, v)
895      tree decl;
896      char *s;
897      int v;
898 {
899   char *junk;
900   count_error (0);
901
902   report_error_function (DECL_SOURCE_FILE (decl));
903
904   fprintf (stderr, "%s:%d: ",
905            DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
906
907   if (DECL_NAME (decl))
908     fprintf (stderr, s, (*decl_printable_name) (decl, &junk), v);
909   else
910     fprintf (stderr, s, "((anonymous))", v);
911   fprintf (stderr, "\n");
912 }
913
914 /* Report an error at the line number of the insn INSN.
915    S and V are a string and an arg for `printf'.
916    This is used only when INSN is an `asm' with operands,
917    and each ASM_OPERANDS records its own source file and line.  */
918
919 void
920 error_for_asm (insn, s, v, v2)
921      rtx insn;
922      char *s;
923      int v;                     /* @@also used as pointer */
924      int v2;                    /* @@also used as pointer */
925 {
926   char *filename;
927   int line;
928   rtx body = PATTERN (insn);
929   rtx asmop;
930
931   /* Find the (or one of the) ASM_OPERANDS in the insn.  */
932   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
933     asmop = SET_SRC (body);
934   else if (GET_CODE (body) == ASM_OPERANDS)
935     asmop = body;
936   else if (GET_CODE (body) == PARALLEL
937            && GET_CODE (XVECEXP (body, 0, 0)) == SET)
938     asmop = SET_SRC (XVECEXP (body, 0, 0));
939   else if (GET_CODE (body) == PARALLEL
940            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
941     asmop = XVECEXP (body, 0, 0);
942
943   filename = ASM_OPERANDS_SOURCE_FILE (asmop);
944   line = ASM_OPERANDS_SOURCE_LINE (asmop);
945
946   error_with_file_and_line (filename, line, s, v, v2);
947 }
948
949 /* Report a warning at line LINE.
950    S and V are a string and an arg for `printf'.  */
951
952 void
953 warning_with_file_and_line (file, line, s, v, v2, v3)
954      char *file;
955      int line;
956      char *s;
957      int v;
958      int v2;
959      int v3;
960 {
961   if (count_error (1) == 0)
962     return;
963
964   report_error_function (file);
965
966   if (file)
967     fprintf (stderr, "%s:%d: ", file, line);
968   else
969     fprintf (stderr, "%s: ", progname);
970
971   fprintf (stderr, "warning: ");
972   fprintf (stderr, s, v, v2, v3);
973   fprintf (stderr, "\n");
974 }
975
976 /* Report a warning at the current line number.
977    S and V are a string and an arg for `printf'.  */
978
979 void
980 warning (s, v, v2, v3)
981      char *s;
982      int v;                     /* @@also used as pointer */
983      int v2;
984      int v3;
985 {
986   warning_with_file_and_line (input_filename, lineno, s, v, v2, v3);
987 }
988
989 /* Report a warning at the declaration DECL.
990    S is string which uses %s to substitute the declaration name.
991    V is a second parameter that S can refer to.  */
992
993 void
994 warning_with_decl (decl, s, v)
995      tree decl;
996      char *s;
997      int v;
998 {
999   char *junk;
1000
1001   if (count_error (1) == 0)
1002     return;
1003
1004   report_error_function (DECL_SOURCE_FILE (decl));
1005
1006   fprintf (stderr, "%s:%d: ",
1007            DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
1008
1009   fprintf (stderr, "warning: ");
1010   if (DECL_NAME (decl))
1011     fprintf (stderr, s, (*decl_printable_name) (decl, &junk), v);
1012   else
1013     fprintf (stderr, s, "((anonymous))", v);
1014   fprintf (stderr, "\n");
1015 }
1016
1017 /* Report a warning at the line number of the insn INSN.
1018    S and V are a string and an arg for `printf'.
1019    This is used only when INSN is an `asm' with operands,
1020    and each ASM_OPERANDS records its own source file and line.  */
1021
1022 void
1023 warning_for_asm (insn, s, v, v2)
1024      rtx insn;
1025      char *s;
1026      int v;                     /* @@also used as pointer */
1027      int v2;                    /* @@also used as pointer */
1028 {
1029   char *filename;
1030   int line;
1031   rtx body = PATTERN (insn);
1032   rtx asmop;
1033
1034   /* Find the (or one of the) ASM_OPERANDS in the insn.  */
1035   if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
1036     asmop = SET_SRC (body);
1037   else if (GET_CODE (body) == ASM_OPERANDS)
1038     asmop = body;
1039   else if (GET_CODE (body) == PARALLEL
1040            && GET_CODE (XVECEXP (body, 0, 0)) == SET)
1041     asmop = SET_SRC (XVECEXP (body, 0, 0));
1042   else if (GET_CODE (body) == PARALLEL
1043            && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
1044     asmop = XVECEXP (body, 0, 0);
1045
1046   filename = ASM_OPERANDS_SOURCE_FILE (asmop);
1047   line = ASM_OPERANDS_SOURCE_LINE (asmop);
1048
1049   warning_with_file_and_line (filename, line, s, v, v2);
1050 }
1051 \f
1052 /* These functions issue either warnings or errors depending on
1053    -pedantic-errors.  */
1054
1055 void
1056 pedwarn (s, v, v2)
1057      char *s;
1058      int v;                     /* @@also used as pointer */
1059      int v2;
1060 {
1061   if (flag_pedantic_errors)
1062     error (s, v, v2);
1063   else
1064     warning (s, v, v2);
1065 }
1066
1067 void
1068 pedwarn_with_decl (decl, s, v)
1069      tree decl;
1070      char *s;
1071      int v;
1072 {
1073   if (flag_pedantic_errors)
1074     error_with_decl (decl, s, v);
1075   else
1076     warning_with_decl (decl, s, v);
1077 }
1078
1079 void
1080 pedwarn_with_file_and_line (file, line, s, v, v2)
1081      char *file;
1082      int line;
1083      char *s;
1084      int v;
1085      int v2;
1086 {
1087   if (flag_pedantic_errors)
1088     error_with_file_and_line (file, line, s, v, v2);
1089   else
1090     warning_with_file_and_line (file, line, s, v, v2);
1091 }
1092
1093 /* Apologize for not implementing some feature.
1094    S, V, and V2 are a string and args for `printf'.  */
1095
1096 void
1097 sorry (s, v, v2)
1098      char *s;
1099      int v, v2;
1100 {
1101   sorrycount++;
1102   if (input_filename)
1103     fprintf (stderr, "%s:%d: ", input_filename, lineno);
1104   else
1105     fprintf (stderr, "%s: ", progname);
1106
1107   fprintf (stderr, "sorry, not implemented: ");
1108   fprintf (stderr, s, v, v2);
1109   fprintf (stderr, "\n");
1110 }
1111
1112 /* Apologize for not implementing some feature, then quit.
1113    S, V, and V2 are a string and args for `printf'.  */
1114
1115 void
1116 really_sorry (s, v, v2)
1117      char *s;
1118      int v, v2;
1119 {
1120   if (input_filename)
1121     fprintf (stderr, "%s:%d: ", input_filename, lineno);
1122   else
1123     fprintf (stderr, "c++: ");
1124
1125   fprintf (stderr, "sorry, not implemented: ");
1126   fprintf (stderr, s, v, v2);
1127   fatal (" (fatal)\n");
1128 }
1129 \f
1130 /* More 'friendly' abort that prints the line and file.
1131    config.h can #define abort fancy_abort if you like that sort of thing.
1132
1133    I don't think this is actually a good idea.
1134    Other sorts of crashes will look a certain way.
1135    It is a good thing if crashes from calling abort look the same way.
1136      -- RMS  */
1137
1138 void
1139 fancy_abort ()
1140 {
1141   fatal ("internal gcc abort");
1142 }
1143
1144 /* This calls abort and is used to avoid problems when abort if a macro.
1145    It is used when we need to pass the address of abort.  */
1146
1147 void
1148 do_abort ()
1149 {
1150   abort ();
1151 }
1152
1153 /* When `malloc.c' is compiled with `rcheck' defined,
1154    it calls this function to report clobberage.  */
1155
1156 void
1157 botch (s)
1158 {
1159   abort ();
1160 }
1161
1162 /* Same as `malloc' but report error if no memory available.  */
1163
1164 int
1165 xmalloc (size)
1166      unsigned size;
1167 {
1168   register int value = (int) malloc (size);
1169   if (value == 0)
1170     fatal ("virtual memory exhausted");
1171   return value;
1172 }
1173
1174 /* Same as `realloc' but report error if no memory available.  */
1175
1176 int
1177 xrealloc (ptr, size)
1178      char *ptr;
1179      int size;
1180 {
1181   int result = realloc (ptr, size);
1182   if (!result)
1183     fatal ("virtual memory exhausted");
1184   return result;
1185 }
1186 \f
1187 /* Return the logarithm of X, base 2, considering X unsigned,
1188    if X is a power of 2.  Otherwise, returns -1.  */
1189
1190 int
1191 exact_log2 (x)
1192      register unsigned int x;
1193 {
1194   register int log = 0;
1195   /* Test for 0 or a power of 2.  */
1196   if (x == 0 || x != (x & -x))
1197     return -1;
1198   while ((x >>= 1) != 0)
1199     log++;
1200   return log;
1201 }
1202
1203 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1204    If X is 0, return -1.  */
1205
1206 int
1207 floor_log2 (x)
1208      register unsigned int x;
1209 {
1210   register int log = -1;
1211   while (x != 0)
1212     log++,
1213     x >>= 1;
1214   return log;
1215 }
1216
1217 int float_handled;
1218 jmp_buf float_handler;
1219
1220 /* Specify where to longjmp to when a floating arithmetic error happens.
1221    If HANDLER is 0, it means don't handle the errors any more.  */
1222
1223 void
1224 set_float_handler (handler)
1225      jmp_buf handler;
1226 {
1227   float_handled = (handler != 0);
1228   if (handler)
1229     bcopy (handler, float_handler, sizeof (float_handler));
1230 }
1231
1232 /* Signals actually come here.  */
1233
1234 static void
1235 float_signal (signo)
1236      /* If this is missing, some compilers complain.  */
1237      int signo;
1238 {
1239   if (float_handled == 0)
1240     abort ();
1241 #if defined (USG) || defined (hpux)
1242   signal (SIGFPE, float_signal);  /* re-enable the signal catcher */
1243 #endif
1244   float_handled = 0;
1245   signal (SIGFPE, float_signal);
1246   longjmp (float_handler, 1);
1247 }
1248
1249 /* Handler for SIGPIPE.  */
1250
1251 static void
1252 pipe_closed (signo)
1253      /* If this is missing, some compilers complain.  */
1254      int signo;
1255 {
1256   fatal ("output pipe has been closed");
1257 }
1258
1259 /* Strip off a legitimate source ending from the input string NAME of
1260    length LEN. */
1261
1262 void
1263 strip_off_ending (name, len)
1264      char *name;
1265      int len;
1266 {
1267   if (len > 2 && ! strcmp (".c", name + len - 2))
1268     name[len - 2] = 0;
1269   else if (len > 2 && ! strcmp (".m", name + len - 2))
1270     name[len - 2] = 0;
1271   else if (len > 2 && ! strcmp (".i", name + len - 2))
1272     name[len - 2] = 0;
1273   else if (len > 3 && ! strcmp (".ii", name + len - 3))
1274     name[len - 3] = 0;
1275   else if (len > 3 && ! strcmp (".co", name + len - 3))
1276     name[len - 3] = 0;
1277   else if (len > 3 && ! strcmp (".cc", name + len - 3))
1278     name[len - 3] = 0;
1279   else if (len > 2 && ! strcmp (".f", name + len - 2))
1280     name[len - 2] = 0;
1281   else if (len > 4 && ! strcmp (".ada", name + len - 4))
1282     name[len - 4] = 0;
1283 }
1284
1285 /* Output a file name in the form wanted by System V.  */
1286
1287 void
1288 output_file_directive (asm_file, input_name)
1289      FILE *asm_file;
1290      char *input_name;
1291 {
1292   int len = strlen (input_name);
1293   char *na = input_name + len;
1294
1295   /* NA gets INPUT_NAME sans directory names.  */
1296   while (na > input_name)
1297     {
1298       if (na[-1] == '/')
1299         break;
1300       na--;
1301     }
1302
1303 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
1304   ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
1305 #else
1306 #ifdef ASM_OUTPUT_SOURCE_FILENAME
1307   ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
1308 #else
1309   fprintf (asm_file, "\t.file\t\"%s\"\n", na);
1310 #endif
1311 #endif
1312 }
1313 \f
1314 /* Compile an entire file of output from cpp, named NAME.
1315    Write a file of assembly output and various debugging dumps.  */
1316
1317 static void
1318 compile_file (name)
1319      char *name;
1320 {
1321   tree globals;
1322   int start_time;
1323   int dump_base_name_length;
1324
1325   int name_specified = name != 0;
1326
1327   if (dump_base_name == 0)
1328     dump_base_name = name ? name : "gccdump";
1329   dump_base_name_length = strlen (dump_base_name);
1330
1331   parse_time = 0;
1332   varconst_time = 0;
1333   integration_time = 0;
1334   jump_time = 0;
1335   cse_time = 0;
1336   loop_time = 0;
1337   cse2_time = 0;
1338   flow_time = 0;
1339   combine_time = 0;
1340   sched_time = 0;
1341   local_alloc_time = 0;
1342   global_alloc_time = 0;
1343   sched2_time = 0;
1344   dbr_sched_time = 0;
1345   shorten_branch_time = 0;
1346   stack_reg_time = 0;
1347   final_time = 0;
1348   symout_time = 0;
1349   dump_time = 0;
1350
1351   /* Open input file.  */
1352
1353   if (name == 0 || !strcmp (name, "-"))
1354     {
1355       finput = stdin;
1356       name = "stdin";
1357     }
1358   else
1359     finput = fopen (name, "r");
1360   if (finput == 0)
1361     pfatal_with_name (name);
1362
1363 #ifdef IO_BUFFER_SIZE
1364   setvbuf (finput, xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
1365 #endif
1366
1367   /* Initialize data in various passes.  */
1368
1369   init_obstacks ();
1370   init_tree_codes ();
1371   init_lex ();
1372   init_rtl ();
1373   init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
1374                   || debug_info_level == DINFO_LEVEL_VERBOSE);
1375   init_decl_processing ();
1376   init_optabs ();
1377   init_stmt ();
1378   init_expmed ();
1379   init_loop ();
1380   init_reload ();
1381
1382   if (flag_caller_saves)
1383     init_caller_save ();
1384
1385   /* If auxiliary info generation is desired, open the output file.
1386      This goes in the same directory as the source file--unlike
1387      all the other output files.  */
1388   if (flag_gen_aux_info)
1389     {
1390       aux_info_file = fopen (aux_info_file_name, "w");
1391       if (aux_info_file == 0)
1392         pfatal_with_name (aux_info_file_name);
1393     }
1394
1395   /* If rtl dump desired, open the output file.  */
1396   if (rtl_dump)
1397     {
1398       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1399       strcpy (dumpname, dump_base_name);
1400       strcat (dumpname, ".rtl");
1401       rtl_dump_file = fopen (dumpname, "w");
1402       if (rtl_dump_file == 0)
1403         pfatal_with_name (dumpname);
1404     }
1405
1406   /* If jump_opt dump desired, open the output file.  */
1407   if (jump_opt_dump)
1408     {
1409       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1410       strcpy (dumpname, dump_base_name);
1411       strcat (dumpname, ".jump");
1412       jump_opt_dump_file = fopen (dumpname, "w");
1413       if (jump_opt_dump_file == 0)
1414         pfatal_with_name (dumpname);
1415     }
1416
1417   /* If cse dump desired, open the output file.  */
1418   if (cse_dump)
1419     {
1420       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1421       strcpy (dumpname, dump_base_name);
1422       strcat (dumpname, ".cse");
1423       cse_dump_file = fopen (dumpname, "w");
1424       if (cse_dump_file == 0)
1425         pfatal_with_name (dumpname);
1426     }
1427
1428   /* If loop dump desired, open the output file.  */
1429   if (loop_dump)
1430     {
1431       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1432       strcpy (dumpname, dump_base_name);
1433       strcat (dumpname, ".loop");
1434       loop_dump_file = fopen (dumpname, "w");
1435       if (loop_dump_file == 0)
1436         pfatal_with_name (dumpname);
1437     }
1438
1439   /* If cse2 dump desired, open the output file.  */
1440   if (cse2_dump)
1441     {
1442       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1443       strcpy (dumpname, dump_base_name);
1444       strcat (dumpname, ".cse2");
1445       cse2_dump_file = fopen (dumpname, "w");
1446       if (cse2_dump_file == 0)
1447         pfatal_with_name (dumpname);
1448     }
1449
1450   /* If flow dump desired, open the output file.  */
1451   if (flow_dump)
1452     {
1453       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1454       strcpy (dumpname, dump_base_name);
1455       strcat (dumpname, ".flow");
1456       flow_dump_file = fopen (dumpname, "w");
1457       if (flow_dump_file == 0)
1458         pfatal_with_name (dumpname);
1459     }
1460
1461   /* If combine dump desired, open the output file.  */
1462   if (combine_dump)
1463     {
1464       register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
1465       strcpy (dumpname, dump_base_name);
1466       strcat (dumpname, ".combine");
1467       combine_dump_file = fopen (dumpname, "w");
1468       if (combine_dump_file == 0)
1469         pfatal_with_name (dumpname);
1470     }
1471
1472   /* If scheduling dump desired, open the output file.  */
1473   if (sched_dump)
1474     {
1475       register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
1476       strcpy (dumpname, dump_base_name);
1477       strcat (dumpname, ".sched");
1478       sched_dump_file = fopen (dumpname, "w");
1479       if (sched_dump_file == 0)
1480         pfatal_with_name (dumpname);
1481     }
1482
1483   /* If local_reg dump desired, open the output file.  */
1484   if (local_reg_dump)
1485     {
1486       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1487       strcpy (dumpname, dump_base_name);
1488       strcat (dumpname, ".lreg");
1489       local_reg_dump_file = fopen (dumpname, "w");
1490       if (local_reg_dump_file == 0)
1491         pfatal_with_name (dumpname);
1492     }
1493
1494   /* If global_reg dump desired, open the output file.  */
1495   if (global_reg_dump)
1496     {
1497       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1498       strcpy (dumpname, dump_base_name);
1499       strcat (dumpname, ".greg");
1500       global_reg_dump_file = fopen (dumpname, "w");
1501       if (global_reg_dump_file == 0)
1502         pfatal_with_name (dumpname);
1503     }
1504
1505   /* If 2nd scheduling dump desired, open the output file.  */
1506   if (sched2_dump)
1507     {
1508       register char *dumpname = (char *) xmalloc (dump_base_name_length + 8);
1509       strcpy (dumpname, dump_base_name);
1510       strcat (dumpname, ".sched2");
1511       sched2_dump_file = fopen (dumpname, "w");
1512       if (sched2_dump_file == 0)
1513         pfatal_with_name (dumpname);
1514     }
1515
1516   /* If jump2_opt dump desired, open the output file.  */
1517   if (jump2_opt_dump)
1518     {
1519       register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
1520       strcpy (dumpname, dump_base_name);
1521       strcat (dumpname, ".jump2");
1522       jump2_opt_dump_file = fopen (dumpname, "w");
1523       if (jump2_opt_dump_file == 0)
1524         pfatal_with_name (dumpname);
1525     }
1526
1527   /* If dbr_sched dump desired, open the output file.  */
1528   if (dbr_sched_dump)
1529     {
1530       register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
1531       strcpy (dumpname, dump_base_name);
1532       strcat (dumpname, ".dbr");
1533       dbr_sched_dump_file = fopen (dumpname, "w");
1534       if (dbr_sched_dump_file == 0)
1535         pfatal_with_name (dumpname);
1536     }
1537
1538 #ifdef STACK_REGS
1539
1540   /* If stack_reg dump desired, open the output file.  */
1541   if (stack_reg_dump)
1542     {
1543       register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
1544       strcpy (dumpname, dump_base_name);
1545       strcat (dumpname, ".stack");
1546       stack_reg_dump_file = fopen (dumpname, "w");
1547       if (stack_reg_dump_file == 0)
1548         pfatal_with_name (dumpname);
1549     }
1550
1551 #endif
1552
1553   /* Open assembler code output file.  */
1554
1555   if (! name_specified && asm_file_name == 0)
1556     asm_out_file = stdout;
1557   else
1558     {
1559       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1560       int len = strlen (dump_base_name);
1561       strcpy (dumpname, dump_base_name);
1562       strip_off_ending (dumpname, len);
1563       strcat (dumpname, ".s");
1564       if (asm_file_name == 0)
1565         {
1566           asm_file_name = (char *) xmalloc (strlen (dumpname) + 1);
1567           strcpy (asm_file_name, dumpname);
1568         }
1569       if (!strcmp (asm_file_name, "-"))
1570         asm_out_file = stdout;
1571       else
1572         asm_out_file = fopen (asm_file_name, "w");
1573       if (asm_out_file == 0)
1574         pfatal_with_name (asm_file_name);
1575     }
1576
1577 #ifdef IO_BUFFER_SIZE
1578   setvbuf (asm_out_file, xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
1579 #endif
1580
1581   input_filename = name;
1582
1583   /* Perform language-specific initialization.
1584      This may set main_input_filename.  */
1585   lang_init ();
1586
1587   /* If the input doesn't start with a #line, use the input name
1588      as the official input file name.  */
1589   if (main_input_filename == 0)
1590     main_input_filename = name;
1591
1592   /* Put an entry on the input file stack for the main input file.  */
1593   input_file_stack
1594     = (struct file_stack *) xmalloc (sizeof (struct file_stack));
1595   input_file_stack->next = 0;
1596   input_file_stack->name = input_filename;
1597
1598   ASM_FILE_START (asm_out_file);
1599
1600   /* Output something to inform GDB that this compilation was by GCC.  */
1601 #ifndef ASM_IDENTIFY_GCC
1602   fprintf (asm_out_file, "gcc2_compiled.:\n");
1603 #else
1604   ASM_IDENTIFY_GCC (asm_out_file);
1605 #endif
1606   /* Don't let the first function fall at the same address
1607      as gcc_compiled., if profiling.  */
1608   if (profile_flag || profile_block_flag)
1609     assemble_zeros (UNITS_PER_WORD);
1610
1611   /* If dbx symbol table desired, initialize writing it
1612      and output the predefined types.  */
1613 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1614   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1615     TIMEVAR (symout_time, dbxout_init (asm_out_file, main_input_filename,
1616                                        getdecls ()));
1617 #endif
1618 #ifdef SDB_DEBUGGING_INFO
1619   if (write_symbols == SDB_DEBUG)
1620     TIMEVAR (symout_time, sdbout_init (asm_out_file, main_input_filename,
1621                                        getdecls ()));
1622 #endif
1623 #ifdef DWARF_DEBUGGING_INFO
1624   if (write_symbols == DWARF_DEBUG)
1625     TIMEVAR (symout_time, dwarfout_init (asm_out_file, main_input_filename));
1626 #endif
1627
1628   /* Initialize yet another pass.  */
1629
1630   init_final (main_input_filename);
1631
1632   start_time = get_run_time ();
1633
1634   /* Call the parser, which parses the entire file
1635      (calling rest_of_compilation for each function).  */
1636
1637   if (yyparse () != 0)
1638     if (errorcount == 0)
1639       fprintf (stderr, "Errors detected in input file (your bison.simple is out of date)");
1640
1641   /* Compilation is now finished except for writing
1642      what's left of the symbol table output.  */
1643
1644   parse_time += get_run_time () - start_time;
1645
1646   parse_time -= integration_time;
1647   parse_time -= varconst_time;
1648
1649   globals = getdecls ();
1650
1651   /* Really define vars that have had only a tentative definition.
1652      Really output inline functions that must actually be callable
1653      and have not been output so far.  */
1654
1655   {
1656     int len = list_length (globals);
1657     tree *vec = (tree *) alloca (sizeof (tree) * len);
1658     int i;
1659     tree decl;
1660
1661     /* Process the decls in reverse order--earliest first.
1662        Put them into VEC from back to front, then take out from front.  */
1663
1664     for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1665       vec[len - i - 1] = decl;
1666
1667     for (i = 0; i < len; i++)
1668       {
1669         decl = vec[i];
1670         if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
1671             && ! TREE_ASM_WRITTEN (decl))
1672           {
1673             /* Don't write out static consts, unless we used them.
1674                (This used to write them out only if the address was
1675                taken, but that was wrong; if the variable was simply
1676                referred to, it still needs to exist or else it will
1677                be undefined in the linker.)  */
1678             if (! TREE_READONLY (decl)
1679                 || TREE_PUBLIC (decl)
1680                 || TREE_USED (decl)
1681                 || TREE_ADDRESSABLE (decl)
1682                 || TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl)))
1683               rest_of_decl_compilation (decl, 0, 1, 1);
1684             else
1685               /* Cancel the RTL for this decl so that, if debugging info
1686                  output for global variables is still to come,
1687                  this one will be omitted.  */
1688               DECL_RTL (decl) = NULL;
1689           }
1690
1691         if (TREE_CODE (decl) == FUNCTION_DECL
1692             && ! TREE_ASM_WRITTEN (decl)
1693             && DECL_INITIAL (decl) != 0
1694             && (TREE_ADDRESSABLE (decl)
1695                 || TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl)))
1696             && ! TREE_EXTERNAL (decl))
1697           output_inline_function (decl);
1698
1699         /* Warn about any function
1700            declared static but not defined.
1701            We don't warn about variables,
1702            because many programs have static variables
1703            that exist only to get some text into the object file.  */
1704         if ((warn_unused
1705              || TREE_USED (decl)
1706              || (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl))))
1707             && TREE_CODE (decl) == FUNCTION_DECL
1708             && DECL_INITIAL (decl) == 0
1709             && TREE_EXTERNAL (decl)
1710             && ! TREE_PUBLIC (decl))
1711           warning_with_decl (decl, "`%s' declared `static' but never defined");
1712         /* Warn about static fns or vars defined but not used,
1713            but not about inline functions
1714            since unused inline statics is normal practice.  */
1715         if (warn_unused
1716             && (TREE_CODE (decl) == FUNCTION_DECL
1717                 || TREE_CODE (decl) == VAR_DECL)
1718             && ! TREE_EXTERNAL (decl)
1719             && ! TREE_PUBLIC (decl)
1720             && ! TREE_USED (decl)
1721             && ! TREE_INLINE (decl)
1722             /* The TREE_USED bit for file-scope decls
1723                is kept in the identifier, to handle multiple
1724                external decls in different scopes.  */
1725             && ! TREE_USED (DECL_NAME (decl)))
1726           warning_with_decl (decl, "`%s' defined but not used");
1727
1728 #ifdef SDB_DEBUGGING_INFO
1729         /* The COFF linker can move initialized global vars to the end.
1730            And that can screw up the symbol ordering.
1731            By putting the symbols in that order to begin with,
1732            we avoid a problem.  mcsun!unido!fauern!tumuc!pes@uunet.uu.net.  */
1733         if (write_symbols == SDB_DEBUG && TREE_CODE (decl) == VAR_DECL
1734             && TREE_PUBLIC (decl) && DECL_INITIAL (decl)
1735             && DECL_RTL (decl) != 0)
1736           TIMEVAR (symout_time, sdbout_symbol (decl, 0));
1737
1738         /* Output COFF information for non-global
1739            file-scope initialized variables. */
1740         if (write_symbols == SDB_DEBUG
1741             && TREE_CODE (decl) == VAR_DECL
1742             && DECL_INITIAL (decl)
1743             && DECL_RTL (decl) != 0
1744             && GET_CODE (DECL_RTL (decl)) == MEM)
1745           TIMEVAR (symout_time, sdbout_toplevel_data (decl));
1746 #endif /* SDB_DEBUGGING_INFO */
1747 #ifdef DWARF_DEBUGGING_INFO
1748         /* Output DWARF information for file-scope tentative data object
1749            declarations, file-scope (extern) function declarations (which
1750            had no corresponding body) and file-scope tagged type declarations
1751            and definitions which have not yet been forced out.  */
1752
1753         if (write_symbols == DWARF_DEBUG
1754             && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)))
1755           TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 1));
1756 #endif
1757       }
1758   }
1759
1760   /* Do dbx symbols */
1761 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1762   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1763     TIMEVAR (symout_time,
1764              {
1765                dbxout_finish (asm_out_file, main_input_filename);
1766              });
1767 #endif
1768
1769 #ifdef DWARF_DEBUGGING_INFO
1770   if (write_symbols == DWARF_DEBUG)
1771     TIMEVAR (symout_time,
1772              {
1773                dwarfout_finish ();
1774              });
1775 #endif
1776
1777   /* Output some stuff at end of file if nec.  */
1778
1779   end_final (main_input_filename);
1780
1781 #ifdef ASM_FILE_END
1782   ASM_FILE_END (asm_out_file);
1783 #endif
1784
1785  after_finish_compilation:
1786
1787   /* Language-specific end of compilation actions.  */
1788
1789   lang_finish ();
1790
1791   /* Close the dump files.  */
1792
1793   if (flag_gen_aux_info)
1794     {
1795       fclose (aux_info_file);
1796       if (errorcount)
1797         unlink (aux_info_file_name);
1798     }
1799
1800   if (rtl_dump)
1801     fclose (rtl_dump_file);
1802
1803   if (jump_opt_dump)
1804     fclose (jump_opt_dump_file);
1805
1806   if (cse_dump)
1807     fclose (cse_dump_file);
1808
1809   if (loop_dump)
1810     fclose (loop_dump_file);
1811
1812   if (cse2_dump)
1813     fclose (cse2_dump_file);
1814
1815   if (flow_dump)
1816     fclose (flow_dump_file);
1817
1818   if (combine_dump)
1819     {
1820       dump_combine_total_stats (combine_dump_file);
1821       fclose (combine_dump_file);
1822     }
1823
1824   if (sched_dump)
1825     fclose (sched_dump_file);
1826
1827   if (local_reg_dump)
1828     fclose (local_reg_dump_file);
1829
1830   if (global_reg_dump)
1831     fclose (global_reg_dump_file);
1832
1833   if (sched2_dump)
1834     fclose (sched2_dump_file);
1835
1836   if (jump2_opt_dump)
1837     fclose (jump2_opt_dump_file);
1838
1839   if (dbr_sched_dump)
1840     fclose (dbr_sched_dump_file);
1841
1842 #ifdef STACK_REGS
1843   if (stack_reg_dump)
1844     fclose (stack_reg_dump_file);
1845 #endif
1846
1847   /* Close non-debugging input and output files.  Take special care to note
1848      whether fclose returns an error, since the pages might still be on the
1849      buffer chain while the file is open.  */
1850
1851   fclose (finput);
1852   if (ferror (asm_out_file) != 0 || fclose (asm_out_file) != 0)
1853     fatal_io_error (asm_file_name);
1854
1855   /* Print the times.  */
1856
1857   if (! quiet_flag)
1858     {
1859       fprintf (stderr,"\n");
1860       print_time ("parse", parse_time);
1861       print_time ("integration", integration_time);
1862       print_time ("jump", jump_time);
1863       print_time ("cse", cse_time);
1864       print_time ("loop", loop_time);
1865       print_time ("cse2", cse2_time);
1866       print_time ("flow", flow_time);
1867       print_time ("combine", combine_time);
1868       print_time ("sched", sched_time);
1869       print_time ("local-alloc", local_alloc_time);
1870       print_time ("global-alloc", global_alloc_time);
1871       print_time ("sched2", sched2_time);
1872       print_time ("dbranch", dbr_sched_time);
1873       print_time ("shorten-branch", shorten_branch_time);
1874       print_time ("stack-reg", stack_reg_time);
1875       print_time ("final", final_time);
1876       print_time ("varconst", varconst_time);
1877       print_time ("symout", symout_time);
1878       print_time ("dump", dump_time);
1879     }
1880 }
1881 \f
1882 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
1883    and TYPE_DECL nodes.
1884
1885    This does nothing for local (non-static) variables.
1886    Otherwise, it sets up the RTL and outputs any assembler code
1887    (label definition, storage allocation and initialization).
1888
1889    DECL is the declaration.  If ASMSPEC is nonzero, it specifies
1890    the assembler symbol name to be used.  TOP_LEVEL is nonzero
1891    if this declaration is not within a function.  */
1892
1893 void
1894 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
1895      tree decl;
1896      char *asmspec;
1897      int top_level;
1898      int at_end;
1899 {
1900   /* Declarations of variables, and of functions defined elsewhere.  */
1901
1902   /* Forward declarations for nested functions are not "external",
1903      but we need to treat them as if they were.  */
1904   if (TREE_STATIC (decl) || TREE_EXTERNAL (decl)
1905       || TREE_CODE (decl) == FUNCTION_DECL)
1906     TIMEVAR (varconst_time,
1907              {
1908                make_decl_rtl (decl, asmspec, top_level);
1909                /* Don't output anything
1910                   when a tentative file-scope definition is seen.
1911                   But at end of compilation, do output code for them.  */
1912                if (! (! at_end && top_level
1913                       && (DECL_INITIAL (decl) == 0
1914                           || DECL_INITIAL (decl) == error_mark_node)))
1915                  assemble_variable (decl, top_level, at_end);
1916              });
1917   else if (TREE_REGDECL (decl) && asmspec != 0)
1918     {
1919       if (decode_reg_name (asmspec) >= 0)
1920         {
1921           DECL_RTL (decl) = 0;
1922           make_decl_rtl (decl, asmspec, top_level);
1923         }
1924       else
1925         error ("invalid register name `%s' for register variable", asmspec);
1926     }
1927 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1928   else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1929            && TREE_CODE (decl) == TYPE_DECL)
1930     TIMEVAR (symout_time, dbxout_symbol (decl, 0));
1931 #endif
1932 #ifdef SDB_DEBUGGING_INFO
1933   else if (write_symbols == SDB_DEBUG && top_level
1934            && TREE_CODE (decl) == TYPE_DECL)
1935     TIMEVAR (symout_time, sdbout_symbol (decl, 0));
1936 #endif
1937 }
1938
1939 /* Called after finishing a record, union or enumeral type.  */
1940
1941 void
1942 rest_of_type_compilation (type, toplev)
1943      tree type;
1944      int toplev;
1945 {
1946 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1947   if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1948     TIMEVAR (symout_time, dbxout_symbol (TYPE_STUB_DECL (type), !toplev));
1949 #endif
1950 #ifdef SDB_DEBUGGING_INFO
1951   if (write_symbols == SDB_DEBUG)
1952     TIMEVAR (symout_time, sdbout_symbol (TYPE_STUB_DECL (type), !toplev));
1953 #endif
1954 }
1955
1956 /* This is called from finish_function (within yyparse)
1957    after each top-level definition is parsed.
1958    It is supposed to compile that function or variable
1959    and output the assembler code for it.
1960    After we return, the tree storage is freed.  */
1961
1962 void
1963 rest_of_compilation (decl)
1964      tree decl;
1965 {
1966   register rtx insns;
1967   int start_time = get_run_time ();
1968   int tem;
1969   /* Nonzero if we have saved the original DECL_INITIAL of the function,
1970      to be restored after we finish compiling the function
1971      (for use when compiling inline calls to this function).  */
1972   tree saved_block_tree = 0;
1973
1974   /* If we are reconsidering an inline function
1975      at the end of compilation, skip the stuff for making it inline.  */
1976
1977   if (DECL_SAVED_INSNS (decl) == 0)
1978     {
1979       int specd = TREE_INLINE (decl);
1980       char *lose;
1981
1982       /* If requested, consider whether to make this function inline.  */
1983       if (specd || flag_inline_functions)
1984         TIMEVAR (integration_time,
1985                  {
1986                    lose = function_cannot_inline_p (decl);
1987                    if (lose)
1988                      {
1989                        if (warn_inline && specd)
1990                          warning_with_decl (decl, lose);
1991                        TREE_INLINE (decl) = 0;
1992                      }
1993                    else
1994                      TREE_INLINE (decl) = 1;
1995                  });
1996
1997       insns = get_insns ();
1998
1999       /* Dump the rtl code if we are dumping rtl.  */
2000
2001       if (rtl_dump)
2002         TIMEVAR (dump_time,
2003                  {
2004                    fprintf (rtl_dump_file, "\n;; Function %s\n\n",
2005                             IDENTIFIER_POINTER (DECL_NAME (decl)));
2006                    if (DECL_SAVED_INSNS (decl))
2007                      fprintf (rtl_dump_file, ";; (integrable)\n\n");
2008                    print_rtl (rtl_dump_file, insns);
2009                    fflush (rtl_dump_file);
2010                  });
2011
2012       /* If function is inline, and we don't yet know whether to
2013          compile it by itself, defer decision till end of compilation.
2014          finish_compilation will call rest_of_compilation again
2015          for those functions that need to be output.  */
2016
2017       if (TREE_INLINE (decl)
2018           && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
2019                && ! flag_keep_inline_functions)
2020               || TREE_EXTERNAL (decl)))
2021         {
2022           TIMEVAR (integration_time, save_for_inline_nocopy (decl));
2023           goto exit_rest_of_compilation;
2024         }
2025
2026       /* If we have to compile the function now, save its rtl
2027          so that its compilation will not affect what others get.  */
2028       if (TREE_INLINE (decl))
2029         {
2030           saved_block_tree = DECL_INITIAL (decl);
2031           TIMEVAR (integration_time, save_for_inline_copying (decl));
2032         }
2033     }
2034
2035   /* Suppress warnings for unused static functions
2036      defined (not just declared) in system headers.  */
2037   if (in_system_header && TREE_STATIC (decl) && !TREE_INLINE (decl))
2038     TREE_USED (decl) = 1;
2039
2040   TREE_ASM_WRITTEN (decl) = 1;
2041
2042   /* Now that integrate will no longer see our rtl, we need not distinguish
2043      between the return value of this function and the return value of called
2044      functions.  */
2045   rtx_equal_function_value_matters = 0;
2046
2047   /* Don't return yet if -Wreturn-type; we need to do jump_optimize.  */
2048   if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
2049     {
2050       goto exit_rest_of_compilation;
2051     }
2052
2053   /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
2054      Note that that may have been done above, in save_for_inline_copying.
2055      The call to resume_temporary_allocation near the end of this function
2056      goes back to the usual state of affairs.  */
2057
2058   rtl_in_current_obstack ();
2059
2060 #ifdef FINALIZE_PIC
2061   /* If we are doing position-independent code generation, now
2062      is the time to output special prologues and epilogues.
2063      We do not want to do this earlier, because it just clutters
2064      up inline functions with meaningless insns.  */
2065   if (flag_pic)
2066     FINALIZE_PIC;
2067 #endif
2068
2069   insns = get_insns ();
2070
2071   /* Copy any shared structure that should not be shared.  */
2072
2073   unshare_all_rtl (insns);
2074
2075   /* Instantiate all virtual registers.  */
2076
2077   instantiate_virtual_regs (current_function_decl, get_insns ());
2078
2079   /* See if we have allocated stack slots that are not directly addressable.
2080      If so, scan all the insns and create explicit address computation
2081      for all references to such slots.  */
2082 /*   fixup_stack_slots (); */
2083
2084   /* Do jump optimization the first time, if -opt.
2085      Also do it if -W, but in that case it doesn't change the rtl code,
2086      it only computes whether control can drop off the end of the function.  */
2087
2088   if (optimize > 0 || extra_warnings || warn_return_type
2089       /* If function is `volatile', we should warn if it tries to return.  */
2090       || TREE_THIS_VOLATILE (decl))
2091     {
2092       TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
2093       TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1));
2094     }
2095
2096   /* Now is when we stop if -fsyntax-only and -Wreturn-type.  */
2097   if (rtl_dump_and_exit || flag_syntax_only)
2098     goto exit_rest_of_compilation;
2099
2100   /* Dump rtl code after jump, if we are doing that.  */
2101
2102   if (jump_opt_dump)
2103     TIMEVAR (dump_time,
2104              {
2105                fprintf (jump_opt_dump_file, "\n;; Function %s\n\n",
2106                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2107                print_rtl (jump_opt_dump_file, insns);
2108                fflush (jump_opt_dump_file);
2109              });
2110
2111   /* Perform common subexpression elimination.
2112      Nonzero value from `cse_main' means that jumps were simplified
2113      and some code may now be unreachable, so do
2114      jump optimization again.  */
2115
2116   if (cse_dump)
2117     TIMEVAR (dump_time,
2118              {
2119                fprintf (cse_dump_file, "\n;; Function %s\n\n",
2120                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2121              });
2122
2123   if (optimize > 0)
2124     {
2125       TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 1));
2126
2127       if (flag_thread_jumps)
2128         /* Hacks by tiemann & kenner.  */
2129         TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0));
2130
2131       TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (),
2132                                          0, cse_dump_file));
2133       TIMEVAR (cse_time, delete_dead_from_cse (insns, max_reg_num ()));
2134
2135       if (tem)
2136         TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
2137     }
2138
2139   /* Dump rtl code after cse, if we are doing that.  */
2140
2141   if (cse_dump)
2142     TIMEVAR (dump_time,
2143              {
2144                print_rtl (cse_dump_file, insns);
2145                fflush (cse_dump_file);
2146              });
2147
2148   if (loop_dump)
2149     TIMEVAR (dump_time,
2150              {
2151                fprintf (loop_dump_file, "\n;; Function %s\n\n",
2152                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2153              });
2154
2155   /* Move constant computations out of loops.  */
2156
2157   if (optimize > 0)
2158     {
2159       TIMEVAR (loop_time,
2160                {
2161                  loop_optimize (insns, loop_dump ? loop_dump_file : 0);
2162                });
2163     }
2164
2165   /* Dump rtl code after loop opt, if we are doing that.  */
2166
2167   if (loop_dump)
2168     TIMEVAR (dump_time,
2169              {
2170                print_rtl (loop_dump_file, insns);
2171                fflush (loop_dump_file);
2172              });
2173
2174   if (cse2_dump)
2175     TIMEVAR (dump_time,
2176              {
2177                fprintf (cse2_dump_file, "\n;; Function %s\n\n",
2178                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2179              });
2180
2181   if (optimize > 0 && flag_rerun_cse_after_loop)
2182     {
2183       TIMEVAR (cse2_time, reg_scan (insns, max_reg_num (), 0));
2184
2185       TIMEVAR (cse2_time, tem = cse_main (insns, max_reg_num (),
2186                                           1, cse2_dump_file));
2187       if (tem)
2188         TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
2189     }
2190
2191   if (optimize > 0 && flag_thread_jumps)
2192     /* This pass of jump threading straightens out code
2193        that was kinked by loop optimization.  */
2194     TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0));
2195
2196   /* Dump rtl code after cse, if we are doing that.  */
2197
2198   if (cse2_dump)
2199     TIMEVAR (dump_time,
2200              {
2201                print_rtl (cse2_dump_file, insns);
2202                fflush (cse2_dump_file);
2203              });
2204
2205   /* We are no longer anticipating cse in this function, at least.  */
2206
2207   cse_not_expected = 1;
2208
2209   /* Now we choose between stupid (pcc-like) register allocation
2210      (if we got the -noreg switch and not -opt)
2211      and smart register allocation.  */
2212
2213   if (optimize > 0)                     /* Stupid allocation probably won't work */
2214     obey_regdecls = 0;          /* if optimizations being done.  */
2215
2216   regclass_init ();
2217
2218   /* Print function header into flow dump now
2219      because doing the flow analysis makes some of the dump.  */
2220
2221   if (flow_dump)
2222     TIMEVAR (dump_time,
2223              {
2224                fprintf (flow_dump_file, "\n;; Function %s\n\n",
2225                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2226              });
2227
2228   if (obey_regdecls)
2229     {
2230       TIMEVAR (flow_time,
2231                {
2232                  regclass (insns, max_reg_num ());
2233                  stupid_life_analysis (insns, max_reg_num (),
2234                                        flow_dump_file);
2235                });
2236     }
2237   else
2238     {
2239       /* Do control and data flow analysis,
2240          and write some of the results to dump file.  */
2241
2242       TIMEVAR (flow_time, flow_analysis (insns, max_reg_num (),
2243                                          flow_dump_file));
2244       if (warn_uninitialized)
2245         {
2246           uninitialized_vars_warning (DECL_INITIAL (decl));
2247           setjmp_args_warning ();
2248         }
2249     }
2250
2251   /* Dump rtl after flow analysis.  */
2252
2253   if (flow_dump)
2254     TIMEVAR (dump_time,
2255              {
2256                print_rtl (flow_dump_file, insns);
2257                fflush (flow_dump_file);
2258              });
2259
2260   /* If -opt, try combining insns through substitution.  */
2261
2262   if (optimize > 0)
2263     TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ()));
2264
2265   /* Dump rtl code after insn combination.  */
2266
2267   if (combine_dump)
2268     TIMEVAR (dump_time,
2269              {
2270                fprintf (combine_dump_file, "\n;; Function %s\n\n",
2271                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2272                dump_combine_stats (combine_dump_file);
2273                print_rtl (combine_dump_file, insns);
2274                fflush (combine_dump_file);
2275              });
2276
2277   /* Print function header into sched dump now
2278      because doing the sched analysis makes some of the dump.  */
2279
2280   if (sched_dump)
2281     TIMEVAR (dump_time,
2282              {
2283                fprintf (sched_dump_file, "\n;; Function %s\n\n",
2284                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2285              });
2286
2287   if (optimize > 0 && flag_schedule_insns)
2288     {
2289       /* Do control and data sched analysis,
2290          and write some of the results to dump file.  */
2291
2292       TIMEVAR (sched_time, schedule_insns (sched_dump_file));
2293     }
2294
2295   /* Dump rtl after instruction scheduling.  */
2296
2297   if (sched_dump)
2298     TIMEVAR (dump_time,
2299              {
2300                print_rtl (sched_dump_file, insns);
2301                fflush (sched_dump_file);
2302              });
2303
2304   /* Unless we did stupid register allocation,
2305      allocate pseudo-regs that are used only within 1 basic block.  */
2306
2307   if (!obey_regdecls)
2308     TIMEVAR (local_alloc_time,
2309              {
2310                regclass (insns, max_reg_num ());
2311                local_alloc ();
2312              });
2313
2314   /* Dump rtl code after allocating regs within basic blocks.  */
2315
2316   if (local_reg_dump)
2317     TIMEVAR (dump_time,
2318              {
2319                fprintf (local_reg_dump_file, "\n;; Function %s\n\n",
2320                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2321                dump_flow_info (local_reg_dump_file);
2322                dump_local_alloc (local_reg_dump_file);
2323                print_rtl (local_reg_dump_file, insns);
2324                fflush (local_reg_dump_file);
2325              });
2326
2327   if (global_reg_dump)
2328     TIMEVAR (dump_time,
2329              fprintf (global_reg_dump_file, "\n;; Function %s\n\n",
2330                       IDENTIFIER_POINTER (DECL_NAME (decl))));
2331
2332   /* Unless we did stupid register allocation,
2333      allocate remaining pseudo-regs, then do the reload pass
2334      fixing up any insns that are invalid.  */
2335
2336   TIMEVAR (global_alloc_time,
2337            {
2338              if (!obey_regdecls)
2339                global_alloc (global_reg_dump ? global_reg_dump_file : 0);
2340              else
2341                reload (insns, 0,
2342                        global_reg_dump ? global_reg_dump_file : 0);
2343            });
2344
2345   if (global_reg_dump)
2346     TIMEVAR (dump_time,
2347              {
2348                dump_global_regs (global_reg_dump_file);
2349                print_rtl (global_reg_dump_file, insns);
2350                fflush (global_reg_dump_file);
2351              });
2352
2353   reload_completed = 1;
2354
2355   if (optimize > 0 && flag_schedule_insns_after_reload)
2356     {
2357       if (sched2_dump)
2358         TIMEVAR (dump_time,
2359                  {
2360                    fprintf (sched2_dump_file, "\n;; Function %s\n\n",
2361                             IDENTIFIER_POINTER (DECL_NAME (decl)));
2362                  });
2363
2364       /* Do control and data sched analysis again,
2365          and write some more of the results to dump file.  */
2366
2367       TIMEVAR (sched2_time, schedule_insns (sched2_dump_file));
2368
2369       /* Dump rtl after post-reorder instruction scheduling.  */
2370
2371       if (sched2_dump)
2372         TIMEVAR (dump_time,
2373                  {
2374                    print_rtl (sched2_dump_file, insns);
2375                    fflush (sched2_dump_file);
2376                  });
2377     }
2378
2379 #ifdef LEAF_REGISTERS
2380   leaf_function = 0;
2381   if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
2382       leaf_function = 1;
2383 #endif
2384
2385   /* One more attempt to remove jumps to .+1
2386      left by dead-store-elimination.
2387      Also do cross-jumping this time
2388      and delete no-op move insns.  */
2389
2390   if (optimize > 0)
2391     {
2392       TIMEVAR (jump_time, jump_optimize (insns, 1, 1, 0));
2393     }
2394
2395   /* Dump rtl code after jump, if we are doing that.  */
2396
2397   if (jump2_opt_dump)
2398     TIMEVAR (dump_time,
2399              {
2400                fprintf (jump2_opt_dump_file, "\n;; Function %s\n\n",
2401                         IDENTIFIER_POINTER (DECL_NAME (decl)));
2402                print_rtl (jump2_opt_dump_file, insns);
2403                fflush (jump2_opt_dump_file);
2404              });
2405
2406   /* If a scheduling pass for delayed branches is to be done,
2407      call the scheduling code. */
2408
2409 #ifdef DELAY_SLOTS
2410   if (optimize > 0 && flag_delayed_branch)
2411     {
2412       TIMEVAR (dbr_sched_time, dbr_schedule (insns, dbr_sched_dump_file));
2413       if (dbr_sched_dump)
2414         {
2415           TIMEVAR (dump_time,
2416                  {
2417                    fprintf (dbr_sched_dump_file, "\n;; Function %s\n\n",
2418                             IDENTIFIER_POINTER (DECL_NAME (decl)));
2419                    print_rtl (dbr_sched_dump_file, insns);
2420                    fflush (dbr_sched_dump_file);
2421                  });
2422         }
2423     }
2424 #endif
2425
2426   if (optimize > 0)
2427     /* Shorten branches.  */
2428     TIMEVAR (shorten_branch_time,
2429              {
2430                shorten_branches (get_insns ());
2431              });
2432
2433 #ifdef STACK_REGS
2434   TIMEVAR (stack_reg_time, reg_to_stack (insns, stack_reg_dump_file));
2435   if (stack_reg_dump)
2436     {
2437       TIMEVAR (dump_time,
2438                {
2439                  fprintf (stack_reg_dump_file, "\n;; Function %s\n\n",
2440                           IDENTIFIER_POINTER (DECL_NAME (decl)));
2441                  print_rtl (stack_reg_dump_file, insns);
2442                  fflush (stack_reg_dump_file);
2443                });
2444     }
2445 #endif
2446
2447   /* Now turn the rtl into assembler code.  */
2448
2449   TIMEVAR (final_time,
2450            {
2451              rtx x;
2452              char *fnname;
2453
2454              /* Get the function's name, as described by its RTL.
2455                 This may be different from the DECL_NAME name used
2456                 in the source file.  */
2457
2458              x = DECL_RTL (decl);
2459              if (GET_CODE (x) != MEM)
2460                abort ();
2461              x = XEXP (x, 0);
2462              if (GET_CODE (x) != SYMBOL_REF)
2463                abort ();
2464              fnname = XSTR (x, 0);
2465
2466              assemble_start_function (decl, fnname);
2467              final_start_function (insns, asm_out_file, optimize);
2468              final (insns, asm_out_file, optimize, 0);
2469              final_end_function (insns, asm_out_file, optimize);
2470              assemble_end_function (decl, fnname);
2471              fflush (asm_out_file);
2472            });
2473
2474   /* Write DBX symbols if requested */
2475
2476   /* Note that for those inline functions where we don't initially
2477      know for certain that we will be generating an out-of-line copy,
2478      the first invocation of this routine (rest_of_compilation) will
2479      skip over this code by doing a `goto exit_rest_of_compilation;'.
2480      Later on, finish_compilation will call rest_of_compilation again
2481      for those inline functions that need to have out-of-line copies
2482      generated.  During that call, we *will* be routed past here.  */
2483
2484 #ifdef DBX_DEBUGGING_INFO
2485   if (write_symbols == DBX_DEBUG)
2486     TIMEVAR (symout_time, dbxout_function (decl));
2487 #endif
2488
2489 #ifdef DWARF_DEBUGGING_INFO
2490   if (write_symbols == DWARF_DEBUG)
2491     TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
2492 #endif
2493
2494  exit_rest_of_compilation:
2495
2496   /* In case the function was not output,
2497      don't leave any temporary anonymous types
2498      queued up for sdb output.  */
2499 #ifdef SDB_DEBUGGING_INFO
2500   if (write_symbols == SDB_DEBUG)
2501     sdbout_types (0);
2502 #endif
2503
2504   /* Put back the tree of subblocks from before we copied it.
2505      Code generation and the output of debugging info may have modified
2506      the copy, but the original is unchanged.  */
2507
2508   if (saved_block_tree != 0)
2509     DECL_INITIAL (decl) = saved_block_tree;
2510
2511   reload_completed = 0;
2512
2513   /* Clear out the real_constant_chain before some of the rtx's
2514      it runs through become garbage.  */
2515
2516   clear_const_double_mem ();
2517
2518   /* Cancel the effect of rtl_in_current_obstack.  */
2519
2520   resume_temporary_allocation ();
2521
2522   /* The parsing time is all the time spent in yyparse
2523      *except* what is spent in this function.  */
2524
2525   parse_time -= get_run_time () - start_time;
2526 }
2527 \f
2528 /* Entry point of cc1/c++.  Decode command args, then call compile_file.
2529    Exit code is 35 if can't open files, 34 if fatal error,
2530    33 if had nonfatal errors, else success.  */
2531
2532 int
2533 main (argc, argv, envp)
2534      int argc;
2535      char **argv;
2536      char **envp;
2537 {
2538   register int i;
2539   char *filename = 0;
2540   int flag_print_mem = 0;
2541   int version_flag = 0;
2542   char *p;
2543
2544   /* save in case md file wants to emit args as a comment.  */
2545   save_argc = argc;
2546   save_argv = argv;
2547
2548   p = argv[0] + strlen (argv[0]);
2549   while (p != argv[0] && p[-1] != '/') --p;
2550   progname = p;
2551
2552 #ifdef RLIMIT_STACK
2553   /* Get rid of any avoidable limit on stack size.  */
2554   {
2555     struct rlimit rlim;
2556
2557     /* Set the stack limit huge so that alloca does not fail. */
2558     getrlimit (RLIMIT_STACK, &rlim);
2559     rlim.rlim_cur = rlim.rlim_max;
2560     setrlimit (RLIMIT_STACK, &rlim);
2561   }
2562 #endif /* RLIMIT_STACK */
2563
2564   signal (SIGFPE, float_signal);
2565
2566   signal (SIGPIPE, pipe_closed);
2567
2568   decl_printable_name = decl_name;
2569   lang_expand_expr = (struct rtx_def *(*)()) do_abort;
2570
2571   /* Initialize whether `char' is signed.  */
2572   flag_signed_char = DEFAULT_SIGNED_CHAR;
2573 #ifdef DEFAULT_SHORT_ENUMS
2574   /* Initialize how much space enums occupy, by default.  */
2575   flag_short_enums = DEFAULT_SHORT_ENUMS;
2576 #endif
2577
2578   /* Scan to see what optimization level has been specified.  That will
2579      determine the default value of many flags.  */
2580   for (i = 1; i < argc; i++)
2581     {
2582       if (!strcmp (argv[i], "-O"))
2583         {
2584           optimize = 1;
2585         }
2586       else if (argv[i][0] == '-' && argv[i][1] == 'O')
2587         {
2588           /* Handle -O2, -O3, -O69, ...  */
2589           char *p = &argv[i][2];
2590           int c;
2591
2592           while (c = *p++)
2593             if (! (c >= '0' && c <= '9'))
2594               break;
2595           if (c == 0)
2596             optimize = atoi (&argv[i][2]);
2597         }
2598     }
2599
2600   obey_regdecls = (optimize == 0);
2601   if (optimize == 0)
2602     {
2603       flag_no_inline = 1;
2604       warn_inline = 0;
2605     }
2606
2607   if (optimize >= 1)
2608     {
2609       flag_thread_jumps = 1;
2610 #ifdef DELAY_SLOTS
2611       flag_delayed_branch = 1;
2612 #endif
2613     }
2614
2615   if (optimize >= 2)
2616     {
2617       flag_cse_follow_jumps = 1;
2618       flag_cse_skip_blocks = 1;
2619       flag_expensive_optimizations = 1;
2620       flag_strength_reduce = 1;
2621       flag_rerun_cse_after_loop = 1;
2622       flag_caller_saves = 1;
2623 #ifdef INSN_SCHEDULING
2624       flag_schedule_insns = 1;
2625       flag_schedule_insns_after_reload = 1;
2626 #endif
2627     }
2628
2629 #ifdef OPTIMIZATION_OPTIONS
2630   /* Allow default optimizations to be specified on a per-machine basis.  */
2631   OPTIMIZATION_OPTIONS (optimize);
2632 #endif
2633
2634   /* Initialize register usage now so switches may override.  */
2635   init_reg_sets ();
2636
2637   target_flags = 0;
2638   set_target_switch ("");
2639
2640   for (i = 1; i < argc; i++)
2641     {
2642       if (argv[i][0] == '-' && argv[i][1] != 0)
2643         {
2644           register char *str = argv[i] + 1;
2645           if (str[0] == 'Y')
2646             str++;
2647
2648           if (str[0] == 'm')
2649             set_target_switch (&str[1]);
2650           else if (!strcmp (str, "dumpbase"))
2651             {
2652               dump_base_name = argv[++i];
2653             }
2654           else if (str[0] == 'd')
2655             {
2656               register char *p = &str[1];
2657               while (*p)
2658                 switch (*p++)
2659                   {
2660                   case 'a':
2661                     combine_dump = 1;
2662                     dbr_sched_dump = 1;
2663                     flow_dump = 1;
2664                     global_reg_dump = 1;
2665                     jump_opt_dump = 1;
2666                     jump2_opt_dump = 1;
2667                     local_reg_dump = 1;
2668                     loop_dump = 1;
2669                     rtl_dump = 1;
2670                     cse_dump = 1, cse2_dump = 1;
2671                     sched_dump = 1;
2672                     sched2_dump = 1;
2673                     stack_reg_dump = 1;
2674                     break;
2675                   case 'k':
2676                     stack_reg_dump = 1;
2677                     break;
2678                   case 'c':
2679                     combine_dump = 1;
2680                     break;
2681                   case 'd':
2682                     dbr_sched_dump = 1;
2683                     break;
2684                   case 'f':
2685                     flow_dump = 1;
2686                     break;
2687                   case 'g':
2688                     global_reg_dump = 1;
2689                     break;
2690                   case 'j':
2691                     jump_opt_dump = 1;
2692                     break;
2693                   case 'J':
2694                     jump2_opt_dump = 1;
2695                     break;
2696                   case 'l':
2697                     local_reg_dump = 1;
2698                     break;
2699                   case 'L':
2700                     loop_dump = 1;
2701                     break;
2702                   case 'm':
2703                     flag_print_mem = 1;
2704                     break;
2705                   case 'p':
2706                     flag_print_asm_name = 1;
2707                     break;
2708                   case 'r':
2709                     rtl_dump = 1;
2710                     break;
2711                   case 's':
2712                     cse_dump = 1;
2713                     break;
2714                   case 't':
2715                     cse2_dump = 1;
2716                     break;
2717                   case 'S':
2718                     sched_dump = 1;
2719                     break;
2720                   case 'R':
2721                     sched2_dump = 1;
2722                     break;
2723                   case 'y':
2724                     set_yydebug (1);
2725                     break;
2726
2727                   case 'x':
2728                     rtl_dump_and_exit = 1;
2729                     break;
2730                   }
2731             }
2732           else if (str[0] == 'f')
2733             {
2734               int j;
2735               register char *p = &str[1];
2736               int found = 0;
2737
2738               /* Some kind of -f option.
2739                  P's value is the option sans `-f'.
2740                  Search for it in the table of options.  */
2741
2742               for (j = 0;
2743                    !found && j < sizeof (f_options) / sizeof (f_options[0]);
2744                    j++)
2745                 {
2746                   if (!strcmp (p, f_options[j].string))
2747                     {
2748                       *f_options[j].variable = f_options[j].on_value;
2749                       /* A goto here would be cleaner,
2750                          but breaks the vax pcc.  */
2751                       found = 1;
2752                     }
2753                   if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
2754                       && ! strcmp (p+3, f_options[j].string))
2755                     {
2756                       *f_options[j].variable = ! f_options[j].on_value;
2757                       found = 1;
2758                     }
2759                 }
2760
2761               if (found)
2762                 ;
2763               else if (!strncmp (p, "fixed-", 6))
2764                 fix_register (&p[6], 1, 1);
2765               else if (!strncmp (p, "call-used-", 10))
2766                 fix_register (&p[10], 0, 1);
2767               else if (!strncmp (p, "call-saved-", 11))
2768                 fix_register (&p[11], 0, 0);
2769               else if (! lang_decode_option (argv[i]))
2770                 error ("Invalid option `%s'", argv[i]);
2771             }
2772           else if (str[0] == 'O')
2773             {
2774               register char *p = str+1;
2775               while (*p && *p >= '0' && *p <= '9')
2776                 p++;
2777               if (*p == '\0')
2778                 ;
2779               else
2780                 error ("Invalid option `%s'", argv[i]);
2781             }
2782           else if (!strcmp (str, "pedantic"))
2783             pedantic = 1;
2784           else if (!strcmp (str, "pedantic-errors"))
2785             flag_pedantic_errors = pedantic = 1;
2786           else if (lang_decode_option (argv[i]))
2787             ;
2788           else if (!strcmp (str, "quiet"))
2789             quiet_flag = 1;
2790           else if (!strcmp (str, "version"))
2791             version_flag = 1;
2792           else if (!strcmp (str, "w"))
2793             inhibit_warnings = 1;
2794           else if (!strcmp (str, "W"))
2795             {
2796               extra_warnings = 1;
2797               warn_uninitialized = 1;
2798             }
2799           else if (str[0] == 'W')
2800             {
2801               int j;
2802               register char *p = &str[1];
2803               int found = 0;
2804
2805               /* Some kind of -W option.
2806                  P's value is the option sans `-W'.
2807                  Search for it in the table of options.  */
2808
2809               for (j = 0;
2810                    !found && j < sizeof (W_options) / sizeof (W_options[0]);
2811                    j++)
2812                 {
2813                   if (!strcmp (p, W_options[j].string))
2814                     {
2815                       *W_options[j].variable = W_options[j].on_value;
2816                       /* A goto here would be cleaner,
2817                          but breaks the vax pcc.  */
2818                       found = 1;
2819                     }
2820                   if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
2821                       && ! strcmp (p+3, W_options[j].string))
2822                     {
2823                       *W_options[j].variable = ! W_options[j].on_value;
2824                       found = 1;
2825                     }
2826                 }
2827
2828               if (found)
2829                 ;
2830               else if (!strncmp (p, "id-clash-", 9))
2831                 {
2832                   char *endp = p + 9;
2833
2834                   while (*endp)
2835                     {
2836                       if (*endp >= '0' && *endp <= '9')
2837                         endp++;
2838                       else
2839                         error ("Invalid option `%s'", argv[i]);
2840                     }
2841                   warn_id_clash = 1;
2842                   id_clash_len = atoi (str + 10);
2843                 }
2844               else
2845                 error ("Invalid option `%s'", argv[i]);
2846             }
2847           else if (!strcmp (str, "p"))
2848             profile_flag = 1;
2849           else if (!strcmp (str, "a"))
2850             {
2851 #if !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
2852               warning ("`-a' option (basic block profile) not supported");
2853 #else
2854               profile_block_flag = 1;
2855 #endif
2856             }
2857           else if (str[0] == 'g')
2858             {
2859               char *p = str + 1;
2860               char *q;
2861               unsigned len;
2862               unsigned level;
2863
2864               while (*p && (*p < '0' || *p > '9'))
2865                 p++;
2866               len = p - str;
2867               q = p;
2868               while (*q && (*q >= '0' && *q <= '9'))
2869                 q++;
2870               if (*p)
2871                 level = atoi (p);
2872               else
2873                 level = 2;      /* default debugging info level */
2874               if (*q || level > 3)
2875                 {
2876                   warning ("invalid debug level specification in option: `-%s'",
2877                            str);
2878                   warning ("no debugging information will be generated");
2879                   level = 0;
2880                 }
2881
2882               /* If more than one debugging type is supported,
2883                  you must define PREFERRED_DEBUGGING_TYPE
2884                  to choose a format in a system-dependent way.  */
2885 #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) \
2886          + defined (DWARF_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO))
2887 #ifdef PREFERRED_DEBUGGING_TYPE
2888               if (!strncmp (str, "ggdb", len))
2889                 write_symbols = PREFERRED_DEBUGGING_TYPE;
2890 #else /* no PREFERRED_DEBUGGING_TYPE */
2891 You Lose!  You must define PREFERRED_DEBUGGING_TYPE!
2892 #endif /* no PREFERRED_DEBUGGING_TYPE */
2893 #endif /* More than one debugger format enabled.  */
2894 #ifdef DBX_DEBUGGING_INFO
2895               if (write_symbols != NO_DEBUG)
2896                 ;
2897               else if (!strncmp (str, "ggdb", len))
2898                 write_symbols = DBX_DEBUG;
2899               else if (!strncmp (str, "gstabs", len))
2900                 write_symbols = DBX_DEBUG;
2901
2902               /* Always enable extensions for -ggdb or -gstabs+, 
2903                  always disable for -gstabs.
2904                  For plain -g, use system-specific default.  */
2905               if (write_symbols == DBX_DEBUG && !strncmp (str, "ggdb", len)
2906                   && len >= 2)
2907                 use_gdb_dbx_extensions = 1;
2908               else if (write_symbols == DBX_DEBUG && !strcmp (str, "gstabs+"))
2909                 use_gdb_dbx_extensions = 1;
2910               else if (write_symbols == DBX_DEBUG
2911                        && !strncmp (str, "gstabs", len) && len >= 2)
2912                 use_gdb_dbx_extensions = 0;
2913               else
2914                 use_gdb_dbx_extensions = DEFAULT_GDB_EXTENSIONS;
2915 #endif /* DBX_DEBUGGING_INFO */
2916 #ifdef DWARF_DEBUGGING_INFO
2917               if (write_symbols != NO_DEBUG)
2918                 ;
2919               else if (!strncmp (str, "ggdb", len))
2920                 write_symbols = DWARF_DEBUG;
2921               /* For orthogonality.  */
2922               else if (!strncmp (str, "gdwarf", len))
2923                 write_symbols = DWARF_DEBUG;
2924 #endif
2925 #ifdef SDB_DEBUGGING_INFO
2926               if (write_symbols != NO_DEBUG)
2927                 ;
2928               else if (!strncmp (str, "ggdb", len))
2929                 write_symbols = SDB_DEBUG;
2930               else if (!strncmp (str, "gcoff", len))
2931                 write_symbols = SDB_DEBUG;
2932 #endif /* SDB_DEBUGGING_INFO */
2933 #ifdef XCOFF_DEBUGGING_INFO
2934               if (write_symbols != NO_DEBUG)
2935                 ;
2936               else if (!strncmp (str, "ggdb", len))
2937                 write_symbols = XCOFF_DEBUG;
2938               else if (!strncmp (str, "gxcoff", len))
2939                 write_symbols = XCOFF_DEBUG;
2940
2941               /* Always enable extensions for -ggdb,
2942                  always disable for -gxcoff.
2943                  For plain -g, use system-specific default.  */
2944               if (write_symbols == XCOFF_DEBUG && !strncmp (str, "ggdb", len)
2945                   && len >= 2)
2946                 use_gdb_dbx_extensions = 1;
2947               else if (write_symbols == DBX_DEBUG
2948                        && !strncmp (str, "gxcoff", len) && len >= 2)
2949                 use_gdb_dbx_extensions = 0;
2950               else
2951                 use_gdb_dbx_extensions = DEFAULT_GDB_EXTENSIONS;
2952 #endif        
2953               if (write_symbols == NO_DEBUG)
2954                 warning ("`-%s' option not supported on this version of GCC", str);
2955               else if (level == 0)
2956                 write_symbols = NO_DEBUG;
2957               else
2958                 debug_info_level = (enum debug_info_level) level;
2959             }
2960           else if (!strcmp (str, "o"))
2961             {
2962               asm_file_name = argv[++i];
2963             }
2964           else if (str[0] == 'G')
2965             {
2966               g_switch_set = TRUE;
2967               g_switch_value = atoi ((str[1] != '\0') ? str+1 : argv[++i]);
2968             }
2969           else if (!strncmp (str, "aux-info", 8))
2970             {
2971               flag_gen_aux_info = 1;
2972               aux_info_file_name = (str[8] != '\0' ? str+8 : argv[++i]);
2973             }
2974           else
2975             error ("Invalid option `%s'", argv[i]);
2976         }
2977       else if (argv[i][0] == '+')
2978         {
2979           if (lang_decode_option (argv[i]))
2980             ;
2981           else
2982             error ("Invalid option `%s'", argv[i]);
2983         }
2984       else
2985         filename = argv[i];
2986     }
2987
2988   /* Inlining does not work if not optimizing,
2989      so force it not to be done.  */
2990   if (optimize == 0)
2991     {
2992       flag_no_inline = 1;
2993       warn_inline = 0;
2994     }
2995
2996 #ifdef OVERRIDE_OPTIONS
2997   /* Some machines may reject certain combinations of options.  */
2998   OVERRIDE_OPTIONS;
2999 #endif
3000
3001   /* Unrolling all loops implies that standard loop unrolling must also
3002      be done.  */
3003   if (flag_unroll_all_loops)
3004     flag_unroll_loops = 1;
3005   /* Loop unrolling requires that strength_reduction be on also.  Silently
3006      turn on strength reduction here if it isn't already on.  Also, the loop
3007      unrolling code assumes that cse will be run after loop, so that must
3008      be turned on also.  */
3009   if (flag_unroll_loops)
3010     {
3011       flag_strength_reduce = 1;
3012       flag_rerun_cse_after_loop = 1;
3013     }
3014
3015   /* Warn about options that are not supported on this machine.  */
3016 #ifndef INSN_SCHEDULING
3017   if (flag_schedule_insns || flag_schedule_insns_after_reload)
3018     warning ("instruction scheduling not supported on this target machine");
3019 #endif
3020 #ifndef DELAY_SLOTS
3021   if (flag_delayed_branch)
3022     warning ("this target machine does not have delayed branches");
3023 #endif
3024
3025   /* If we are in verbose mode, write out the version and maybe all the
3026      option flags in use.  */
3027   if (version_flag)
3028     {
3029       fprintf (stderr, "%s version %s", language_string, version_string);
3030 #ifdef TARGET_VERSION
3031       TARGET_VERSION;
3032 #endif
3033 #ifdef __GNUC__
3034 #ifndef __VERSION__
3035 #define __VERSION__ "[unknown]"
3036 #endif
3037       fprintf (stderr, " compiled by GNU C version %s.\n", __VERSION__);
3038 #else
3039       fprintf (stderr, " compiled by CC.\n");
3040 #endif
3041       if (! quiet_flag)
3042         print_switch_values ();
3043     }
3044
3045   /* Now that register usage is specified, convert it to HARD_REG_SETs.  */
3046   init_reg_sets_1 ();
3047
3048   compile_file (filename);
3049
3050 #ifndef VMS
3051   if (flag_print_mem)
3052     {
3053       char *lim = (char *) sbrk (0);
3054
3055       fprintf (stderr, "Data size %d.\n",
3056                (int) lim - (int) &environ);
3057       fflush (stderr);
3058
3059 #ifdef USG
3060       system ("ps -l 1>&2");
3061 #else /* not USG */
3062       system ("ps v");
3063 #endif /* not USG */
3064     }
3065 #endif /* not VMS */
3066
3067   if (errorcount)
3068     exit (FATAL_EXIT_CODE);
3069   if (sorrycount)
3070     exit (FATAL_EXIT_CODE);
3071   exit (SUCCESS_EXIT_CODE);
3072   return 34;
3073 }
3074 \f
3075 /* Decode -m switches.  */
3076
3077 /* Here is a table, controlled by the tm.h file, listing each -m switch
3078    and which bits in `target_switches' it should set or clear.
3079    If VALUE is positive, it is bits to set.
3080    If VALUE is negative, -VALUE is bits to clear.
3081    (The sign bit is not used so there is no confusion.)  */
3082
3083 struct {char *name; int value;} target_switches []
3084   = TARGET_SWITCHES;
3085
3086 /* This table is similar, but allows the switch to have a value.  */
3087
3088 #ifdef TARGET_OPTIONS
3089 struct {char *prefix; char ** variable;} target_options []
3090   = TARGET_OPTIONS;
3091 #endif
3092
3093 /* Decode the switch -mNAME.  */
3094
3095 void
3096 set_target_switch (name)
3097      char *name;
3098 {
3099   register int j;
3100   int valid = 0;
3101
3102   for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
3103     if (!strcmp (target_switches[j].name, name))
3104       {
3105         if (target_switches[j].value < 0)
3106           target_flags &= ~-target_switches[j].value;
3107         else
3108           target_flags |= target_switches[j].value;
3109         valid = 1;
3110       }
3111
3112 #ifdef TARGET_OPTIONS
3113   if (!valid)
3114     for (j = 0; j < sizeof target_options / sizeof target_options[0]; j++)
3115       {
3116         int len = strlen (target_options[j].prefix);
3117         if (!strncmp (target_options[j].prefix, name, len))
3118           {
3119             *target_options[j].variable = name + len;
3120             valid = 1;
3121           }
3122       }
3123 #endif
3124
3125   if (!valid)
3126     error ("Invalid option `%s'", name);
3127 }
3128 \f
3129 /* Variable used for communication between the following two routines.  */
3130
3131 static int line_position;
3132
3133 /* Print an option value and adjust the position in the line.  */
3134
3135 static void
3136 print_single_switch (type, name)
3137      char *type, *name;
3138 {
3139   fprintf (stderr, " %s%s", type, name);
3140
3141   line_position += strlen (type) + strlen (name) + 1;
3142
3143   if (line_position > 65)
3144     {
3145       fprintf (stderr, "\n\t");
3146       line_position = 8;
3147     }
3148 }
3149      
3150 /* Print default target switches for -version.  */
3151
3152 static void
3153 print_switch_values ()
3154 {
3155   register int j;
3156
3157   fprintf (stderr, "enabled:");
3158   line_position = 8;
3159
3160   for (j = 0; j < sizeof f_options / sizeof f_options[0]; j++)
3161     if (*f_options[j].variable == f_options[j].on_value)
3162       print_single_switch ("-f", f_options[j].string);
3163
3164   for (j = 0; j < sizeof W_options / sizeof W_options[0]; j++)
3165     if (*W_options[j].variable == W_options[j].on_value)
3166       print_single_switch ("-W", W_options[j].string);
3167
3168   for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
3169     if (target_switches[j].name[0] != '\0'
3170         && target_switches[j].value > 0
3171         && ((target_switches[j].value & target_flags)
3172             == target_switches[j].value))
3173       print_single_switch ("-m", target_switches[j].name);
3174
3175   fprintf (stderr, "\n");
3176 }