![[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 [Research Unix] / researchv10dc / cmd / gcc|
Return to toplev.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* Top level of GNU C compiler
2: Copyright (C) 1987, 1988 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: /* This is the top level of cc1.
23: It parses command args, opens files, invokes the various passes
24: in the proper order, and counts the time used by each.
25: Error messages and low-level interface to malloc also handled here. */
26:
27: #include "config.h"
28: #include <stdio.h>
29: #include <signal.h>
30:
31: #ifdef USG
32: #include <sys/param.h>
33: #include <sys/times.h>
34: #include <time.h> /* Correct for hpux at least. Is it good on other USG? */
35: #else
36: #ifndef VMS
37: #include <sys/time.h>
38: #include <sys/resource.h>
39: #endif
40: #endif
41:
42: #ifndef _TYPES_
43: #include <sys/types.h>
44: #endif
45: #include <sys/stat.h>
46:
47: #include "tree.h"
48: #include "c-tree.h"
49: #include "rtl.h"
50: #include "flags.h"
51:
52: extern int yydebug;
53:
54: extern FILE *finput;
55:
56: extern void init_lex ();
57: extern void init_decl_processing ();
58: extern void init_tree ();
59: extern void init_rtl ();
60: extern void init_optabs ();
61: extern void init_reg_sets ();
62: extern void dump_flow_info ();
63: extern void dump_local_alloc ();
64:
65: void rest_of_decl_compilation ();
66: void error ();
67: void error_with_file_and_line ();
68: void set_target_switch ();
69:
70: /* Bit flags that specify the machine subtype we are compiling for.
71: Bits are tested using macros TARGET_... defined in the tm-...h file
72: and set by `-m...' switches. */
73:
74: int target_flags;
75:
76: /* Name of current original source file (what was input to cpp).
77: This comes from each #-command in the actual input. */
78:
79: char *input_filename;
80:
81: /* Name of top-level original source file (what was input to cpp).
82: This comes from the first #-command in the actual input. */
83:
84: char *main_input_filename;
85:
86: /* Current line number in real source file. */
87:
88: extern int lineno;
89:
90: /* FUNCTION_DECL for function now being parsed or compiled. */
91:
92: extern tree current_function_decl;
93:
94: /* Name to use as base of names for dump output files. */
95:
96: char *dump_base_name;
97:
98: /* Flags saying which kinds of debugging dump have been requested. */
99:
100: int rtl_dump = 0;
101: int rtl_dump_and_exit = 0;
102: int jump_opt_dump = 0;
103: int cse_dump = 0;
104: int loop_dump = 0;
105: int flow_dump = 0;
106: int combine_dump = 0;
107: int local_reg_dump = 0;
108: int global_reg_dump = 0;
109: int jump2_opt_dump = 0;
110:
111: /* 1 => write gdb debugging output (using symout.c). -g
112: 2 => write dbx debugging output (using dbxout.c). -G */
113:
114: int write_symbols = 0;
115:
116: /* Nonzero means do optimizations. -opt. */
117:
118: int optimize = 0;
119:
120: /* Nonzero for -fforce-mem: load memory value into a register
121: before arithmetic on it. This makes better cse but slower compilation. */
122:
123: int flag_force_mem = 0;
124:
125: /* Nonzero for -fforce-addr: load memory address into a register before
126: reference to memory. This makes better cse but slower compilation. */
127:
128: int flag_force_addr = 0;
129:
130: /* Nonzero for -fdefer-pop: don't pop args after each function call;
131: instead save them up to pop many calls' args with one insns. */
132:
133: int flag_defer_pop = 1;
134:
135: /* Nonzero for -ffloat-store: don't allocate floats and doubles
136: in extended-precision registers. */
137:
138: int flag_float_store = 0;
139:
140: /* Nonzero for -fcombine-regs:
141: allow instruction combiner to combine an insn
142: that just copies one reg to another. */
143:
144: int flag_combine_regs = 0;
145:
146: /* Nonzero for -fwritable-strings:
147: store string constants in data segment and don't uniquize them. */
148:
149: int flag_writable_strings = 0;
150:
151: /* Nonzero means don't put addresses of constant functions in registers.
152: Used for compiling the Unix kernel, where strange substitutions are
153: done on the assembly output. */
154:
155: int flag_no_function_cse = 0;
156:
157: /* Nonzero for -fomit-frame-pointer:
158: don't make a frame pointer in simple functions that don't require one. */
159:
160: int flag_omit_frame_pointer = 0;
161:
162: /* Nonzero to inhibit use of define_optimization peephole opts. */
163:
164: int flag_no_peephole = 0;
165:
166: /* Nonzero means `char' should be signed. */
167:
168: int flag_signed_char;
169:
170: /* Nonzero means allow type mismatches in conditional expressions;
171: just make their values `void'. */
172:
173: int flag_cond_mismatch;
174:
175: /* Nonzero means don't recognize the keyword `asm'. */
176:
177: int flag_no_asm;
178:
179: /* Nonzero means warn about implicit declarations. */
180:
181: int warn_implicit;
182:
183: /* Nonzero means warn about function definitions that default the return type
184: or that use a null return and have a return-type other than void. */
185:
186: int warn_return_type;
187:
188: /* Nonzero means do some things the same way PCC does. */
189:
190: int flag_traditional;
191:
192: /* Nonzero means all references through pointers are volatile. */
193:
194: int flag_volatile;
195:
196: /* Nonzero means do stupid register allocation. -noreg.
197: This and `optimize' are controlled by different switches in cc1,
198: but normally cc controls them both with the -O switch. */
199:
200: int obey_regdecls = 0;
201:
202: /* Don't print functions as they are compiled and don't print
203: times taken by the various passes. -quiet. */
204:
205: int quiet_flag = 0;
206:
207: /* Don't print warning messages. -w. */
208:
209: int inhibit_warnings = 0;
210:
211: /* Do print extra warnings (such as for uninitialized variables). -W. */
212:
213: int extra_warnings = 0;
214:
215: /* Number of error messages and warning messages so far. */
216:
217: int errorcount = 0;
218: int warningcount = 0;
219:
220: /* Nonzero if generating code to do profiling. */
221:
222: int profile_flag = 0;
223:
224: /* Nonzero for -pedantic switch: warn about anything
225: that standard C forbids. */
226:
227: int pedantic = 0;
228:
229: /* Nonzero for -finline-functions: ok to inline functions that look like
230: good inline candidates. */
231:
232: int flag_inline_functions;
233:
234: /* Nonzero for -fkeep-inline-functions: even if we make a function
235: go inline everywhere, keep its defintion around for debugging
236: purposes. */
237:
238: int flag_keep_inline_functions;
239:
240: /* Name for output file of assembly code, specified with -o. */
241:
242: char *asm_file_name;
243:
244: /* Name for output file of GDB symbol segment, specified with -symout. */
245:
246: char *sym_file_name;
247:
248: /* Output files for assembler code (real compiler output)
249: and debugging dumps. */
250:
251: FILE *asm_out_file;
252: FILE *rtl_dump_file;
253: FILE *jump_opt_dump_file;
254: FILE *cse_dump_file;
255: FILE *loop_dump_file;
256: FILE *flow_dump_file;
257: FILE *combine_dump_file;
258: FILE *local_reg_dump_file;
259: FILE *global_reg_dump_file;
260: FILE *jump2_opt_dump_file;
261:
262: /* Time accumulators, to count the total time spent in various passes. */
263:
264: int parse_time;
265: int varconst_time;
266: int integration_time;
267: int jump_time;
268: int cse_time;
269: int loop_time;
270: int flow_time;
271: int combine_time;
272: int local_alloc_time;
273: int global_alloc_time;
274: int final_time;
275: int symout_time;
276: int dump_time;
277:
278: /* Return time used so far, in microseconds. */
279:
280: int
281: gettime ()
282: {
283: #ifdef USG
284: struct tms tms;
285: #else
286: #ifndef VMS
287: struct rusage rusage;
288: #else /* VMS */
289: struct
290: {
291: int proc_user_time;
292: int proc_system_time;
293: int child_user_time;
294: int child_system_time;
295: } vms_times;
296: #endif
297: #endif
298:
299: if (quiet_flag)
300: return 0;
301:
302: #ifdef USG
303: times (&tms);
304: return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
305: #else
306: #ifndef VMS
307: getrusage (0, &rusage);
308: return (rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec
309: + rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec);
310: #else /* VMS */
311: times (&vms_times);
312: return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
313: #endif
314: #endif
315: }
316:
317: #define TIMEVAR(VAR, BODY) \
318: do { int otime = gettime (); BODY; VAR += gettime () - otime; } while (0)
319:
320: void
321: print_time (str, total)
322: char *str;
323: int total;
324: {
325: fprintf (stderr,
326: "time in %s: %d.%06d\n",
327: str, total / 1000000, total % 1000000);
328: }
329:
330: /* Count an error or warning. Return 1 if the message should be printed. */
331:
332: int
333: count_error (warningp)
334: int warningp;
335: {
336: if (warningp && inhibit_warnings)
337: return 0;
338:
339: if (warningp)
340: warningcount++;
341: else
342: errorcount++;
343:
344: return 1;
345: }
346:
347: /* Print a fatal error message. NAME is the text.
348: Also include a system error message based on `errno'. */
349:
350: void
351: pfatal_with_name (name)
352: char *name;
353: {
354: fprintf (stderr, "cc1: ");
355: perror (name);
356: exit (35);
357: }
358:
359: void
360: fatal_io_error (name)
361: char *name;
362: {
363: fprintf (stderr, "cc1:%s: I/O error\n", name);
364: exit (35);
365: }
366:
367: void
368: fatal (s)
369: char *s;
370: {
371: error (s, 0);
372: exit (34);
373: }
374:
375: /* Called when the start of a function definition is parsed,
376: this function prints on stderr the name of the function. */
377:
378: void
379: announce_function (decl)
380: tree decl;
381: {
382: if (! quiet_flag)
383: {
384: fprintf (stderr, " %s", IDENTIFIER_POINTER (DECL_NAME (decl)));
385: fflush (stderr);
386: }
387: }
388:
389: /* Prints out, if necessary, the name of the current function
390: which caused an error. Called from all error and warning functions. */
391:
392: void
393: report_error_function()
394: {
395: static tree last_error_function = NULL;
396:
397: if (last_error_function != current_function_decl)
398: {
399: if (current_function_decl == NULL)
400: {
401: if (!quiet_flag)
402: fprintf (stderr, "\n");
403: fprintf (stderr, "At top level:\n");
404: }
405: else
406: {
407: if (!quiet_flag)
408: /* We already know this info. Don't print it twice.
409: But make sure we are at the beginning of a line. */
410: fprintf (stderr, "\n");
411: else
412: fprintf (stderr, "In function %s:\n",
413: IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
414: }
415: last_error_function = current_function_decl;
416: }
417: }
418:
419: /* Report an error at the current line number.
420: S and V are a string and an arg for `printf'. */
421:
422: void
423: error (s, v)
424: char *s;
425: int v; /* @@also used as pointer */
426: {
427: error_with_file_and_line (input_filename, lineno, s, v);
428: }
429:
430: /* Report an error at line LINE of file FILE.
431: S and V are a string and an arg for `printf'. */
432:
433: void
434: error_with_file_and_line (file, line, s, v)
435: char *file;
436: int line;
437: char *s;
438: int v;
439: {
440: count_error (0);
441:
442: report_error_function ();
443:
444: if (file)
445: fprintf (stderr, "%s:%d: ", file, line);
446: else
447: fprintf (stderr, "cc1: ");
448: fprintf (stderr, s, v);
449: fprintf (stderr, "\n");
450: }
451:
452: /* Report an error at the declaration DECL.
453: S is string which uses %s to substitute the declaration name. */
454:
455: void
456: error_with_decl (decl, s)
457: tree decl;
458: char *s;
459: {
460: count_error (0);
461:
462: report_error_function ();
463:
464: fprintf (stderr, "%s:%d: ",
465: DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
466:
467: if (DECL_NAME (decl))
468: fprintf (stderr, s, IDENTIFIER_POINTER (DECL_NAME (decl)));
469: else
470: fprintf (stderr, s, "((anonymous))");
471: fprintf (stderr, "\n");
472: }
473:
474: /* Report a warning at line LINE.
475: S and V are a string and an arg for `printf'. */
476:
477: void
478: warning_with_line (line, s, v)
479: int line;
480: char *s;
481: int v;
482: {
483: if (count_error (1) == 0)
484: return;
485:
486: report_error_function ();
487:
488: if (input_filename)
489: fprintf (stderr, "%s:%d: ", input_filename, line);
490: else
491: fprintf (stderr, "cc1: ");
492:
493: fprintf (stderr, "warning: ");
494: fprintf (stderr, s, v);
495: fprintf (stderr, "\n");
496: }
497:
498: /* Report a warning at the current line number.
499: S and V are a string and an arg for `printf'. */
500:
501: void
502: warning (s, v)
503: char *s;
504: int v; /* @@also used as pointer */
505: {
506: warning_with_line (lineno, s, v);
507: }
508:
509: /* Report a warning at the declaration DECL.
510: S is string which uses %s to substitute the declaration name. */
511:
512: void
513: warning_with_decl (decl, s)
514: tree decl;
515: char *s;
516: {
517: if (count_error (1) == 0)
518: return;
519:
520: report_error_function ();
521:
522: fprintf (stderr, "%s:%d: ",
523: DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
524:
525: fprintf (stderr, "warning: ");
526: if (DECL_NAME (decl))
527: fprintf (stderr, s, IDENTIFIER_POINTER (DECL_NAME (decl)));
528: else
529: fprintf (stderr, s, "((anonymous))");
530: fprintf (stderr, "\n");
531: }
532:
533: /* When `malloc.c' is compiled with `rcheck' defined,
534: it calls this function to report clobberage. */
535:
536: void
537: botch (s)
538: {
539: abort ();
540: }
541:
542: /* Same as `malloc' but report error if no memory available. */
543:
544: int
545: xmalloc (size)
546: unsigned size;
547: {
548: register int value = (int) malloc (size);
549: if (value == 0)
550: fatal ("Virtual memory exhausted.");
551: return value;
552: }
553:
554: /* Same as `realloc' but report error if no memory available. */
555:
556: int
557: xrealloc (ptr, size)
558: char *ptr;
559: int size;
560: {
561: int result = realloc (ptr, size);
562: if (!result)
563: fatal ("Virtual memory exhausted.");
564: return result;
565: }
566:
567: /* Return the logarithm of X, base 2, considering X unsigned,
568: if X is a power of 2. Otherwise, returns -1. */
569:
570: int
571: exact_log2 (x)
572: register unsigned int x;
573: {
574: register int log = 0;
575: for (log = 0; log < HOST_BITS_PER_INT; log++)
576: if (x == (1 << log))
577: return log;
578: return -1;
579: }
580:
581: /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
582: If X is 0, return -1. */
583:
584: int
585: floor_log2 (x)
586: register unsigned int x;
587: {
588: register int log = 0;
589: for (log = 0; log < HOST_BITS_PER_INT; log++)
590: if ((x & ((-1) << log)) == 0)
591: return log - 1;
592: return HOST_BITS_PER_INT - 1;
593: }
594:
595: /* Compile an entire file of output from cpp, named NAME.
596: Write a file of assembly output and various debugging dumps. */
597:
598: static void
599: compile_file (name)
600: char *name;
601: {
602: tree globals;
603: int start_time;
604: int dump_base_name_length = strlen (dump_base_name);
605:
606: parse_time = 0;
607: varconst_time = 0;
608: integration_time = 0;
609: jump_time = 0;
610: cse_time = 0;
611: loop_time = 0;
612: flow_time = 0;
613: combine_time = 0;
614: local_alloc_time = 0;
615: global_alloc_time = 0;
616: final_time = 0;
617: symout_time = 0;
618: dump_time = 0;
619:
620: /* Open input file. */
621:
622: finput = fopen (name, "r");
623: if (finput == 0)
624: pfatal_with_name (name);
625:
626: /* Initialize data in various passes. */
627:
628: init_tree ();
629: init_lex ();
630: init_rtl ();
631: init_emit_once ();
632: init_decl_processing ();
633: init_optabs ();
634:
635: /* If rtl dump desired, open the output file. */
636: if (rtl_dump)
637: {
638: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
639: strcpy (dumpname, dump_base_name);
640: strcat (dumpname, ".rtl");
641: rtl_dump_file = fopen (dumpname, "w");
642: if (rtl_dump_file == 0)
643: pfatal_with_name (dumpname);
644: }
645:
646: /* If jump_opt dump desired, open the output file. */
647: if (jump_opt_dump)
648: {
649: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
650: strcpy (dumpname, dump_base_name);
651: strcat (dumpname, ".jump");
652: jump_opt_dump_file = fopen (dumpname, "w");
653: if (jump_opt_dump_file == 0)
654: pfatal_with_name (dumpname);
655: }
656:
657: /* If cse dump desired, open the output file. */
658: if (cse_dump)
659: {
660: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
661: strcpy (dumpname, dump_base_name);
662: strcat (dumpname, ".cse");
663: cse_dump_file = fopen (dumpname, "w");
664: if (cse_dump_file == 0)
665: pfatal_with_name (dumpname);
666: }
667:
668: /* If loop dump desired, open the output file. */
669: if (loop_dump)
670: {
671: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
672: strcpy (dumpname, dump_base_name);
673: strcat (dumpname, ".loop");
674: loop_dump_file = fopen (dumpname, "w");
675: if (loop_dump_file == 0)
676: pfatal_with_name (dumpname);
677: }
678:
679: /* If flow dump desired, open the output file. */
680: if (flow_dump)
681: {
682: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
683: strcpy (dumpname, dump_base_name);
684: strcat (dumpname, ".flow");
685: flow_dump_file = fopen (dumpname, "w");
686: if (flow_dump_file == 0)
687: pfatal_with_name (dumpname);
688: }
689:
690: /* If combine dump desired, open the output file. */
691: if (combine_dump)
692: {
693: register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
694: strcpy (dumpname, dump_base_name);
695: strcat (dumpname, ".combine");
696: combine_dump_file = fopen (dumpname, "w");
697: if (combine_dump_file == 0)
698: pfatal_with_name (dumpname);
699: }
700:
701: /* If local_reg dump desired, open the output file. */
702: if (local_reg_dump)
703: {
704: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
705: strcpy (dumpname, dump_base_name);
706: strcat (dumpname, ".lreg");
707: local_reg_dump_file = fopen (dumpname, "w");
708: if (local_reg_dump_file == 0)
709: pfatal_with_name (dumpname);
710: }
711:
712: /* If global_reg dump desired, open the output file. */
713: if (global_reg_dump)
714: {
715: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
716: strcpy (dumpname, dump_base_name);
717: strcat (dumpname, ".greg");
718: global_reg_dump_file = fopen (dumpname, "w");
719: if (global_reg_dump_file == 0)
720: pfatal_with_name (dumpname);
721: }
722:
723: /* If jump2_opt dump desired, open the output file. */
724: if (jump2_opt_dump)
725: {
726: register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
727: strcpy (dumpname, dump_base_name);
728: strcat (dumpname, ".jump2");
729: jump2_opt_dump_file = fopen (dumpname, "w");
730: if (jump2_opt_dump_file == 0)
731: pfatal_with_name (dumpname);
732: }
733:
734: /* Open assembler code output file. */
735:
736: {
737: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
738: int len = strlen (dump_base_name);
739: strcpy (dumpname, dump_base_name);
740: if (len > 2 && ! strcmp (".c", dumpname + len - 2))
741: dumpname[len - 2] = 0;
742: else if (len > 3 && ! strcmp (".co", dumpname + len - 3))
743: dumpname[len - 3] = 0;
744: strcat (dumpname, ".s");
745: if (asm_file_name == 0)
746: {
747: asm_file_name = (char *) malloc (strlen (dumpname) + 1);
748: strcpy (asm_file_name, dumpname);
749: }
750: asm_out_file = fopen (asm_file_name, "w");
751: if (asm_out_file == 0)
752: pfatal_with_name (asm_file_name ? asm_file_name : dumpname);
753: fprintf (asm_out_file, ASM_FILE_START);
754: }
755:
756: input_filename = name;
757:
758: /* the beginning of the file is a new line; check for # */
759: /* With luck, we discover the real source file's name from that
760: and put it in input_filename. */
761: check_newline ();
762:
763: /* If GDB symbol table desired, open the GDB symbol output file. */
764: if (write_symbols == 1)
765: {
766: register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
767: int len = strlen (dump_base_name);
768: strcpy (dumpname, dump_base_name);
769: if (len > 2 && ! strcmp (".c", dumpname + len - 2))
770: dumpname[len - 2] = 0;
771: else if (len > 3 && ! strcmp (".co", dumpname + len - 3))
772: dumpname[len - 3] = 0;
773: strcat (dumpname, ".sym");
774: if (sym_file_name == 0)
775: sym_file_name = dumpname;
776: symout_init (sym_file_name, asm_out_file, input_filename);
777: }
778:
779: /* If dbx symbol table desired, initialize writing it
780: and output the predefined types. */
781: if (write_symbols == 2)
782: dbxout_init (asm_out_file, main_input_filename);
783:
784: /* Initialize yet another pass. */
785:
786: init_final (main_input_filename);
787:
788: start_time = gettime ();
789:
790: /* Call the parser, which parses the entire file
791: (calling rest_of_compilation for each function). */
792:
793: yyparse ();
794:
795: /* Compilation is now finished except for writing
796: what's left of the symbol table output. */
797:
798: parse_time += gettime () - start_time;
799:
800: parse_time -= varconst_time;
801:
802: globals = getdecls ();
803:
804: /* Really define vars that have had only a tentative definition.
805: Really output inline functions that must actually be callable
806: and have not been output so far. */
807:
808: {
809: tree decl;
810: for (decl = globals; decl; decl = TREE_CHAIN (decl))
811: {
812: if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
813: && ! TREE_ASM_WRITTEN (decl))
814: rest_of_decl_compilation (decl, 0, 1, 1);
815: if (TREE_CODE (decl) == FUNCTION_DECL
816: && ! TREE_ASM_WRITTEN (decl)
817: && DECL_INITIAL (decl) != 0
818: && TREE_ADDRESSABLE (decl))
819: output_inline_function (decl);
820: }
821: }
822:
823: /* Do dbx symbols */
824: if (write_symbols == 2)
825: TIMEVAR (symout_time,
826: {
827: dbxout_tags (gettags ());
828: dbxout_types (get_permanent_types ());
829: });
830:
831: /* Do gdb symbols */
832: if (write_symbols == 1)
833: TIMEVAR (symout_time,
834: {
835: struct stat statbuf;
836: fstat (fileno (finput), &statbuf);
837: symout_types (get_permanent_types ());
838: symout_top_blocks (globals, gettags ());
839: symout_finish (name, statbuf.st_ctime);
840: });
841:
842: /* Close the dump files. */
843:
844: if (rtl_dump)
845: fclose (rtl_dump_file);
846:
847: if (jump_opt_dump)
848: fclose (jump_opt_dump_file);
849:
850: if (cse_dump)
851: fclose (cse_dump_file);
852:
853: if (loop_dump)
854: fclose (loop_dump_file);
855:
856: if (flow_dump)
857: fclose (flow_dump_file);
858:
859: if (combine_dump)
860: {
861: dump_combine_total_stats (combine_dump_file);
862: fclose (combine_dump_file);
863: }
864:
865: if (local_reg_dump)
866: fclose (local_reg_dump_file);
867:
868: if (global_reg_dump)
869: fclose (global_reg_dump_file);
870:
871: if (jump2_opt_dump)
872: fclose (jump2_opt_dump_file);
873:
874: /* Close non-debugging input and output files. */
875:
876: fclose (finput);
877: if (ferror (asm_out_file) != 0)
878: fatal_io_error (asm_file_name);
879: fclose (asm_out_file);
880:
881: /* Print the times. */
882:
883: if (! quiet_flag)
884: {
885: fprintf (stderr,"\n");
886: print_time ("parse", parse_time);
887: print_time ("integration", integration_time);
888: print_time ("jump", jump_time);
889: print_time ("cse", cse_time);
890: print_time ("loop", loop_time);
891: print_time ("flow", flow_time);
892: print_time ("combine", combine_time);
893: print_time ("local-alloc", local_alloc_time);
894: print_time ("global-alloc", global_alloc_time);
895: print_time ("final", final_time);
896: print_time ("varconst", varconst_time);
897: print_time ("symout", symout_time);
898: print_time ("dump", dump_time);
899: }
900: }
901:
902: /* This is called from finish_decl (within yyparse)
903: for each declaration of a function or variable.
904: This does nothing for automatic variables.
905: Otherwise, it sets up the RTL and outputs any assembler code
906: (label definition, storage allocation and initialization).
907:
908: DECL is the declaration. If ASMSPEC is nonzero, it specifies
909: the assembler symbol name to be used. TOP_LEVEL is nonzero
910: if this declaration is not within a function. */
911:
912: void
913: rest_of_decl_compilation (decl, asmspec, top_level, at_end)
914: tree decl;
915: tree asmspec;
916: int top_level;
917: int at_end;
918: {
919: /* Declarations of variables, and of functions defined elsewhere. */
920:
921: if (TREE_STATIC (decl) || TREE_EXTERNAL (decl))
922: TIMEVAR (varconst_time,
923: {
924: assemble_variable (decl, asmspec, top_level, write_symbols, at_end);
925: });
926: else if (write_symbols == 2 && TREE_CODE (decl) == TYPE_DECL)
927: TIMEVAR (varconst_time, dbxout_symbol (decl, 0));
928:
929: if (top_level)
930: {
931: if (write_symbols == 1)
932: {
933: TIMEVAR (symout_time,
934: {
935: /* The initizations make types when they contain
936: string constants. The types are on the temporary
937: obstack, so output them now before they go away. */
938: symout_types (get_temporary_types ());
939: });
940: }
941: else
942: /* Clean out the temporary type list, since the types will go away. */
943: get_temporary_types ();
944: }
945: }
946:
947: /* This is called from finish_function (within yyparse)
948: after each top-level definition is parsed.
949: It is supposed to compile that function or variable
950: and output the assembler code for it.
951: After we return, the tree storage is freed. */
952:
953: void
954: rest_of_compilation (decl)
955: tree decl;
956: {
957: register rtx insns;
958: int start_time = gettime ();
959: int tem;
960:
961: /* If we are reconsidering an inline function
962: at the end of compilation, skip the stuff for making it inline. */
963:
964: if (DECL_SAVED_INSNS (decl) == 0)
965: {
966:
967: /* If requested, consider whether to make this function inline. */
968: if (flag_inline_functions || TREE_INLINE (decl))
969: {
970: TIMEVAR (integration_time,
971: {
972: int specd = TREE_INLINE (decl);
973: char *lose = function_cannot_inline_p (decl);
974: if (lose != 0 && specd)
975: warning_with_decl (decl, lose);
976: if (lose == 0)
977: save_for_inline (decl);
978: else
979: TREE_INLINE (decl) = 0;
980: });
981: }
982:
983: insns = get_insns ();
984:
985: /* Dump the rtl code if we are dumping rtl. */
986:
987: if (rtl_dump)
988: TIMEVAR (dump_time,
989: {
990: fprintf (rtl_dump_file, "\n;; Function %s\n\n",
991: IDENTIFIER_POINTER (DECL_NAME (decl)));
992: if (DECL_SAVED_INSNS (decl))
993: fprintf (rtl_dump_file, ";; (integrable)\n\n");
994: print_rtl (rtl_dump_file, insns);
995: fflush (rtl_dump_file);
996: });
997:
998: /* If function is inline, and we don't yet know whether to
999: compile it by itself, defer decision till end of compilation.
1000: finish_compilation will call rest_of_compilation again
1001: for those functions that need to be output. */
1002:
1003: if (TREE_PUBLIC (decl) == 0
1004: && TREE_INLINE (decl)
1005: && ! flag_keep_inline_functions)
1006: goto exit_rest_of_compilation;
1007: }
1008:
1009: if (rtl_dump_and_exit)
1010: goto exit_rest_of_compilation;
1011:
1012: TREE_ASM_WRITTEN (decl) = 1;
1013:
1014: insns = get_insns ();
1015:
1016: /* Copy any shared structure that should not be shared. */
1017:
1018: unshare_all_rtl (insns);
1019:
1020: /* See if we have allocated stack slots that are not directly addressable.
1021: If so, scan all the insns and create explicit address computation
1022: for all references to such slots. */
1023: /* fixup_stack_slots (); */
1024:
1025: /* Do jump optimization the first time, if -opt.
1026: Also do it if -W, but in that case it doesn't change the rtl code,
1027: it only computes whether control can drop off the end of the function. */
1028:
1029: if (optimize || extra_warnings || warn_return_type)
1030: TIMEVAR (jump_time, jump_optimize (insns, 0, 0));
1031:
1032: /* Dump rtl code after jump, if we are doing that. */
1033:
1034: if (jump_opt_dump)
1035: TIMEVAR (dump_time,
1036: {
1037: fprintf (jump_opt_dump_file, "\n;; Function %s\n\n",
1038: IDENTIFIER_POINTER (DECL_NAME (decl)));
1039: print_rtl (jump_opt_dump_file, insns);
1040: fflush (jump_opt_dump_file);
1041: });
1042:
1043: /* Perform common subexpression elimination.
1044: Nonzero value from `cse_main' means that jumps were simplified
1045: and some code may now be unreachable, so do
1046: jump optimization again. */
1047:
1048: if (optimize)
1049: {
1050: TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 0));
1051:
1052: TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num ()));
1053:
1054: if (tem)
1055: TIMEVAR (jump_time, jump_optimize (insns, 0, 0));
1056: }
1057:
1058: /* Dump rtl code after cse, if we are doing that. */
1059:
1060: if (cse_dump)
1061: TIMEVAR (dump_time,
1062: {
1063: fprintf (cse_dump_file, "\n;; Function %s\n\n",
1064: IDENTIFIER_POINTER (DECL_NAME (decl)));
1065: print_rtl (cse_dump_file, insns);
1066: fflush (cse_dump_file);
1067: });
1068:
1069: if (loop_dump)
1070: TIMEVAR (dump_time,
1071: {
1072: fprintf (loop_dump_file, "\n;; Function %s\n\n",
1073: IDENTIFIER_POINTER (DECL_NAME (decl)));
1074: });
1075:
1076: /* Move constant computations out of loops. */
1077:
1078: if (optimize)
1079: {
1080: TIMEVAR (loop_time,
1081: {
1082: reg_scan (insns, max_reg_num (), 1);
1083: loop_optimize (insns, max_reg_num (),
1084: loop_dump ? loop_dump_file : 0);
1085: });
1086: }
1087:
1088: /* Dump rtl code after loop opt, if we are doing that. */
1089:
1090: if (loop_dump)
1091: TIMEVAR (dump_time,
1092: {
1093: print_rtl (loop_dump_file, insns);
1094: fflush (loop_dump_file);
1095: });
1096:
1097: /* Now we choose between stupid (pcc-like) register allocation
1098: (if we got the -noreg switch and not -opt)
1099: and smart register allocation. */
1100:
1101: if (optimize) /* Stupid allocation probably won't work */
1102: obey_regdecls = 0; /* if optimizations being done. */
1103:
1104: regclass_init ();
1105:
1106: /* Print function header into flow dump now
1107: because doing the flow analysis makes some of the dump. */
1108:
1109: if (flow_dump)
1110: TIMEVAR (dump_time,
1111: {
1112: fprintf (flow_dump_file, "\n;; Function %s\n\n",
1113: IDENTIFIER_POINTER (DECL_NAME (decl)));
1114: });
1115:
1116: if (obey_regdecls)
1117: {
1118: TIMEVAR (flow_time,
1119: {
1120: regclass (insns, max_reg_num ());
1121: stupid_life_analysis (insns, max_reg_num (),
1122: flow_dump_file);
1123: });
1124: }
1125: else
1126: {
1127: /* Do control and data flow analysis,
1128: and write some of the results to dump file. */
1129:
1130: TIMEVAR (flow_time, flow_analysis (insns, max_reg_num (),
1131: flow_dump_file));
1132: if (extra_warnings)
1133: uninitialized_vars_warning (DECL_INITIAL (decl));
1134: }
1135:
1136: /* Dump rtl after flow analysis. */
1137:
1138: if (flow_dump)
1139: TIMEVAR (dump_time,
1140: {
1141: print_rtl (flow_dump_file, insns);
1142: fflush (flow_dump_file);
1143: });
1144:
1145: /* If -opt, try combining insns through substitution. */
1146:
1147: if (optimize)
1148: TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ()));
1149:
1150: /* Dump rtl code after insn combination. */
1151:
1152: if (combine_dump)
1153: TIMEVAR (dump_time,
1154: {
1155: fprintf (combine_dump_file, "\n;; Function %s\n\n",
1156: IDENTIFIER_POINTER (DECL_NAME (decl)));
1157: dump_combine_stats (combine_dump_file);
1158: print_rtl (combine_dump_file, insns);
1159: fflush (combine_dump_file);
1160: });
1161:
1162: /* Unless we did stupid register allocation,
1163: allocate pseudo-regs that are used only within 1 basic block. */
1164:
1165: if (!obey_regdecls)
1166: TIMEVAR (local_alloc_time,
1167: {
1168: regclass (insns, max_reg_num ());
1169: local_alloc ();
1170: });
1171:
1172: /* Dump rtl code after allocating regs within basic blocks. */
1173:
1174: if (local_reg_dump)
1175: TIMEVAR (dump_time,
1176: {
1177: fprintf (local_reg_dump_file, "\n;; Function %s\n\n",
1178: IDENTIFIER_POINTER (DECL_NAME (decl)));
1179: dump_flow_info (local_reg_dump_file);
1180: dump_local_alloc (local_reg_dump_file);
1181: print_rtl (local_reg_dump_file, insns);
1182: fflush (local_reg_dump_file);
1183: });
1184:
1185: if (global_reg_dump)
1186: TIMEVAR (dump_time,
1187: fprintf (global_reg_dump_file, "\n;; Function %s\n\n",
1188: IDENTIFIER_POINTER (DECL_NAME (decl))));
1189:
1190: /* Unless we did stupid register allocation,
1191: allocate remaining pseudo-regs, then do the reload pass
1192: fixing up any insns that are invalid. */
1193:
1194: TIMEVAR (global_alloc_time,
1195: {
1196: if (!obey_regdecls)
1197: global_alloc (global_reg_dump ? global_reg_dump_file : 0);
1198: else
1199: reload (insns, 0,
1200: global_reg_dump ? global_reg_dump_file : 0);
1201: });
1202:
1203: if (global_reg_dump)
1204: TIMEVAR (dump_time,
1205: {
1206: dump_global_regs (global_reg_dump_file);
1207: print_rtl (global_reg_dump_file, insns);
1208: fflush (global_reg_dump_file);
1209: });
1210:
1211: /* One more attempt to remove jumps to .+1
1212: left by dead-store-elimination.
1213: Also do cross-jumping this time
1214: and delete no-op move insns. */
1215:
1216: if (optimize)
1217: {
1218: TIMEVAR (jump_time, jump_optimize (insns, 1, 1));
1219: }
1220:
1221: /* Dump rtl code after jump, if we are doing that. */
1222:
1223: if (jump2_opt_dump)
1224: TIMEVAR (dump_time,
1225: {
1226: fprintf (jump2_opt_dump_file, "\n;; Function %s\n\n",
1227: IDENTIFIER_POINTER (DECL_NAME (decl)));
1228: print_rtl (jump2_opt_dump_file, insns);
1229: fflush (jump2_opt_dump_file);
1230: });
1231:
1232: /* Now turn the rtl into assembler code. */
1233:
1234: TIMEVAR (final_time,
1235: {
1236: assemble_function (decl);
1237: final_start_function (insns, asm_out_file,
1238: write_symbols, optimize);
1239: final (insns, asm_out_file,
1240: write_symbols, optimize);
1241: final_end_function (insns, asm_out_file,
1242: write_symbols, optimize);
1243: fflush (asm_out_file);
1244: });
1245:
1246: /* Write GDB symbols if requested */
1247:
1248: if (write_symbols == 1)
1249: {
1250: TIMEVAR (symout_time,
1251: {
1252: symout_types (get_permanent_types ());
1253: symout_types (get_temporary_types ());
1254:
1255: DECL_BLOCK_SYMTAB_ADDRESS (decl)
1256: = symout_function (DECL_INITIAL (decl),
1257: DECL_ARGUMENTS (decl), 0);
1258: });
1259: }
1260: else
1261: get_temporary_types ();
1262:
1263: /* Write DBX symbols if requested */
1264:
1265: if (write_symbols == 2)
1266: TIMEVAR (symout_time, dbxout_function (decl));
1267:
1268: exit_rest_of_compilation:
1269:
1270: /* The parsing time is all the time spent in yyparse
1271: *except* what is spent in this function. */
1272:
1273: parse_time -= gettime () - start_time;
1274: }
1275:
1276: /* Entry point of cc1. Decode command args, then call compile_file.
1277: Exit code is 35 if can't open files, 34 if fatal error,
1278: 33 if had nonfatal errors, else success. */
1279:
1280: int
1281: main (argc, argv, envp)
1282: int argc;
1283: char **argv;
1284: char **envp;
1285: {
1286: register int i;
1287: char *filename = 0;
1288: int print_mem_flag = 0;
1289:
1290: #ifdef RLIMIT_STACK
1291: /* Get rid of any avoidable limit on stack size. */
1292: {
1293: struct rlimit rlim;
1294:
1295: /* Set the stack limit huge so that alloca does not fail. */
1296: getrlimit (RLIMIT_STACK, &rlim);
1297: rlim.rlim_cur = rlim.rlim_max;
1298: setrlimit (RLIMIT_STACK, &rlim);
1299: }
1300: #endif /* RLIMIT_STACK */
1301:
1302: /* Initialize whether `char' is signed. */
1303: flag_signed_char = DEFAULT_SIGNED_CHAR;
1304:
1305: /* Initialize reg-sets now so switches may override. */
1306: init_reg_sets ();
1307:
1308: target_flags = 0;
1309: set_target_switch ("");
1310:
1311: for (i = 1; i < argc; i++)
1312: if (argv[i][0] == '-')
1313: {
1314: register char *str = argv[i] + 1;
1315: if (str[0] == 'Y')
1316: str++;
1317:
1318: if (str[0] == 'm')
1319: set_target_switch (&str[1]);
1320: else if (!strcmp (str, "dumpbase"))
1321: {
1322: dump_base_name = argv[++i];
1323: }
1324: else if (str[0] == 'd')
1325: {
1326: register char *p = &str[1];
1327: while (*p)
1328: switch (*p++)
1329: {
1330: case 'c':
1331: combine_dump = 1;
1332: break;
1333: case 'f':
1334: flow_dump = 1;
1335: break;
1336: case 'g':
1337: global_reg_dump = 1;
1338: break;
1339: case 'j':
1340: jump_opt_dump = 1;
1341: break;
1342: case 'J':
1343: jump2_opt_dump = 1;
1344: break;
1345: case 'l':
1346: local_reg_dump = 1;
1347: break;
1348: case 'L':
1349: loop_dump = 1;
1350: break;
1351: case 'm':
1352: print_mem_flag = 1;
1353: break;
1354: case 'r':
1355: rtl_dump = 1;
1356: break;
1357: case 's':
1358: cse_dump = 1;
1359: break;
1360: case 'y':
1361: yydebug = 1;
1362: break;
1363: }
1364: }
1365: else if (str[0] == 'f')
1366: {
1367: register char *p = &str[1];
1368: if (!strcmp (p, "float-store"))
1369: flag_float_store = 1;
1370: else if (!strcmp (p, "traditional"))
1371: flag_traditional = 1;
1372: else if (!strcmp (p, "volatile"))
1373: flag_volatile = 1;
1374: else if (!strcmp (p, "defer-pop"))
1375: flag_defer_pop = 1;
1376: else if (!strcmp (p, "no-defer-pop"))
1377: flag_defer_pop = 0;
1378: else if (!strcmp (p, "omit-frame-pointer"))
1379: flag_omit_frame_pointer = 1;
1380: else if (!strcmp (p, "no-omit-frame-pointer"))
1381: flag_omit_frame_pointer = 0;
1382: else if (!strcmp (p, "no-peephole"))
1383: flag_no_peephole = 1;
1384: else if (!strcmp (p, "signed-char"))
1385: flag_signed_char = 1;
1386: else if (!strcmp (p, "unsigned-char"))
1387: flag_signed_char = 0;
1388: else if (!strcmp (p, "force-mem"))
1389: flag_force_mem = 1;
1390: else if (!strcmp (p, "force-addr"))
1391: flag_force_addr = 1;
1392: else if (!strcmp (p, "combine-regs"))
1393: flag_combine_regs = 1;
1394: else if (!strcmp (p, "writable-strings"))
1395: flag_writable_strings = 1;
1396: else if (!strcmp (p, "no-function-cse"))
1397: flag_no_function_cse = 1;
1398: else if (!strcmp (p, "cond-mismatch"))
1399: flag_cond_mismatch = 1;
1400: else if (!strcmp (p, "no-asm"))
1401: flag_no_asm = 1;
1402: else if (!strncmp (p, "fixed-", 6))
1403: fix_register (&p[6], 1, 1);
1404: else if (!strncmp (p, "call-used-", 10))
1405: fix_register (&p[10], 0, 1);
1406: else if (!strncmp (p, "call-saved-", 11))
1407: fix_register (&p[11], 0, 0);
1408: else if (!strcmp (p, "inline-functions"))
1409: flag_inline_functions = 1;
1410: else if (!strcmp (p, "keep-inline-functions"))
1411: flag_keep_inline_functions = 1;
1412: else
1413: error ("Invalid option, `%s'", argv[i]);
1414: }
1415: else if (!strcmp (str, "noreg"))
1416: obey_regdecls = 1;
1417: else if (!strcmp (str, "opt"))
1418: optimize = 1;
1419: else if (!strcmp (str, "pedantic"))
1420: pedantic = 1;
1421: else if (!strcmp (str, "traditional"))
1422: flag_traditional = 1;
1423: else if (!strcmp (str, "ansi"))
1424: flag_no_asm = 1;
1425: else if (!strcmp (str, "quiet"))
1426: quiet_flag = 1;
1427: else if (!strcmp (str, "version"))
1428: {
1429: extern char version_string[];
1430: printf ("GNU C version %s", version_string);
1431: #ifdef TARGET_VERSION
1432: TARGET_VERSION;
1433: #endif
1434: #ifdef __GNUC__
1435: #ifndef __VERSION__
1436: #define __VERSION__ "[unknown]"
1437: #endif
1438: printf (" compiled by GNU C version %s.\n", __VERSION__);
1439: #else
1440: printf (" compiled by CC.\n");
1441: #endif
1442: }
1443: else if (!strcmp (str, "w"))
1444: inhibit_warnings = 1;
1445: else if (!strcmp (str, "W"))
1446: extra_warnings = 1;
1447: else if (!strcmp (str, "Wimplicit"))
1448: warn_implicit = 1;
1449: else if (!strcmp (str, "Wreturn-type"))
1450: warn_return_type = 1;
1451: else if (!strcmp (str, "Wcomment"))
1452: ; /* cpp handles this one. */
1453: else if (!strcmp (str, "Wall"))
1454: {
1455: extra_warnings = 1;
1456: warn_implicit = 1;
1457: warn_return_type = 1;
1458: }
1459: else if (!strcmp (str, "p"))
1460: profile_flag = 1;
1461: else if (!strcmp (str, "g"))
1462: write_symbols = 1;
1463: else if (!strcmp (str, "G"))
1464: write_symbols = 2;
1465: else if (!strcmp (str, "symout"))
1466: {
1467: if (write_symbols == 0)
1468: write_symbols = 1;
1469: sym_file_name = argv[++i];
1470: }
1471: else if (!strcmp (str, "o"))
1472: {
1473: asm_file_name = argv[++i];
1474: }
1475: else
1476: error ("Invalid switch, %s.", argv[i]);
1477: }
1478: else
1479: filename = argv[i];
1480:
1481: if (filename == 0)
1482: fatal ("no input file specified");
1483:
1484: if (dump_base_name == 0)
1485: dump_base_name = filename;
1486:
1487: #ifdef OVERRIDE_OPTIONS
1488: /* Some machines may reject certain combinations of options. */
1489: OVERRIDE_OPTIONS;
1490: #endif
1491:
1492: compile_file (filename);
1493:
1494: #ifndef USG
1495: #ifndef VMS
1496: if (print_mem_flag)
1497: {
1498: extern char **environ;
1499: caddr_t lim = (caddr_t) sbrk (0);
1500:
1501: fprintf (stderr, "Data size %d.\n",
1502: (int) lim - (int) &environ);
1503: fflush (stderr);
1504:
1505: system ("ps v");
1506: }
1507: #endif /* not VMS */
1508: #endif /* not USG */
1509:
1510: if (errorcount)
1511: exit (FATAL_EXIT_CODE);
1512: exit (SUCCESS_EXIT_CODE);
1513: return 34;
1514: }
1515:
1516: /* Decode -m switches. */
1517:
1518: /* Here is a table, controlled by the tm-...h file, listing each -m switch
1519: and which bits in `target_switches' it should set or clear.
1520: If VALUE is positive, it is bits to set.
1521: If VALUE is negative, -VALUE is bits to clear.
1522: (The sign bit is not used so there is no confusion.) */
1523:
1524: struct {char *name; int value;} target_switches []
1525: = TARGET_SWITCHES;
1526:
1527: /* Decode the switch -mNAME. */
1528:
1529: void
1530: set_target_switch (name)
1531: char *name;
1532: {
1533: register int j;
1534: for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
1535: if (!strcmp (target_switches[j].name, name))
1536: {
1537: if (target_switches[j].value < 0)
1538: target_flags &= ~-target_switches[j].value;
1539: else
1540: target_flags |= target_switches[j].value;
1541: break;
1542: }
1543: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.