![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to toplev.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to toplev.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 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"
1.1.1.2 root 55:
56: #ifdef XCOFF_DEBUGGING_INFO
57: #include "xcoffout.h"
58: #endif
1.1 root 59:
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:
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:
1.1.1.2 root 190: #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1.1 root 191: /* Nonzero means can use our own extensions to DBX format.
1.1.1.2 root 192: Relevant only when write_symbols == DBX_DEBUG or XCOFF_DEBUG. */
1.1 root 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:
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:
1.1.1.3 ! root 296: /* Nonzero for -fcse-skip-blocks:
! 297: have cse follow a branch around a block. */
! 298: int flag_cse_skip_blocks;
! 299:
1.1 root 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:
1.1.1.3 ! root 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:
1.1 root 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:
1.1.1.2 root 388: /* Specified name of aux-info file. */
389:
390: static char *aux_info_file_name;
391:
1.1 root 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:
1.1.1.3 ! root 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:
1.1 root 443: /* -fgnu-linker specifies use of the GNU linker for initializations.
1.1.1.3 ! root 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
1.1 root 449: int flag_gnu_linker = 1;
1.1.1.3 ! root 450: #endif
1.1 root 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},
1.1.1.3 ! root 465: {"cse-skip-blocks", &flag_cse_skip_blocks, 1},
1.1 root 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},
1.1.1.3 ! root 490: {"fast-math", &flag_fast_math, 1},
1.1 root 491: {"common", &flag_no_common, 0},
492: {"inhibit-size-directive", &flag_inhibit_size_directive, 1},
1.1.1.3 ! root 493: {"verbose-asm", &flag_verbose_asm, 1},
1.1 root 494: {"gnu-linker", &flag_gnu_linker, 1}
495: };
496:
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},
1.1.1.2 root 564: {"uninitialized", &warn_uninitialized, 1},
565: {"inline", &warn_inline, 1}
1.1 root 566: };
567:
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:
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:
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:
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:
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:
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:
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:
1.1.1.3 ! root 1363: #ifdef IO_BUFFER_SIZE
! 1364: setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
! 1365: #endif
! 1366:
1.1 root 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:
1.1.1.2 root 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. */
1.1 root 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:
1.1.1.2 root 1577: #ifdef IO_BUFFER_SIZE
1.1.1.3 ! root 1578: setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
! 1579: _IOFBF, IO_BUFFER_SIZE);
1.1.1.2 root 1580: #endif
1581:
1.1 root 1582: input_filename = name;
1583:
1584: /* Perform language-specific initialization.
1585: This may set main_input_filename. */
1586: lang_init ();
1587:
1588: /* If the input doesn't start with a #line, use the input name
1589: as the official input file name. */
1590: if (main_input_filename == 0)
1591: main_input_filename = name;
1592:
1593: /* Put an entry on the input file stack for the main input file. */
1594: input_file_stack
1595: = (struct file_stack *) xmalloc (sizeof (struct file_stack));
1596: input_file_stack->next = 0;
1597: input_file_stack->name = input_filename;
1598:
1599: ASM_FILE_START (asm_out_file);
1600:
1601: /* Output something to inform GDB that this compilation was by GCC. */
1602: #ifndef ASM_IDENTIFY_GCC
1603: fprintf (asm_out_file, "gcc2_compiled.:\n");
1604: #else
1605: ASM_IDENTIFY_GCC (asm_out_file);
1606: #endif
1607: /* Don't let the first function fall at the same address
1608: as gcc_compiled., if profiling. */
1609: if (profile_flag || profile_block_flag)
1610: assemble_zeros (UNITS_PER_WORD);
1611:
1612: /* If dbx symbol table desired, initialize writing it
1613: and output the predefined types. */
1.1.1.2 root 1614: #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1615: if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1.1 root 1616: TIMEVAR (symout_time, dbxout_init (asm_out_file, main_input_filename,
1617: getdecls ()));
1618: #endif
1619: #ifdef SDB_DEBUGGING_INFO
1620: if (write_symbols == SDB_DEBUG)
1621: TIMEVAR (symout_time, sdbout_init (asm_out_file, main_input_filename,
1622: getdecls ()));
1623: #endif
1624: #ifdef DWARF_DEBUGGING_INFO
1625: if (write_symbols == DWARF_DEBUG)
1626: TIMEVAR (symout_time, dwarfout_init (asm_out_file, main_input_filename));
1627: #endif
1628:
1629: /* Initialize yet another pass. */
1630:
1631: init_final (main_input_filename);
1632:
1633: start_time = get_run_time ();
1634:
1635: /* Call the parser, which parses the entire file
1636: (calling rest_of_compilation for each function). */
1637:
1638: if (yyparse () != 0)
1639: if (errorcount == 0)
1640: fprintf (stderr, "Errors detected in input file (your bison.simple is out of date)");
1641:
1642: /* Compilation is now finished except for writing
1643: what's left of the symbol table output. */
1644:
1645: parse_time += get_run_time () - start_time;
1646:
1647: parse_time -= integration_time;
1648: parse_time -= varconst_time;
1649:
1650: globals = getdecls ();
1651:
1652: /* Really define vars that have had only a tentative definition.
1653: Really output inline functions that must actually be callable
1654: and have not been output so far. */
1655:
1656: {
1657: int len = list_length (globals);
1658: tree *vec = (tree *) alloca (sizeof (tree) * len);
1659: int i;
1660: tree decl;
1661:
1662: /* Process the decls in reverse order--earliest first.
1663: Put them into VEC from back to front, then take out from front. */
1664:
1665: for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1666: vec[len - i - 1] = decl;
1667:
1668: for (i = 0; i < len; i++)
1669: {
1670: decl = vec[i];
1671: if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
1672: && ! TREE_ASM_WRITTEN (decl))
1673: {
1674: /* Don't write out static consts, unless we used them.
1675: (This used to write them out only if the address was
1676: taken, but that was wrong; if the variable was simply
1677: referred to, it still needs to exist or else it will
1678: be undefined in the linker.) */
1679: if (! TREE_READONLY (decl)
1680: || TREE_PUBLIC (decl)
1681: || TREE_USED (decl)
1682: || TREE_ADDRESSABLE (decl)
1683: || TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl)))
1684: rest_of_decl_compilation (decl, 0, 1, 1);
1685: else
1686: /* Cancel the RTL for this decl so that, if debugging info
1687: output for global variables is still to come,
1688: this one will be omitted. */
1689: DECL_RTL (decl) = NULL;
1690: }
1691:
1692: if (TREE_CODE (decl) == FUNCTION_DECL
1693: && ! TREE_ASM_WRITTEN (decl)
1694: && DECL_INITIAL (decl) != 0
1695: && (TREE_ADDRESSABLE (decl)
1696: || TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl)))
1697: && ! TREE_EXTERNAL (decl))
1698: output_inline_function (decl);
1699:
1.1.1.2 root 1700: /* Warn about any function
1701: declared static but not defined.
1702: We don't warn about variables,
1703: because many programs have static variables
1704: that exist only to get some text into the object file. */
1.1 root 1705: if ((warn_unused
1706: || TREE_USED (decl)
1707: || (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl))))
1.1.1.2 root 1708: && TREE_CODE (decl) == FUNCTION_DECL
1.1 root 1709: && DECL_INITIAL (decl) == 0
1710: && TREE_EXTERNAL (decl)
1711: && ! TREE_PUBLIC (decl))
1712: warning_with_decl (decl, "`%s' declared `static' but never defined");
1713: /* Warn about static fns or vars defined but not used,
1714: but not about inline functions
1715: since unused inline statics is normal practice. */
1716: if (warn_unused
1717: && (TREE_CODE (decl) == FUNCTION_DECL
1718: || TREE_CODE (decl) == VAR_DECL)
1719: && ! TREE_EXTERNAL (decl)
1720: && ! TREE_PUBLIC (decl)
1721: && ! TREE_USED (decl)
1722: && ! TREE_INLINE (decl)
1723: /* The TREE_USED bit for file-scope decls
1724: is kept in the identifier, to handle multiple
1725: external decls in different scopes. */
1726: && ! TREE_USED (DECL_NAME (decl)))
1727: warning_with_decl (decl, "`%s' defined but not used");
1728:
1729: #ifdef SDB_DEBUGGING_INFO
1730: /* The COFF linker can move initialized global vars to the end.
1731: And that can screw up the symbol ordering.
1732: By putting the symbols in that order to begin with,
1733: we avoid a problem. [email protected]. */
1734: if (write_symbols == SDB_DEBUG && TREE_CODE (decl) == VAR_DECL
1735: && TREE_PUBLIC (decl) && DECL_INITIAL (decl)
1736: && DECL_RTL (decl) != 0)
1737: TIMEVAR (symout_time, sdbout_symbol (decl, 0));
1738:
1739: /* Output COFF information for non-global
1740: file-scope initialized variables. */
1741: if (write_symbols == SDB_DEBUG
1742: && TREE_CODE (decl) == VAR_DECL
1743: && DECL_INITIAL (decl)
1744: && DECL_RTL (decl) != 0
1745: && GET_CODE (DECL_RTL (decl)) == MEM)
1746: TIMEVAR (symout_time, sdbout_toplevel_data (decl));
1747: #endif /* SDB_DEBUGGING_INFO */
1748: #ifdef DWARF_DEBUGGING_INFO
1.1.1.3 ! root 1749: /* Output DWARF information for file-scope tentative data object
1.1 root 1750: declarations, file-scope (extern) function declarations (which
1751: had no corresponding body) and file-scope tagged type declarations
1752: and definitions which have not yet been forced out. */
1753:
1754: if (write_symbols == DWARF_DEBUG
1755: && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)))
1756: TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 1));
1757: #endif
1758: }
1759: }
1760:
1761: /* Do dbx symbols */
1.1.1.2 root 1762: #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1763: if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1.1 root 1764: TIMEVAR (symout_time,
1765: {
1766: dbxout_finish (asm_out_file, main_input_filename);
1767: });
1768: #endif
1769:
1770: #ifdef DWARF_DEBUGGING_INFO
1771: if (write_symbols == DWARF_DEBUG)
1772: TIMEVAR (symout_time,
1773: {
1774: dwarfout_finish ();
1775: });
1776: #endif
1777:
1778: /* Output some stuff at end of file if nec. */
1779:
1780: end_final (main_input_filename);
1781:
1782: #ifdef ASM_FILE_END
1783: ASM_FILE_END (asm_out_file);
1784: #endif
1785:
1786: after_finish_compilation:
1787:
1788: /* Language-specific end of compilation actions. */
1789:
1790: lang_finish ();
1791:
1792: /* Close the dump files. */
1793:
1794: if (flag_gen_aux_info)
1795: {
1796: fclose (aux_info_file);
1797: if (errorcount)
1798: unlink (aux_info_file_name);
1799: }
1800:
1801: if (rtl_dump)
1802: fclose (rtl_dump_file);
1803:
1804: if (jump_opt_dump)
1805: fclose (jump_opt_dump_file);
1806:
1807: if (cse_dump)
1808: fclose (cse_dump_file);
1809:
1810: if (loop_dump)
1811: fclose (loop_dump_file);
1812:
1813: if (cse2_dump)
1814: fclose (cse2_dump_file);
1815:
1816: if (flow_dump)
1817: fclose (flow_dump_file);
1818:
1819: if (combine_dump)
1820: {
1821: dump_combine_total_stats (combine_dump_file);
1822: fclose (combine_dump_file);
1823: }
1824:
1825: if (sched_dump)
1826: fclose (sched_dump_file);
1827:
1828: if (local_reg_dump)
1829: fclose (local_reg_dump_file);
1830:
1831: if (global_reg_dump)
1832: fclose (global_reg_dump_file);
1833:
1834: if (sched2_dump)
1835: fclose (sched2_dump_file);
1836:
1837: if (jump2_opt_dump)
1838: fclose (jump2_opt_dump_file);
1839:
1840: if (dbr_sched_dump)
1841: fclose (dbr_sched_dump_file);
1842:
1843: #ifdef STACK_REGS
1844: if (stack_reg_dump)
1845: fclose (stack_reg_dump_file);
1846: #endif
1847:
1848: /* Close non-debugging input and output files. Take special care to note
1849: whether fclose returns an error, since the pages might still be on the
1850: buffer chain while the file is open. */
1851:
1852: fclose (finput);
1853: if (ferror (asm_out_file) != 0 || fclose (asm_out_file) != 0)
1854: fatal_io_error (asm_file_name);
1855:
1856: /* Print the times. */
1857:
1858: if (! quiet_flag)
1859: {
1860: fprintf (stderr,"\n");
1861: print_time ("parse", parse_time);
1862: print_time ("integration", integration_time);
1863: print_time ("jump", jump_time);
1864: print_time ("cse", cse_time);
1865: print_time ("loop", loop_time);
1866: print_time ("cse2", cse2_time);
1867: print_time ("flow", flow_time);
1868: print_time ("combine", combine_time);
1869: print_time ("sched", sched_time);
1870: print_time ("local-alloc", local_alloc_time);
1871: print_time ("global-alloc", global_alloc_time);
1872: print_time ("sched2", sched2_time);
1873: print_time ("dbranch", dbr_sched_time);
1874: print_time ("shorten-branch", shorten_branch_time);
1875: print_time ("stack-reg", stack_reg_time);
1876: print_time ("final", final_time);
1877: print_time ("varconst", varconst_time);
1878: print_time ("symout", symout_time);
1879: print_time ("dump", dump_time);
1880: }
1881: }
1882:
1883: /* This is called from various places for FUNCTION_DECL, VAR_DECL,
1884: and TYPE_DECL nodes.
1885:
1886: This does nothing for local (non-static) variables.
1887: Otherwise, it sets up the RTL and outputs any assembler code
1888: (label definition, storage allocation and initialization).
1889:
1890: DECL is the declaration. If ASMSPEC is nonzero, it specifies
1891: the assembler symbol name to be used. TOP_LEVEL is nonzero
1892: if this declaration is not within a function. */
1893:
1894: void
1895: rest_of_decl_compilation (decl, asmspec, top_level, at_end)
1896: tree decl;
1897: char *asmspec;
1898: int top_level;
1899: int at_end;
1900: {
1901: /* Declarations of variables, and of functions defined elsewhere. */
1902:
1903: /* Forward declarations for nested functions are not "external",
1904: but we need to treat them as if they were. */
1905: if (TREE_STATIC (decl) || TREE_EXTERNAL (decl)
1906: || TREE_CODE (decl) == FUNCTION_DECL)
1907: TIMEVAR (varconst_time,
1908: {
1909: make_decl_rtl (decl, asmspec, top_level);
1.1.1.3 ! root 1910: /* For a user-invisible decl that should be replaced
! 1911: by its value when used, don't output anything. */
! 1912: if (! (TREE_CODE (decl) == VAR_DECL
! 1913: && DECL_IGNORED_P (decl) && TREE_READONLY (decl)
! 1914: && DECL_INITIAL (decl) != 0))
! 1915: /* Don't output anything
! 1916: when a tentative file-scope definition is seen.
! 1917: But at end of compilation, do output code for them. */
! 1918: if (! (! at_end && top_level
! 1919: && (DECL_INITIAL (decl) == 0
! 1920: || DECL_INITIAL (decl) == error_mark_node
! 1921: || DECL_IGNORED_P (decl))))
! 1922: assemble_variable (decl, top_level, at_end);
1.1 root 1923: });
1924: else if (TREE_REGDECL (decl) && asmspec != 0)
1925: {
1926: if (decode_reg_name (asmspec) >= 0)
1927: {
1928: DECL_RTL (decl) = 0;
1929: make_decl_rtl (decl, asmspec, top_level);
1930: }
1931: else
1932: error ("invalid register name `%s' for register variable", asmspec);
1933: }
1.1.1.2 root 1934: #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1935: else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1936: && TREE_CODE (decl) == TYPE_DECL)
1.1 root 1937: TIMEVAR (symout_time, dbxout_symbol (decl, 0));
1938: #endif
1939: #ifdef SDB_DEBUGGING_INFO
1940: else if (write_symbols == SDB_DEBUG && top_level
1941: && TREE_CODE (decl) == TYPE_DECL)
1942: TIMEVAR (symout_time, sdbout_symbol (decl, 0));
1943: #endif
1944: }
1945:
1946: /* Called after finishing a record, union or enumeral type. */
1947:
1948: void
1949: rest_of_type_compilation (type, toplev)
1950: tree type;
1951: int toplev;
1952: {
1.1.1.2 root 1953: #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1954: if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1.1 root 1955: TIMEVAR (symout_time, dbxout_symbol (TYPE_STUB_DECL (type), !toplev));
1956: #endif
1957: #ifdef SDB_DEBUGGING_INFO
1958: if (write_symbols == SDB_DEBUG)
1959: TIMEVAR (symout_time, sdbout_symbol (TYPE_STUB_DECL (type), !toplev));
1960: #endif
1961: }
1962:
1963: /* This is called from finish_function (within yyparse)
1964: after each top-level definition is parsed.
1965: It is supposed to compile that function or variable
1966: and output the assembler code for it.
1967: After we return, the tree storage is freed. */
1968:
1969: void
1970: rest_of_compilation (decl)
1971: tree decl;
1972: {
1973: register rtx insns;
1974: int start_time = get_run_time ();
1975: int tem;
1976: /* Nonzero if we have saved the original DECL_INITIAL of the function,
1977: to be restored after we finish compiling the function
1978: (for use when compiling inline calls to this function). */
1979: tree saved_block_tree = 0;
1980:
1981: /* If we are reconsidering an inline function
1982: at the end of compilation, skip the stuff for making it inline. */
1983:
1984: if (DECL_SAVED_INSNS (decl) == 0)
1985: {
1986: int specd = TREE_INLINE (decl);
1987: char *lose;
1988:
1989: /* If requested, consider whether to make this function inline. */
1990: if (specd || flag_inline_functions)
1991: TIMEVAR (integration_time,
1992: {
1993: lose = function_cannot_inline_p (decl);
1994: if (lose)
1995: {
1996: if (warn_inline && specd)
1997: warning_with_decl (decl, lose);
1998: TREE_INLINE (decl) = 0;
1999: }
2000: else
2001: TREE_INLINE (decl) = 1;
2002: });
2003:
2004: insns = get_insns ();
2005:
2006: /* Dump the rtl code if we are dumping rtl. */
2007:
2008: if (rtl_dump)
2009: TIMEVAR (dump_time,
2010: {
2011: fprintf (rtl_dump_file, "\n;; Function %s\n\n",
2012: IDENTIFIER_POINTER (DECL_NAME (decl)));
2013: if (DECL_SAVED_INSNS (decl))
2014: fprintf (rtl_dump_file, ";; (integrable)\n\n");
2015: print_rtl (rtl_dump_file, insns);
2016: fflush (rtl_dump_file);
2017: });
2018:
2019: /* If function is inline, and we don't yet know whether to
2020: compile it by itself, defer decision till end of compilation.
2021: finish_compilation will call rest_of_compilation again
2022: for those functions that need to be output. */
2023:
2024: if (TREE_INLINE (decl)
2025: && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
2026: && ! flag_keep_inline_functions)
2027: || TREE_EXTERNAL (decl)))
2028: {
2029: TIMEVAR (integration_time, save_for_inline_nocopy (decl));
2030: goto exit_rest_of_compilation;
2031: }
2032:
2033: /* If we have to compile the function now, save its rtl
2034: so that its compilation will not affect what others get. */
2035: if (TREE_INLINE (decl))
2036: {
2037: saved_block_tree = DECL_INITIAL (decl);
2038: TIMEVAR (integration_time, save_for_inline_copying (decl));
2039: }
2040: }
2041:
2042: /* Suppress warnings for unused static functions
2043: defined (not just declared) in system headers. */
2044: if (in_system_header && TREE_STATIC (decl) && !TREE_INLINE (decl))
2045: TREE_USED (decl) = 1;
2046:
2047: TREE_ASM_WRITTEN (decl) = 1;
2048:
2049: /* Now that integrate will no longer see our rtl, we need not distinguish
2050: between the return value of this function and the return value of called
2051: functions. */
2052: rtx_equal_function_value_matters = 0;
2053:
1.1.1.3 ! root 2054: /* Don't return yet if -Wreturn-type; we need to do jump_optimize. */
! 2055: if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
1.1 root 2056: {
2057: goto exit_rest_of_compilation;
2058: }
2059:
2060: /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
2061: Note that that may have been done above, in save_for_inline_copying.
2062: The call to resume_temporary_allocation near the end of this function
2063: goes back to the usual state of affairs. */
2064:
2065: rtl_in_current_obstack ();
2066:
2067: #ifdef FINALIZE_PIC
2068: /* If we are doing position-independent code generation, now
2069: is the time to output special prologues and epilogues.
2070: We do not want to do this earlier, because it just clutters
2071: up inline functions with meaningless insns. */
2072: if (flag_pic)
2073: FINALIZE_PIC;
2074: #endif
2075:
2076: insns = get_insns ();
2077:
2078: /* Copy any shared structure that should not be shared. */
2079:
2080: unshare_all_rtl (insns);
2081:
2082: /* Instantiate all virtual registers. */
2083:
2084: instantiate_virtual_regs (current_function_decl, get_insns ());
2085:
2086: /* See if we have allocated stack slots that are not directly addressable.
2087: If so, scan all the insns and create explicit address computation
2088: for all references to such slots. */
2089: /* fixup_stack_slots (); */
2090:
2091: /* Do jump optimization the first time, if -opt.
2092: Also do it if -W, but in that case it doesn't change the rtl code,
2093: it only computes whether control can drop off the end of the function. */
2094:
2095: if (optimize > 0 || extra_warnings || warn_return_type
2096: /* If function is `volatile', we should warn if it tries to return. */
2097: || TREE_THIS_VOLATILE (decl))
2098: {
2099: TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
2100: TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1));
2101: }
2102:
1.1.1.3 ! root 2103: /* Now is when we stop if -fsyntax-only and -Wreturn-type. */
! 2104: if (rtl_dump_and_exit || flag_syntax_only)
! 2105: goto exit_rest_of_compilation;
! 2106:
1.1 root 2107: /* Dump rtl code after jump, if we are doing that. */
2108:
2109: if (jump_opt_dump)
2110: TIMEVAR (dump_time,
2111: {
2112: fprintf (jump_opt_dump_file, "\n;; Function %s\n\n",
2113: IDENTIFIER_POINTER (DECL_NAME (decl)));
2114: print_rtl (jump_opt_dump_file, insns);
2115: fflush (jump_opt_dump_file);
2116: });
2117:
2118: /* Perform common subexpression elimination.
2119: Nonzero value from `cse_main' means that jumps were simplified
2120: and some code may now be unreachable, so do
2121: jump optimization again. */
2122:
2123: if (cse_dump)
2124: TIMEVAR (dump_time,
2125: {
2126: fprintf (cse_dump_file, "\n;; Function %s\n\n",
2127: IDENTIFIER_POINTER (DECL_NAME (decl)));
2128: });
2129:
2130: if (optimize > 0)
2131: {
2132: TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 1));
2133:
2134: if (flag_thread_jumps)
2135: /* Hacks by tiemann & kenner. */
2136: TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0));
2137:
2138: TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (),
2139: 0, cse_dump_file));
2140: TIMEVAR (cse_time, delete_dead_from_cse (insns, max_reg_num ()));
2141:
2142: if (tem)
2143: TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
2144: }
2145:
2146: /* Dump rtl code after cse, if we are doing that. */
2147:
2148: if (cse_dump)
2149: TIMEVAR (dump_time,
2150: {
2151: print_rtl (cse_dump_file, insns);
2152: fflush (cse_dump_file);
2153: });
2154:
2155: if (loop_dump)
2156: TIMEVAR (dump_time,
2157: {
2158: fprintf (loop_dump_file, "\n;; Function %s\n\n",
2159: IDENTIFIER_POINTER (DECL_NAME (decl)));
2160: });
2161:
2162: /* Move constant computations out of loops. */
2163:
2164: if (optimize > 0)
2165: {
2166: TIMEVAR (loop_time,
2167: {
2168: loop_optimize (insns, loop_dump ? loop_dump_file : 0);
2169: });
2170: }
2171:
2172: /* Dump rtl code after loop opt, if we are doing that. */
2173:
2174: if (loop_dump)
2175: TIMEVAR (dump_time,
2176: {
2177: print_rtl (loop_dump_file, insns);
2178: fflush (loop_dump_file);
2179: });
2180:
2181: if (cse2_dump)
2182: TIMEVAR (dump_time,
2183: {
2184: fprintf (cse2_dump_file, "\n;; Function %s\n\n",
2185: IDENTIFIER_POINTER (DECL_NAME (decl)));
2186: });
2187:
2188: if (optimize > 0 && flag_rerun_cse_after_loop)
2189: {
2190: TIMEVAR (cse2_time, reg_scan (insns, max_reg_num (), 0));
2191:
2192: TIMEVAR (cse2_time, tem = cse_main (insns, max_reg_num (),
2193: 1, cse2_dump_file));
2194: if (tem)
2195: TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
2196: }
2197:
2198: if (optimize > 0 && flag_thread_jumps)
2199: /* This pass of jump threading straightens out code
2200: that was kinked by loop optimization. */
2201: TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0));
2202:
2203: /* Dump rtl code after cse, if we are doing that. */
2204:
2205: if (cse2_dump)
2206: TIMEVAR (dump_time,
2207: {
2208: print_rtl (cse2_dump_file, insns);
2209: fflush (cse2_dump_file);
2210: });
2211:
2212: /* We are no longer anticipating cse in this function, at least. */
2213:
2214: cse_not_expected = 1;
2215:
2216: /* Now we choose between stupid (pcc-like) register allocation
2217: (if we got the -noreg switch and not -opt)
2218: and smart register allocation. */
2219:
2220: if (optimize > 0) /* Stupid allocation probably won't work */
2221: obey_regdecls = 0; /* if optimizations being done. */
2222:
2223: regclass_init ();
2224:
2225: /* Print function header into flow dump now
2226: because doing the flow analysis makes some of the dump. */
2227:
2228: if (flow_dump)
2229: TIMEVAR (dump_time,
2230: {
2231: fprintf (flow_dump_file, "\n;; Function %s\n\n",
2232: IDENTIFIER_POINTER (DECL_NAME (decl)));
2233: });
2234:
2235: if (obey_regdecls)
2236: {
2237: TIMEVAR (flow_time,
2238: {
2239: regclass (insns, max_reg_num ());
2240: stupid_life_analysis (insns, max_reg_num (),
2241: flow_dump_file);
2242: });
2243: }
2244: else
2245: {
2246: /* Do control and data flow analysis,
2247: and write some of the results to dump file. */
2248:
2249: TIMEVAR (flow_time, flow_analysis (insns, max_reg_num (),
2250: flow_dump_file));
2251: if (warn_uninitialized)
2252: {
2253: uninitialized_vars_warning (DECL_INITIAL (decl));
2254: setjmp_args_warning ();
2255: }
2256: }
2257:
2258: /* Dump rtl after flow analysis. */
2259:
2260: if (flow_dump)
2261: TIMEVAR (dump_time,
2262: {
2263: print_rtl (flow_dump_file, insns);
2264: fflush (flow_dump_file);
2265: });
2266:
2267: /* If -opt, try combining insns through substitution. */
2268:
2269: if (optimize > 0)
2270: TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ()));
2271:
2272: /* Dump rtl code after insn combination. */
2273:
2274: if (combine_dump)
2275: TIMEVAR (dump_time,
2276: {
2277: fprintf (combine_dump_file, "\n;; Function %s\n\n",
2278: IDENTIFIER_POINTER (DECL_NAME (decl)));
2279: dump_combine_stats (combine_dump_file);
2280: print_rtl (combine_dump_file, insns);
2281: fflush (combine_dump_file);
2282: });
2283:
2284: /* Print function header into sched dump now
2285: because doing the sched analysis makes some of the dump. */
2286:
2287: if (sched_dump)
2288: TIMEVAR (dump_time,
2289: {
2290: fprintf (sched_dump_file, "\n;; Function %s\n\n",
2291: IDENTIFIER_POINTER (DECL_NAME (decl)));
2292: });
2293:
2294: if (optimize > 0 && flag_schedule_insns)
2295: {
2296: /* Do control and data sched analysis,
2297: and write some of the results to dump file. */
2298:
2299: TIMEVAR (sched_time, schedule_insns (sched_dump_file));
2300: }
2301:
2302: /* Dump rtl after instruction scheduling. */
2303:
2304: if (sched_dump)
2305: TIMEVAR (dump_time,
2306: {
2307: print_rtl (sched_dump_file, insns);
2308: fflush (sched_dump_file);
2309: });
2310:
2311: /* Unless we did stupid register allocation,
2312: allocate pseudo-regs that are used only within 1 basic block. */
2313:
2314: if (!obey_regdecls)
2315: TIMEVAR (local_alloc_time,
2316: {
2317: regclass (insns, max_reg_num ());
2318: local_alloc ();
2319: });
2320:
2321: /* Dump rtl code after allocating regs within basic blocks. */
2322:
2323: if (local_reg_dump)
2324: TIMEVAR (dump_time,
2325: {
2326: fprintf (local_reg_dump_file, "\n;; Function %s\n\n",
2327: IDENTIFIER_POINTER (DECL_NAME (decl)));
2328: dump_flow_info (local_reg_dump_file);
2329: dump_local_alloc (local_reg_dump_file);
2330: print_rtl (local_reg_dump_file, insns);
2331: fflush (local_reg_dump_file);
2332: });
2333:
2334: if (global_reg_dump)
2335: TIMEVAR (dump_time,
2336: fprintf (global_reg_dump_file, "\n;; Function %s\n\n",
2337: IDENTIFIER_POINTER (DECL_NAME (decl))));
2338:
2339: /* Unless we did stupid register allocation,
2340: allocate remaining pseudo-regs, then do the reload pass
2341: fixing up any insns that are invalid. */
2342:
2343: TIMEVAR (global_alloc_time,
2344: {
2345: if (!obey_regdecls)
2346: global_alloc (global_reg_dump ? global_reg_dump_file : 0);
2347: else
2348: reload (insns, 0,
2349: global_reg_dump ? global_reg_dump_file : 0);
2350: });
2351:
2352: if (global_reg_dump)
2353: TIMEVAR (dump_time,
2354: {
2355: dump_global_regs (global_reg_dump_file);
2356: print_rtl (global_reg_dump_file, insns);
2357: fflush (global_reg_dump_file);
2358: });
2359:
2360: reload_completed = 1;
2361:
2362: if (optimize > 0 && flag_schedule_insns_after_reload)
2363: {
2364: if (sched2_dump)
2365: TIMEVAR (dump_time,
2366: {
2367: fprintf (sched2_dump_file, "\n;; Function %s\n\n",
2368: IDENTIFIER_POINTER (DECL_NAME (decl)));
2369: });
2370:
2371: /* Do control and data sched analysis again,
2372: and write some more of the results to dump file. */
2373:
2374: TIMEVAR (sched2_time, schedule_insns (sched2_dump_file));
2375:
2376: /* Dump rtl after post-reorder instruction scheduling. */
2377:
2378: if (sched2_dump)
2379: TIMEVAR (dump_time,
2380: {
2381: print_rtl (sched2_dump_file, insns);
2382: fflush (sched2_dump_file);
2383: });
2384: }
2385:
2386: #ifdef LEAF_REGISTERS
2387: leaf_function = 0;
2388: if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
2389: leaf_function = 1;
2390: #endif
2391:
2392: /* One more attempt to remove jumps to .+1
2393: left by dead-store-elimination.
2394: Also do cross-jumping this time
2395: and delete no-op move insns. */
2396:
2397: if (optimize > 0)
2398: {
2399: TIMEVAR (jump_time, jump_optimize (insns, 1, 1, 0));
2400: }
2401:
2402: /* Dump rtl code after jump, if we are doing that. */
2403:
2404: if (jump2_opt_dump)
2405: TIMEVAR (dump_time,
2406: {
2407: fprintf (jump2_opt_dump_file, "\n;; Function %s\n\n",
2408: IDENTIFIER_POINTER (DECL_NAME (decl)));
2409: print_rtl (jump2_opt_dump_file, insns);
2410: fflush (jump2_opt_dump_file);
2411: });
2412:
2413: /* If a scheduling pass for delayed branches is to be done,
2414: call the scheduling code. */
2415:
2416: #ifdef DELAY_SLOTS
2417: if (optimize > 0 && flag_delayed_branch)
2418: {
2419: TIMEVAR (dbr_sched_time, dbr_schedule (insns, dbr_sched_dump_file));
2420: if (dbr_sched_dump)
2421: {
2422: TIMEVAR (dump_time,
2423: {
2424: fprintf (dbr_sched_dump_file, "\n;; Function %s\n\n",
2425: IDENTIFIER_POINTER (DECL_NAME (decl)));
2426: print_rtl (dbr_sched_dump_file, insns);
2427: fflush (dbr_sched_dump_file);
2428: });
2429: }
2430: }
2431: #endif
2432:
2433: if (optimize > 0)
2434: /* Shorten branches. */
2435: TIMEVAR (shorten_branch_time,
2436: {
2437: shorten_branches (get_insns ());
2438: });
2439:
2440: #ifdef STACK_REGS
2441: TIMEVAR (stack_reg_time, reg_to_stack (insns, stack_reg_dump_file));
2442: if (stack_reg_dump)
2443: {
2444: TIMEVAR (dump_time,
2445: {
2446: fprintf (stack_reg_dump_file, "\n;; Function %s\n\n",
2447: IDENTIFIER_POINTER (DECL_NAME (decl)));
2448: print_rtl (stack_reg_dump_file, insns);
2449: fflush (stack_reg_dump_file);
2450: });
2451: }
2452: #endif
2453:
2454: /* Now turn the rtl into assembler code. */
2455:
2456: TIMEVAR (final_time,
2457: {
2458: rtx x;
2459: char *fnname;
2460:
2461: /* Get the function's name, as described by its RTL.
2462: This may be different from the DECL_NAME name used
2463: in the source file. */
2464:
2465: x = DECL_RTL (decl);
2466: if (GET_CODE (x) != MEM)
2467: abort ();
2468: x = XEXP (x, 0);
2469: if (GET_CODE (x) != SYMBOL_REF)
2470: abort ();
2471: fnname = XSTR (x, 0);
2472:
2473: assemble_start_function (decl, fnname);
2474: final_start_function (insns, asm_out_file, optimize);
2475: final (insns, asm_out_file, optimize, 0);
2476: final_end_function (insns, asm_out_file, optimize);
2477: assemble_end_function (decl, fnname);
2478: fflush (asm_out_file);
2479: });
2480:
2481: /* Write DBX symbols if requested */
2482:
2483: /* Note that for those inline functions where we don't initially
2484: know for certain that we will be generating an out-of-line copy,
2485: the first invocation of this routine (rest_of_compilation) will
2486: skip over this code by doing a `goto exit_rest_of_compilation;'.
2487: Later on, finish_compilation will call rest_of_compilation again
2488: for those inline functions that need to have out-of-line copies
2489: generated. During that call, we *will* be routed past here. */
2490:
2491: #ifdef DBX_DEBUGGING_INFO
2492: if (write_symbols == DBX_DEBUG)
2493: TIMEVAR (symout_time, dbxout_function (decl));
2494: #endif
2495:
2496: #ifdef DWARF_DEBUGGING_INFO
2497: if (write_symbols == DWARF_DEBUG)
2498: TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
2499: #endif
2500:
2501: exit_rest_of_compilation:
2502:
1.1.1.2 root 2503: /* In case the function was not output,
2504: don't leave any temporary anonymous types
2505: queued up for sdb output. */
2506: #ifdef SDB_DEBUGGING_INFO
2507: if (write_symbols == SDB_DEBUG)
2508: sdbout_types (0);
2509: #endif
2510:
1.1 root 2511: /* Put back the tree of subblocks from before we copied it.
2512: Code generation and the output of debugging info may have modified
2513: the copy, but the original is unchanged. */
2514:
2515: if (saved_block_tree != 0)
2516: DECL_INITIAL (decl) = saved_block_tree;
2517:
2518: reload_completed = 0;
2519:
2520: /* Clear out the real_constant_chain before some of the rtx's
2521: it runs through become garbage. */
2522:
2523: clear_const_double_mem ();
2524:
2525: /* Cancel the effect of rtl_in_current_obstack. */
2526:
2527: resume_temporary_allocation ();
2528:
2529: /* The parsing time is all the time spent in yyparse
2530: *except* what is spent in this function. */
2531:
2532: parse_time -= get_run_time () - start_time;
2533: }
2534:
2535: /* Entry point of cc1/c++. Decode command args, then call compile_file.
2536: Exit code is 35 if can't open files, 34 if fatal error,
2537: 33 if had nonfatal errors, else success. */
2538:
2539: int
2540: main (argc, argv, envp)
2541: int argc;
2542: char **argv;
2543: char **envp;
2544: {
2545: register int i;
2546: char *filename = 0;
2547: int flag_print_mem = 0;
2548: int version_flag = 0;
2549: char *p;
2550:
2551: /* save in case md file wants to emit args as a comment. */
2552: save_argc = argc;
2553: save_argv = argv;
2554:
2555: p = argv[0] + strlen (argv[0]);
2556: while (p != argv[0] && p[-1] != '/') --p;
2557: progname = p;
2558:
2559: #ifdef RLIMIT_STACK
2560: /* Get rid of any avoidable limit on stack size. */
2561: {
2562: struct rlimit rlim;
2563:
2564: /* Set the stack limit huge so that alloca does not fail. */
2565: getrlimit (RLIMIT_STACK, &rlim);
2566: rlim.rlim_cur = rlim.rlim_max;
2567: setrlimit (RLIMIT_STACK, &rlim);
2568: }
2569: #endif /* RLIMIT_STACK */
2570:
2571: signal (SIGFPE, float_signal);
2572:
2573: signal (SIGPIPE, pipe_closed);
2574:
2575: decl_printable_name = decl_name;
2576: lang_expand_expr = (struct rtx_def *(*)()) do_abort;
2577:
2578: /* Initialize whether `char' is signed. */
2579: flag_signed_char = DEFAULT_SIGNED_CHAR;
2580: #ifdef DEFAULT_SHORT_ENUMS
2581: /* Initialize how much space enums occupy, by default. */
2582: flag_short_enums = DEFAULT_SHORT_ENUMS;
2583: #endif
2584:
2585: /* Scan to see what optimization level has been specified. That will
2586: determine the default value of many flags. */
2587: for (i = 1; i < argc; i++)
2588: {
2589: if (!strcmp (argv[i], "-O"))
2590: {
2591: optimize = 1;
2592: }
2593: else if (argv[i][0] == '-' && argv[i][1] == 'O')
2594: {
2595: /* Handle -O2, -O3, -O69, ... */
2596: char *p = &argv[i][2];
2597: int c;
2598:
2599: while (c = *p++)
2600: if (! (c >= '0' && c <= '9'))
2601: break;
2602: if (c == 0)
2603: optimize = atoi (&argv[i][2]);
2604: }
2605: }
2606:
2607: obey_regdecls = (optimize == 0);
1.1.1.2 root 2608: if (optimize == 0)
2609: {
2610: flag_no_inline = 1;
2611: warn_inline = 0;
2612: }
1.1 root 2613:
2614: if (optimize >= 1)
2615: {
2616: flag_thread_jumps = 1;
2617: #ifdef DELAY_SLOTS
2618: flag_delayed_branch = 1;
2619: #endif
2620: }
2621:
2622: if (optimize >= 2)
2623: {
2624: flag_cse_follow_jumps = 1;
1.1.1.3 ! root 2625: flag_cse_skip_blocks = 1;
1.1 root 2626: flag_expensive_optimizations = 1;
2627: flag_strength_reduce = 1;
2628: flag_rerun_cse_after_loop = 1;
1.1.1.2 root 2629: flag_caller_saves = 1;
1.1 root 2630: #ifdef INSN_SCHEDULING
2631: flag_schedule_insns = 1;
2632: flag_schedule_insns_after_reload = 1;
2633: #endif
2634: }
2635:
2636: #ifdef OPTIMIZATION_OPTIONS
2637: /* Allow default optimizations to be specified on a per-machine basis. */
2638: OPTIMIZATION_OPTIONS (optimize);
2639: #endif
2640:
2641: /* Initialize register usage now so switches may override. */
2642: init_reg_sets ();
2643:
2644: target_flags = 0;
2645: set_target_switch ("");
2646:
2647: for (i = 1; i < argc; i++)
2648: {
2649: if (argv[i][0] == '-' && argv[i][1] != 0)
2650: {
2651: register char *str = argv[i] + 1;
2652: if (str[0] == 'Y')
2653: str++;
2654:
2655: if (str[0] == 'm')
2656: set_target_switch (&str[1]);
2657: else if (!strcmp (str, "dumpbase"))
2658: {
2659: dump_base_name = argv[++i];
2660: }
2661: else if (str[0] == 'd')
2662: {
2663: register char *p = &str[1];
2664: while (*p)
2665: switch (*p++)
2666: {
2667: case 'a':
2668: combine_dump = 1;
2669: dbr_sched_dump = 1;
2670: flow_dump = 1;
2671: global_reg_dump = 1;
2672: jump_opt_dump = 1;
2673: jump2_opt_dump = 1;
2674: local_reg_dump = 1;
2675: loop_dump = 1;
2676: rtl_dump = 1;
2677: cse_dump = 1, cse2_dump = 1;
2678: sched_dump = 1;
2679: sched2_dump = 1;
2680: stack_reg_dump = 1;
2681: break;
2682: case 'k':
2683: stack_reg_dump = 1;
2684: break;
2685: case 'c':
2686: combine_dump = 1;
2687: break;
2688: case 'd':
2689: dbr_sched_dump = 1;
2690: break;
2691: case 'f':
2692: flow_dump = 1;
2693: break;
2694: case 'g':
2695: global_reg_dump = 1;
2696: break;
2697: case 'j':
2698: jump_opt_dump = 1;
2699: break;
2700: case 'J':
2701: jump2_opt_dump = 1;
2702: break;
2703: case 'l':
2704: local_reg_dump = 1;
2705: break;
2706: case 'L':
2707: loop_dump = 1;
2708: break;
2709: case 'm':
2710: flag_print_mem = 1;
2711: break;
2712: case 'p':
2713: flag_print_asm_name = 1;
2714: break;
2715: case 'r':
2716: rtl_dump = 1;
2717: break;
2718: case 's':
2719: cse_dump = 1;
2720: break;
2721: case 't':
2722: cse2_dump = 1;
2723: break;
2724: case 'S':
2725: sched_dump = 1;
2726: break;
2727: case 'R':
2728: sched2_dump = 1;
2729: break;
2730: case 'y':
2731: set_yydebug (1);
2732: break;
2733:
2734: case 'x':
2735: rtl_dump_and_exit = 1;
2736: break;
2737: }
2738: }
2739: else if (str[0] == 'f')
2740: {
2741: int j;
2742: register char *p = &str[1];
2743: int found = 0;
2744:
2745: /* Some kind of -f option.
2746: P's value is the option sans `-f'.
2747: Search for it in the table of options. */
2748:
2749: for (j = 0;
2750: !found && j < sizeof (f_options) / sizeof (f_options[0]);
2751: j++)
2752: {
2753: if (!strcmp (p, f_options[j].string))
2754: {
2755: *f_options[j].variable = f_options[j].on_value;
2756: /* A goto here would be cleaner,
2757: but breaks the vax pcc. */
2758: found = 1;
2759: }
2760: if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
2761: && ! strcmp (p+3, f_options[j].string))
2762: {
2763: *f_options[j].variable = ! f_options[j].on_value;
2764: found = 1;
2765: }
2766: }
2767:
2768: if (found)
2769: ;
2770: else if (!strncmp (p, "fixed-", 6))
2771: fix_register (&p[6], 1, 1);
2772: else if (!strncmp (p, "call-used-", 10))
2773: fix_register (&p[10], 0, 1);
2774: else if (!strncmp (p, "call-saved-", 11))
2775: fix_register (&p[11], 0, 0);
2776: else if (! lang_decode_option (argv[i]))
2777: error ("Invalid option `%s'", argv[i]);
2778: }
2779: else if (str[0] == 'O')
2780: {
2781: register char *p = str+1;
2782: while (*p && *p >= '0' && *p <= '9')
2783: p++;
2784: if (*p == '\0')
2785: ;
2786: else
2787: error ("Invalid option `%s'", argv[i]);
2788: }
2789: else if (!strcmp (str, "pedantic"))
2790: pedantic = 1;
2791: else if (!strcmp (str, "pedantic-errors"))
2792: flag_pedantic_errors = pedantic = 1;
2793: else if (lang_decode_option (argv[i]))
2794: ;
2795: else if (!strcmp (str, "quiet"))
2796: quiet_flag = 1;
2797: else if (!strcmp (str, "version"))
2798: version_flag = 1;
2799: else if (!strcmp (str, "w"))
2800: inhibit_warnings = 1;
2801: else if (!strcmp (str, "W"))
2802: {
2803: extra_warnings = 1;
2804: warn_uninitialized = 1;
2805: }
2806: else if (str[0] == 'W')
2807: {
2808: int j;
2809: register char *p = &str[1];
2810: int found = 0;
2811:
2812: /* Some kind of -W option.
2813: P's value is the option sans `-W'.
2814: Search for it in the table of options. */
2815:
2816: for (j = 0;
2817: !found && j < sizeof (W_options) / sizeof (W_options[0]);
2818: j++)
2819: {
2820: if (!strcmp (p, W_options[j].string))
2821: {
2822: *W_options[j].variable = W_options[j].on_value;
2823: /* A goto here would be cleaner,
2824: but breaks the vax pcc. */
2825: found = 1;
2826: }
2827: if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
2828: && ! strcmp (p+3, W_options[j].string))
2829: {
2830: *W_options[j].variable = ! W_options[j].on_value;
2831: found = 1;
2832: }
2833: }
2834:
2835: if (found)
2836: ;
2837: else if (!strncmp (p, "id-clash-", 9))
2838: {
2839: char *endp = p + 9;
2840:
2841: while (*endp)
2842: {
2843: if (*endp >= '0' && *endp <= '9')
2844: endp++;
2845: else
2846: error ("Invalid option `%s'", argv[i]);
2847: }
2848: warn_id_clash = 1;
2849: id_clash_len = atoi (str + 10);
2850: }
2851: else
2852: error ("Invalid option `%s'", argv[i]);
2853: }
2854: else if (!strcmp (str, "p"))
2855: profile_flag = 1;
2856: else if (!strcmp (str, "a"))
2857: {
2858: #if !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
2859: warning ("`-a' option (basic block profile) not supported");
2860: #else
2861: profile_block_flag = 1;
2862: #endif
2863: }
2864: else if (str[0] == 'g')
2865: {
2866: char *p = str + 1;
2867: char *q;
2868: unsigned len;
2869: unsigned level;
2870:
2871: while (*p && (*p < '0' || *p > '9'))
2872: p++;
2873: len = p - str;
2874: q = p;
2875: while (*q && (*q >= '0' && *q <= '9'))
2876: q++;
2877: if (*p)
2878: level = atoi (p);
2879: else
2880: level = 2; /* default debugging info level */
2881: if (*q || level > 3)
2882: {
2883: warning ("invalid debug level specification in option: `-%s'",
2884: str);
2885: warning ("no debugging information will be generated");
2886: level = 0;
2887: }
2888:
2889: /* If more than one debugging type is supported,
2890: you must define PREFERRED_DEBUGGING_TYPE
2891: to choose a format in a system-dependent way. */
2892: #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) \
1.1.1.2 root 2893: + defined (DWARF_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO))
1.1 root 2894: #ifdef PREFERRED_DEBUGGING_TYPE
2895: if (!strncmp (str, "ggdb", len))
2896: write_symbols = PREFERRED_DEBUGGING_TYPE;
2897: #else /* no PREFERRED_DEBUGGING_TYPE */
2898: You Lose! You must define PREFERRED_DEBUGGING_TYPE!
2899: #endif /* no PREFERRED_DEBUGGING_TYPE */
2900: #endif /* More than one debugger format enabled. */
2901: #ifdef DBX_DEBUGGING_INFO
2902: if (write_symbols != NO_DEBUG)
2903: ;
2904: else if (!strncmp (str, "ggdb", len))
2905: write_symbols = DBX_DEBUG;
2906: else if (!strncmp (str, "gstabs", len))
2907: write_symbols = DBX_DEBUG;
2908:
2909: /* Always enable extensions for -ggdb or -gstabs+,
2910: always disable for -gstabs.
2911: For plain -g, use system-specific default. */
2912: if (write_symbols == DBX_DEBUG && !strncmp (str, "ggdb", len)
2913: && len >= 2)
2914: use_gdb_dbx_extensions = 1;
2915: else if (write_symbols == DBX_DEBUG && !strcmp (str, "gstabs+"))
2916: use_gdb_dbx_extensions = 1;
2917: else if (write_symbols == DBX_DEBUG
2918: && !strncmp (str, "gstabs", len) && len >= 2)
2919: use_gdb_dbx_extensions = 0;
2920: else
2921: use_gdb_dbx_extensions = DEFAULT_GDB_EXTENSIONS;
2922: #endif /* DBX_DEBUGGING_INFO */
2923: #ifdef DWARF_DEBUGGING_INFO
2924: if (write_symbols != NO_DEBUG)
2925: ;
2926: else if (!strncmp (str, "ggdb", len))
2927: write_symbols = DWARF_DEBUG;
2928: /* For orthogonality. */
2929: else if (!strncmp (str, "gdwarf", len))
2930: write_symbols = DWARF_DEBUG;
2931: #endif
2932: #ifdef SDB_DEBUGGING_INFO
2933: if (write_symbols != NO_DEBUG)
2934: ;
2935: else if (!strncmp (str, "ggdb", len))
2936: write_symbols = SDB_DEBUG;
2937: else if (!strncmp (str, "gcoff", len))
2938: write_symbols = SDB_DEBUG;
2939: #endif /* SDB_DEBUGGING_INFO */
1.1.1.2 root 2940: #ifdef XCOFF_DEBUGGING_INFO
2941: if (write_symbols != NO_DEBUG)
2942: ;
2943: else if (!strncmp (str, "ggdb", len))
2944: write_symbols = XCOFF_DEBUG;
2945: else if (!strncmp (str, "gxcoff", len))
2946: write_symbols = XCOFF_DEBUG;
2947:
2948: /* Always enable extensions for -ggdb,
2949: always disable for -gxcoff.
2950: For plain -g, use system-specific default. */
2951: if (write_symbols == XCOFF_DEBUG && !strncmp (str, "ggdb", len)
2952: && len >= 2)
2953: use_gdb_dbx_extensions = 1;
1.1.1.3 ! root 2954: else if (write_symbols == XCOFF_DEBUG
1.1.1.2 root 2955: && !strncmp (str, "gxcoff", len) && len >= 2)
2956: use_gdb_dbx_extensions = 0;
2957: else
2958: use_gdb_dbx_extensions = DEFAULT_GDB_EXTENSIONS;
2959: #endif
1.1 root 2960: if (write_symbols == NO_DEBUG)
2961: warning ("`-%s' option not supported on this version of GCC", str);
2962: else if (level == 0)
2963: write_symbols = NO_DEBUG;
2964: else
1.1.1.3 ! root 2965: debug_info_level = (enum debug_info_level) level;
1.1 root 2966: }
2967: else if (!strcmp (str, "o"))
2968: {
2969: asm_file_name = argv[++i];
2970: }
2971: else if (str[0] == 'G')
2972: {
2973: g_switch_set = TRUE;
2974: g_switch_value = atoi ((str[1] != '\0') ? str+1 : argv[++i]);
2975: }
1.1.1.2 root 2976: else if (!strncmp (str, "aux-info", 8))
2977: {
2978: flag_gen_aux_info = 1;
2979: aux_info_file_name = (str[8] != '\0' ? str+8 : argv[++i]);
2980: }
1.1 root 2981: else
2982: error ("Invalid option `%s'", argv[i]);
2983: }
2984: else if (argv[i][0] == '+')
2985: {
2986: if (lang_decode_option (argv[i]))
2987: ;
2988: else
2989: error ("Invalid option `%s'", argv[i]);
2990: }
2991: else
2992: filename = argv[i];
2993: }
2994:
1.1.1.2 root 2995: /* Inlining does not work if not optimizing,
2996: so force it not to be done. */
2997: if (optimize == 0)
2998: {
2999: flag_no_inline = 1;
3000: warn_inline = 0;
3001: }
3002:
1.1 root 3003: #ifdef OVERRIDE_OPTIONS
3004: /* Some machines may reject certain combinations of options. */
3005: OVERRIDE_OPTIONS;
3006: #endif
3007:
3008: /* Unrolling all loops implies that standard loop unrolling must also
3009: be done. */
3010: if (flag_unroll_all_loops)
3011: flag_unroll_loops = 1;
3012: /* Loop unrolling requires that strength_reduction be on also. Silently
3013: turn on strength reduction here if it isn't already on. Also, the loop
3014: unrolling code assumes that cse will be run after loop, so that must
3015: be turned on also. */
3016: if (flag_unroll_loops)
3017: {
3018: flag_strength_reduce = 1;
3019: flag_rerun_cse_after_loop = 1;
3020: }
3021:
3022: /* Warn about options that are not supported on this machine. */
3023: #ifndef INSN_SCHEDULING
3024: if (flag_schedule_insns || flag_schedule_insns_after_reload)
3025: warning ("instruction scheduling not supported on this target machine");
3026: #endif
3027: #ifndef DELAY_SLOTS
3028: if (flag_delayed_branch)
3029: warning ("this target machine does not have delayed branches");
3030: #endif
3031:
3032: /* If we are in verbose mode, write out the version and maybe all the
3033: option flags in use. */
3034: if (version_flag)
3035: {
3036: fprintf (stderr, "%s version %s", language_string, version_string);
3037: #ifdef TARGET_VERSION
3038: TARGET_VERSION;
3039: #endif
3040: #ifdef __GNUC__
3041: #ifndef __VERSION__
3042: #define __VERSION__ "[unknown]"
3043: #endif
3044: fprintf (stderr, " compiled by GNU C version %s.\n", __VERSION__);
3045: #else
3046: fprintf (stderr, " compiled by CC.\n");
3047: #endif
3048: if (! quiet_flag)
3049: print_switch_values ();
3050: }
3051:
3052: /* Now that register usage is specified, convert it to HARD_REG_SETs. */
3053: init_reg_sets_1 ();
3054:
3055: compile_file (filename);
3056:
1.1.1.3 ! root 3057: #ifndef OS2
1.1 root 3058: #ifndef VMS
3059: if (flag_print_mem)
3060: {
3061: char *lim = (char *) sbrk (0);
3062:
3063: fprintf (stderr, "Data size %d.\n",
3064: (int) lim - (int) &environ);
3065: fflush (stderr);
3066:
3067: #ifdef USG
3068: system ("ps -l 1>&2");
3069: #else /* not USG */
3070: system ("ps v");
3071: #endif /* not USG */
3072: }
3073: #endif /* not VMS */
1.1.1.3 ! root 3074: #endif /* not OS2 */
1.1 root 3075:
3076: if (errorcount)
3077: exit (FATAL_EXIT_CODE);
3078: if (sorrycount)
3079: exit (FATAL_EXIT_CODE);
3080: exit (SUCCESS_EXIT_CODE);
3081: return 34;
3082: }
3083:
3084: /* Decode -m switches. */
3085:
3086: /* Here is a table, controlled by the tm.h file, listing each -m switch
3087: and which bits in `target_switches' it should set or clear.
3088: If VALUE is positive, it is bits to set.
3089: If VALUE is negative, -VALUE is bits to clear.
3090: (The sign bit is not used so there is no confusion.) */
3091:
3092: struct {char *name; int value;} target_switches []
3093: = TARGET_SWITCHES;
3094:
3095: /* This table is similar, but allows the switch to have a value. */
3096:
3097: #ifdef TARGET_OPTIONS
3098: struct {char *prefix; char ** variable;} target_options []
3099: = TARGET_OPTIONS;
3100: #endif
3101:
3102: /* Decode the switch -mNAME. */
3103:
3104: void
3105: set_target_switch (name)
3106: char *name;
3107: {
3108: register int j;
3109: int valid = 0;
3110:
3111: for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
3112: if (!strcmp (target_switches[j].name, name))
3113: {
3114: if (target_switches[j].value < 0)
3115: target_flags &= ~-target_switches[j].value;
3116: else
3117: target_flags |= target_switches[j].value;
3118: valid = 1;
3119: }
3120:
3121: #ifdef TARGET_OPTIONS
3122: if (!valid)
3123: for (j = 0; j < sizeof target_options / sizeof target_options[0]; j++)
3124: {
3125: int len = strlen (target_options[j].prefix);
3126: if (!strncmp (target_options[j].prefix, name, len))
3127: {
3128: *target_options[j].variable = name + len;
3129: valid = 1;
3130: }
3131: }
3132: #endif
3133:
3134: if (!valid)
3135: error ("Invalid option `%s'", name);
3136: }
3137:
3138: /* Variable used for communication between the following two routines. */
3139:
3140: static int line_position;
3141:
3142: /* Print an option value and adjust the position in the line. */
3143:
3144: static void
3145: print_single_switch (type, name)
3146: char *type, *name;
3147: {
3148: fprintf (stderr, " %s%s", type, name);
3149:
3150: line_position += strlen (type) + strlen (name) + 1;
3151:
3152: if (line_position > 65)
3153: {
3154: fprintf (stderr, "\n\t");
3155: line_position = 8;
3156: }
3157: }
3158:
3159: /* Print default target switches for -version. */
3160:
3161: static void
3162: print_switch_values ()
3163: {
3164: register int j;
3165:
3166: fprintf (stderr, "enabled:");
3167: line_position = 8;
3168:
3169: for (j = 0; j < sizeof f_options / sizeof f_options[0]; j++)
3170: if (*f_options[j].variable == f_options[j].on_value)
3171: print_single_switch ("-f", f_options[j].string);
3172:
3173: for (j = 0; j < sizeof W_options / sizeof W_options[0]; j++)
3174: if (*W_options[j].variable == W_options[j].on_value)
3175: print_single_switch ("-W", W_options[j].string);
3176:
3177: for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
3178: if (target_switches[j].name[0] != '\0'
3179: && target_switches[j].value > 0
3180: && ((target_switches[j].value & target_flags)
3181: == target_switches[j].value))
3182: print_single_switch ("-m", target_switches[j].name);
3183:
3184: fprintf (stderr, "\n");
3185: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.