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