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