cppfiles.c (stack_include_file): Don't optimize zero-length files.
[gcc.git] / gcc / toplev.c
1 /* Top level of GNU C compiler
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
21
22 /* This is the top level of cc1/c++.
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 #undef FLOAT /* This is for hpux. They should change hpux. */
29 #undef FFS /* Some systems define this in param.h. */
30 #include "system.h"
31 #include <signal.h>
32 #include <setjmp.h>
33
34 #ifdef HAVE_SYS_RESOURCE_H
35 # include <sys/resource.h>
36 #endif
37
38 #ifdef HAVE_SYS_TIMES_H
39 # include <sys/times.h>
40 #endif
41
42 #include "input.h"
43 #include "tree.h"
44 #include "rtl.h"
45 #include "tm_p.h"
46 #include "flags.h"
47 #include "insn-attr.h"
48 #include "insn-config.h"
49 #include "hard-reg-set.h"
50 #include "recog.h"
51 #include "output.h"
52 #include "except.h"
53 #include "function.h"
54 #include "toplev.h"
55 #include "expr.h"
56 #include "basic-block.h"
57 #include "intl.h"
58 #include "ggc.h"
59 #include "graph.h"
60 #include "loop.h"
61 #include "regs.h"
62 #include "timevar.h"
63 #include "diagnostic.h"
64 #include "ssa.h"
65 #include "params.h"
66 #include "reload.h"
67 #include "dwarf2asm.h"
68 #include "integrate.h"
69 #include "debug.h"
70 #include "target.h"
71 #include "langhooks.h"
72
73 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
74 #include "dwarf2out.h"
75 #endif
76
77 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
78 #include "dbxout.h"
79 #endif
80
81 #ifdef SDB_DEBUGGING_INFO
82 #include "sdbout.h"
83 #endif
84
85 #ifdef XCOFF_DEBUGGING_INFO
86 #include "xcoffout.h" /* Needed for external data
87 declarations for e.g. AIX 4.x. */
88 #endif
89
90 #ifdef HALF_PIC_DEBUG
91 #include "halfpic.h"
92 #endif
93 \f
94 #ifdef VMS
95 /* The extra parameters substantially improve the I/O performance. */
96
97 static FILE *
98 vms_fopen (fname, type)
99 char *fname;
100 char *type;
101 {
102 /* The <stdio.h> in the gcc-vms-1.42 distribution prototypes fopen with two
103 fixed arguments, which matches ANSI's specification but not VAXCRTL's
104 pre-ANSI implementation. This hack circumvents the mismatch problem. */
105 FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
106
107 if (*type == 'w')
108 return (*vmslib_fopen) (fname, type, "mbc=32",
109 "deq=64", "fop=tef", "shr=nil");
110 else
111 return (*vmslib_fopen) (fname, type, "mbc=32");
112 }
113
114 #define fopen vms_fopen
115 #endif /* VMS */
116
117 #if defined (HAVE_DECL_ENVIRON) && !HAVE_DECL_ENVIRON
118 extern char **environ;
119 #endif
120
121 /* Carry information from ASM_DECLARE_OBJECT_NAME
122 to ASM_FINISH_DECLARE_OBJECT. */
123
124 extern int size_directive_output;
125 extern tree last_assemble_variable_decl;
126
127 static void general_init PARAMS ((char *));
128 static void parse_options_and_default_flags PARAMS ((int, char **));
129 static void do_compile PARAMS ((void));
130 static void process_options PARAMS ((void));
131 static void lang_independent_init PARAMS ((void));
132 static int lang_dependent_init PARAMS ((const char *));
133 static void init_asm_output PARAMS ((const char *));
134 static void finalize PARAMS ((void));
135
136 static void set_target_switch PARAMS ((const char *));
137 static const char *decl_name PARAMS ((tree, int));
138
139 static void float_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
140 static void crash_signal PARAMS ((int)) ATTRIBUTE_NORETURN;
141 static void set_float_handler PARAMS ((jmp_buf));
142 static void compile_file PARAMS ((void));
143 static void display_help PARAMS ((void));
144 static void display_target_options PARAMS ((void));
145
146 static void decode_d_option PARAMS ((const char *));
147 static int decode_f_option PARAMS ((const char *));
148 static int decode_W_option PARAMS ((const char *));
149 static int decode_g_option PARAMS ((const char *));
150 static unsigned int independent_decode_option PARAMS ((int, char **));
151
152 static void print_version PARAMS ((FILE *, const char *));
153 static int print_single_switch PARAMS ((FILE *, int, int, const char *,
154 const char *, const char *,
155 const char *, const char *));
156 static void print_switch_values PARAMS ((FILE *, int, int, const char *,
157 const char *, const char *));
158
159 /* Length of line when printing switch values. */
160 #define MAX_LINE 75
161
162 /* Name of program invoked, sans directories. */
163
164 const char *progname;
165
166 /* Copy of arguments to toplev_main. */
167 int save_argc;
168 char **save_argv;
169 \f
170 /* Name of current original source file (what was input to cpp).
171 This comes from each #-command in the actual input. */
172
173 const char *input_filename;
174
175 /* Name of top-level original source file (what was input to cpp).
176 This comes from the #-command at the beginning of the actual input.
177 If there isn't any there, then this is the cc1 input file name. */
178
179 const char *main_input_filename;
180
181 /* Current line number in real source file. */
182
183 int lineno;
184
185 /* Nonzero if it is unsafe to create any new pseudo registers. */
186 int no_new_pseudos;
187
188 /* Stack of currently pending input files. */
189
190 struct file_stack *input_file_stack;
191
192 /* Incremented on each change to input_file_stack. */
193 int input_file_stack_tick;
194
195 /* Name to use as base of names for dump output files. */
196
197 const char *dump_base_name;
198
199 /* Format to use to print dumpfile index value */
200 #ifndef DUMPFILE_FORMAT
201 #define DUMPFILE_FORMAT ".%02d."
202 #endif
203
204 /* Bit flags that specify the machine subtype we are compiling for.
205 Bits are tested using macros TARGET_... defined in the tm.h file
206 and set by `-m...' switches. Must be defined in rtlanal.c. */
207
208 extern int target_flags;
209
210 /* Debug hooks - dependent upon command line options. */
211
212 struct gcc_debug_hooks *debug_hooks = &do_nothing_debug_hooks;
213
214 /* Describes a dump file. */
215
216 struct dump_file_info
217 {
218 /* The unique extension to apply, e.g. ".jump". */
219 const char *const extension;
220
221 /* The -d<c> character that enables this dump file. */
222 char const debug_switch;
223
224 /* True if there is a corresponding graph dump file. */
225 char const graph_dump_p;
226
227 /* True if the user selected this dump. */
228 char enabled;
229
230 /* True if the files have been initialized (ie truncated). */
231 char initialized;
232 };
233
234 /* Enumerate the extant dump files. */
235
236 enum dump_file_index
237 {
238 DFI_rtl,
239 DFI_sibling,
240 DFI_eh,
241 DFI_jump,
242 DFI_ssa,
243 DFI_ssa_ccp,
244 DFI_ssa_dce,
245 DFI_ussa,
246 DFI_cse,
247 DFI_addressof,
248 DFI_gcse,
249 DFI_loop,
250 DFI_cse2,
251 DFI_cfg,
252 DFI_bp,
253 DFI_life,
254 DFI_combine,
255 DFI_ce,
256 DFI_regmove,
257 DFI_sched,
258 DFI_lreg,
259 DFI_greg,
260 DFI_postreload,
261 DFI_flow2,
262 DFI_peephole2,
263 DFI_rnreg,
264 DFI_ce2,
265 DFI_sched2,
266 DFI_stack,
267 DFI_bbro,
268 DFI_mach,
269 DFI_dbr,
270 DFI_MAX
271 };
272
273 /* Describes all the dump files. Should be kept in order of the
274 pass and in sync with dump_file_index above.
275
276 Remaining -d letters:
277
278 " o q u "
279 " H JK OPQ TUV YZ"
280 */
281
282 struct dump_file_info dump_file[DFI_MAX] =
283 {
284 { "rtl", 'r', 0, 0, 0 },
285 { "sibling", 'i', 0, 0, 0 },
286 { "eh", 'h', 0, 0, 0 },
287 { "jump", 'j', 0, 0, 0 },
288 { "ssa", 'e', 1, 0, 0 },
289 { "ssaccp", 'W', 1, 0, 0 },
290 { "ssadce", 'X', 1, 0, 0 },
291 { "ussa", 'e', 1, 0, 0 }, /* Yes, duplicate enable switch. */
292 { "cse", 's', 0, 0, 0 },
293 { "addressof", 'F', 0, 0, 0 },
294 { "gcse", 'G', 1, 0, 0 },
295 { "loop", 'L', 1, 0, 0 },
296 { "cse2", 't', 1, 0, 0 },
297 { "cfg", 'f', 1, 0, 0 },
298 { "bp", 'b', 1, 0, 0 },
299 { "life", 'f', 1, 0, 0 }, /* Yes, duplicate enable switch. */
300 { "combine", 'c', 1, 0, 0 },
301 { "ce", 'C', 1, 0, 0 },
302 { "regmove", 'N', 1, 0, 0 },
303 { "sched", 'S', 1, 0, 0 },
304 { "lreg", 'l', 1, 0, 0 },
305 { "greg", 'g', 1, 0, 0 },
306 { "postreload", 'o', 1, 0, 0 },
307 { "flow2", 'w', 1, 0, 0 },
308 { "peephole2", 'z', 1, 0, 0 },
309 { "rnreg", 'n', 1, 0, 0 },
310 { "ce2", 'E', 1, 0, 0 },
311 { "sched2", 'R', 1, 0, 0 },
312 { "stack", 'k', 1, 0, 0 },
313 { "bbro", 'B', 1, 0, 0 },
314 { "mach", 'M', 1, 0, 0 },
315 { "dbr", 'd', 0, 0, 0 },
316 };
317
318 static int open_dump_file PARAMS ((enum dump_file_index, tree));
319 static void close_dump_file PARAMS ((enum dump_file_index,
320 void (*) (FILE *, rtx), rtx));
321
322 /* Other flags saying which kinds of debugging dump have been requested. */
323
324 int rtl_dump_and_exit;
325 int flag_print_asm_name;
326 static int version_flag;
327 static char *filename;
328 enum graph_dump_types graph_dump_format;
329
330 /* Name for output file of assembly code, specified with -o. */
331
332 char *asm_file_name;
333
334 /* Value of the -G xx switch, and whether it was passed or not. */
335 int g_switch_value;
336 int g_switch_set;
337
338 /* Type(s) of debugging information we are producing (if any).
339 See flags.h for the definitions of the different possible
340 types of debugging information. */
341 enum debug_info_type write_symbols = NO_DEBUG;
342
343 /* Level of debugging information we are producing. See flags.h
344 for the definitions of the different possible levels. */
345 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
346
347 /* Nonzero means use GNU-only extensions in the generated symbolic
348 debugging information. */
349 /* Currently, this only has an effect when write_symbols is set to
350 DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
351 int use_gnu_debug_info_extensions = 0;
352
353 /* Nonzero means do optimizations. -O.
354 Particular numeric values stand for particular amounts of optimization;
355 thus, -O2 stores 2 here. However, the optimizations beyond the basic
356 ones are not controlled directly by this variable. Instead, they are
357 controlled by individual `flag_...' variables that are defaulted
358 based on this variable. */
359
360 int optimize = 0;
361
362 /* Nonzero means optimize for size. -Os.
363 The only valid values are zero and non-zero. When optimize_size is
364 non-zero, optimize defaults to 2, but certain individual code
365 bloating optimizations are disabled. */
366
367 int optimize_size = 0;
368
369 /* Nonzero if we should exit after parsing options. */
370 static int exit_after_options = 0;
371
372 /* The FUNCTION_DECL for the function currently being compiled,
373 or 0 if between functions. */
374 tree current_function_decl;
375
376 /* Set to the FUNC_BEGIN label of the current function, or NULL_TREE
377 if none. */
378 tree current_function_func_begin_label;
379
380 /* Pointer to function to compute the name to use to print a declaration.
381 DECL is the declaration in question.
382 VERBOSITY determines what information will be printed:
383 0: DECL_NAME, demangled as necessary.
384 1: and scope information.
385 2: and any other information that might be interesting, such as function
386 parameter types in C++. */
387
388 const char *(*decl_printable_name) PARAMS ((tree, int));
389
390 /* Pointer to function to compute rtl for a language-specific tree code. */
391
392 typedef rtx (*lang_expand_expr_t)
393 PARAMS ((union tree_node *, rtx, enum machine_mode,
394 enum expand_modifier modifier));
395
396 lang_expand_expr_t lang_expand_expr = 0;
397
398 tree (*lang_expand_constant) PARAMS ((tree)) = 0;
399
400 /* Pointer to function to finish handling an incomplete decl at the
401 end of compilation. */
402
403 void (*incomplete_decl_finalize_hook) PARAMS ((tree)) = 0;
404
405 /* Nonzero if doing dwarf2 duplicate elimination. */
406
407 int flag_eliminate_dwarf2_dups = 0;
408
409 /* Nonzero if generating code to do profiling. */
410
411 int profile_flag = 0;
412
413 /* Nonzero if generating code to do profiling on a line-by-line basis. */
414
415 int profile_block_flag;
416
417 /* Nonzero if generating code to profile program flow graph arcs. */
418
419 int profile_arc_flag = 0;
420
421 /* Nonzero if generating info for gcov to calculate line test coverage. */
422
423 int flag_test_coverage = 0;
424
425 /* Nonzero indicates that branch taken probabilities should be calculated. */
426
427 int flag_branch_probabilities = 0;
428
429 /* Nonzero if basic blocks should be reordered. */
430
431 int flag_reorder_blocks = 0;
432
433 /* Nonzero if registers should be renamed. */
434
435 int flag_rename_registers = 0;
436
437 /* Nonzero for -pedantic switch: warn about anything
438 that standard spec forbids. */
439
440 int pedantic = 0;
441
442 /* Temporarily suppress certain warnings.
443 This is set while reading code from a system header file. */
444
445 int in_system_header = 0;
446
447 /* Don't print functions as they are compiled. -quiet. */
448
449 int quiet_flag = 0;
450
451 /* Print times taken by the various passes. -ftime-report. */
452
453 int time_report = 0;
454
455 /* Print memory still in use at end of compilation (which may have little
456 to do with peak memory consumption). -fmem-report. */
457
458 int mem_report = 0;
459
460 /* Non-zero means to collect statistics which might be expensive
461 and to print them when we are done. */
462 int flag_detailed_statistics = 0;
463
464 \f
465 /* -f flags. */
466
467 /* Nonzero means `char' should be signed. */
468
469 int flag_signed_char;
470
471 /* Nonzero means give an enum type only as many bytes as it needs. */
472
473 int flag_short_enums;
474
475 /* Nonzero for -fcaller-saves: allocate values in regs that need to
476 be saved across function calls, if that produces overall better code.
477 Optional now, so people can test it. */
478
479 #ifdef DEFAULT_CALLER_SAVES
480 int flag_caller_saves = 1;
481 #else
482 int flag_caller_saves = 0;
483 #endif
484
485 /* Nonzero if structures and unions should be returned in memory.
486
487 This should only be defined if compatibility with another compiler or
488 with an ABI is needed, because it results in slower code. */
489
490 #ifndef DEFAULT_PCC_STRUCT_RETURN
491 #define DEFAULT_PCC_STRUCT_RETURN 1
492 #endif
493
494 /* Nonzero for -fpcc-struct-return: return values the same way PCC does. */
495
496 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
497
498 /* Nonzero for -fforce-mem: load memory value into a register
499 before arithmetic on it. This makes better cse but slower compilation. */
500
501 int flag_force_mem = 0;
502
503 /* Nonzero for -fforce-addr: load memory address into a register before
504 reference to memory. This makes better cse but slower compilation. */
505
506 int flag_force_addr = 0;
507
508 /* Nonzero for -fdefer-pop: don't pop args after each function call;
509 instead save them up to pop many calls' args with one insns. */
510
511 int flag_defer_pop = 0;
512
513 /* Nonzero for -ffloat-store: don't allocate floats and doubles
514 in extended-precision registers. */
515
516 int flag_float_store = 0;
517
518 /* Nonzero for -fcse-follow-jumps:
519 have cse follow jumps to do a more extensive job. */
520
521 int flag_cse_follow_jumps;
522
523 /* Nonzero for -fcse-skip-blocks:
524 have cse follow a branch around a block. */
525 int flag_cse_skip_blocks;
526
527 /* Nonzero for -fexpensive-optimizations:
528 perform miscellaneous relatively-expensive optimizations. */
529 int flag_expensive_optimizations;
530
531 /* Nonzero for -fthread-jumps:
532 have jump optimize output of loop. */
533
534 int flag_thread_jumps;
535
536 /* Nonzero enables strength-reduction in loop.c. */
537
538 int flag_strength_reduce = 0;
539
540 /* Nonzero enables loop unrolling in unroll.c. Only loops for which the
541 number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
542 UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
543 unrolled. */
544
545 int flag_unroll_loops;
546
547 /* Nonzero enables loop unrolling in unroll.c. All loops are unrolled.
548 This is generally not a win. */
549
550 int flag_unroll_all_loops;
551
552 /* Nonzero forces all invariant computations in loops to be moved
553 outside the loop. */
554
555 int flag_move_all_movables = 0;
556
557 /* Nonzero forces all general induction variables in loops to be
558 strength reduced. */
559
560 int flag_reduce_all_givs = 0;
561
562 /* Nonzero to perform full register move optimization passes. This is the
563 default for -O2. */
564
565 int flag_regmove = 0;
566
567 /* Nonzero for -fwritable-strings:
568 store string constants in data segment and don't uniquize them. */
569
570 int flag_writable_strings = 0;
571
572 /* Nonzero means don't put addresses of constant functions in registers.
573 Used for compiling the Unix kernel, where strange substitutions are
574 done on the assembly output. */
575
576 int flag_no_function_cse = 0;
577
578 /* Nonzero for -fomit-frame-pointer:
579 don't make a frame pointer in simple functions that don't require one. */
580
581 int flag_omit_frame_pointer = 0;
582
583 /* Nonzero means place each function into its own section on those platforms
584 which support arbitrary section names and unlimited numbers of sections. */
585
586 int flag_function_sections = 0;
587
588 /* ... and similar for data. */
589
590 int flag_data_sections = 0;
591
592 /* Nonzero to inhibit use of define_optimization peephole opts. */
593
594 int flag_no_peephole = 0;
595
596 /* Nonzero allows GCC to optimize sibling and tail recursive calls. */
597
598 int flag_optimize_sibling_calls = 0;
599
600 /* Nonzero means the front end generally wants `errno' maintained by math
601 operations, like built-in SQRT. */
602
603 int flag_errno_math = 1;
604
605 /* Nonzero means that unsafe floating-point math optimizations are allowed
606 for the sake of speed. IEEE compliance is not guaranteed, and operations
607 are allowed to assume that their arguments and results are "normal"
608 (e.g., nonnegative for SQRT). */
609
610 int flag_unsafe_math_optimizations = 0;
611
612 /* Zero means that floating-point math operations cannot generate a
613 (user-visible) trap. This is the case, for example, in nonstop
614 IEEE 754 arithmetic. */
615
616 int flag_trapping_math = 1;
617
618 /* 0 means straightforward implementation of complex divide acceptable.
619 1 means wide ranges of inputs must work for complex divide.
620 2 means C99-like requirements for complex divide (not yet implemented). */
621
622 int flag_complex_divide_method = 0;
623
624 /* Nonzero means all references through pointers are volatile. */
625
626 int flag_volatile;
627
628 /* Nonzero means treat all global and extern variables as volatile. */
629
630 int flag_volatile_global;
631
632 /* Nonzero means treat all static variables as volatile. */
633
634 int flag_volatile_static;
635
636 /* Nonzero means just do syntax checking; don't output anything. */
637
638 int flag_syntax_only = 0;
639
640 /* Nonzero means perform global cse. */
641
642 static int flag_gcse;
643
644 /* Nonzero means to use global dataflow analysis to eliminate
645 useless null pointer tests. */
646
647 static int flag_delete_null_pointer_checks;
648
649 /* Nonzero means to do the enhanced load motion during gcse, which trys
650 to hoist loads by not killing them when a store to the same location
651 is seen. */
652
653 int flag_gcse_lm = 1;
654
655 /* Nonzero means to perform store motion after gcse, which will try to
656 move stores closer to the exit block. Its not very effective without
657 flag_gcse_lm. */
658
659 int flag_gcse_sm = 1;
660
661 /* Nonzero means to rerun cse after loop optimization. This increases
662 compilation time about 20% and picks up a few more common expressions. */
663
664 static int flag_rerun_cse_after_loop;
665
666 /* Nonzero means to run loop optimizations twice. */
667
668 int flag_rerun_loop_opt;
669
670 /* Nonzero for -finline-functions: ok to inline functions that look like
671 good inline candidates. */
672
673 int flag_inline_functions;
674
675 /* Nonzero for -fkeep-inline-functions: even if we make a function
676 go inline everywhere, keep its definition around for debugging
677 purposes. */
678
679 int flag_keep_inline_functions;
680
681 /* Nonzero means that functions will not be inlined. */
682
683 int flag_no_inline;
684
685 /* Nonzero means that we should emit static const variables
686 regardless of whether or not optimization is turned on. */
687
688 int flag_keep_static_consts = 1;
689
690 /* Nonzero means we should be saving declaration info into a .X file. */
691
692 int flag_gen_aux_info = 0;
693
694 /* Specified name of aux-info file. */
695
696 static char *aux_info_file_name;
697
698 /* Nonzero means make the text shared if supported. */
699
700 int flag_shared_data;
701
702 /* Nonzero means schedule into delayed branch slots if supported. */
703
704 int flag_delayed_branch;
705
706 /* Nonzero if we are compiling pure (sharable) code.
707 Value is 1 if we are doing reasonable (i.e. simple
708 offset into offset table) pic. Value is 2 if we can
709 only perform register offsets. */
710
711 int flag_pic;
712
713 /* Nonzero means generate extra code for exception handling and enable
714 exception handling. */
715
716 int flag_exceptions;
717
718 /* Nonzero means generate frame unwind info table when supported. */
719
720 int flag_unwind_tables = 0;
721
722 /* Nonzero means generate frame unwind info table exact at each insn boundary */
723
724 int flag_asynchronous_unwind_tables = 0;
725
726 /* Nonzero means don't place uninitialized global data in common storage
727 by default. */
728
729 int flag_no_common;
730
731 /* Nonzero means pretend it is OK to examine bits of target floats,
732 even if that isn't true. The resulting code will have incorrect constants,
733 but the same series of instructions that the native compiler would make. */
734
735 int flag_pretend_float;
736
737 /* Nonzero means change certain warnings into errors.
738 Usually these are warnings about failure to conform to some standard. */
739
740 int flag_pedantic_errors = 0;
741
742 /* flag_schedule_insns means schedule insns within basic blocks (before
743 local_alloc).
744 flag_schedule_insns_after_reload means schedule insns after
745 global_alloc. */
746
747 int flag_schedule_insns = 0;
748 int flag_schedule_insns_after_reload = 0;
749
750 /* The following flags have effect only for scheduling before register
751 allocation:
752
753 flag_schedule_interblock means schedule insns accross basic blocks.
754 flag_schedule_speculative means allow speculative motion of non-load insns.
755 flag_schedule_speculative_load means allow speculative motion of some
756 load insns.
757 flag_schedule_speculative_load_dangerous allows speculative motion of more
758 load insns. */
759
760 int flag_schedule_interblock = 1;
761 int flag_schedule_speculative = 1;
762 int flag_schedule_speculative_load = 0;
763 int flag_schedule_speculative_load_dangerous = 0;
764
765 int flag_single_precision_constant;
766
767 /* flag_branch_on_count_reg means try to replace add-1,compare,branch tupple
768 by a cheaper branch on a count register. */
769 int flag_branch_on_count_reg = 1;
770
771 /* -finhibit-size-directive inhibits output of .size for ELF.
772 This is used only for compiling crtstuff.c,
773 and it may be extended to other effects
774 needed for crtstuff.c on other systems. */
775 int flag_inhibit_size_directive = 0;
776
777 /* -fverbose-asm causes extra commentary information to be produced in
778 the generated assembly code (to make it more readable). This option
779 is generally only of use to those who actually need to read the
780 generated assembly code (perhaps while debugging the compiler itself).
781 -fno-verbose-asm, the default, causes the extra information
782 to be omitted and is useful when comparing two assembler files. */
783
784 int flag_verbose_asm = 0;
785
786 /* -dA causes debug commentary information to be produced in
787 the generated assembly code (to make it more readable). This option
788 is generally only of use to those who actually need to read the
789 generated assembly code (perhaps while debugging the compiler itself).
790 Currently, this switch is only used by dwarfout.c; however, it is intended
791 to be a catchall for printing debug information in the assembler file. */
792
793 int flag_debug_asm = 0;
794
795 /* -dP causes the rtl to be emitted as a comment in assembly. */
796
797 int flag_dump_rtl_in_asm = 0;
798
799 /* -fgnu-linker specifies use of the GNU linker for initializations.
800 (Or, more generally, a linker that handles initializations.)
801 -fno-gnu-linker says that collect2 will be used. */
802 #ifdef USE_COLLECT2
803 int flag_gnu_linker = 0;
804 #else
805 int flag_gnu_linker = 1;
806 #endif
807
808 /* Enable SSA. */
809 int flag_ssa = 0;
810
811 /* Enable ssa conditional constant propagation. */
812 int flag_ssa_ccp = 0;
813
814 /* Enable ssa aggressive dead code elimination. */
815 int flag_ssa_dce = 0;
816
817 /* Tag all structures with __attribute__(packed). */
818 int flag_pack_struct = 0;
819
820 /* Emit code to check for stack overflow; also may cause large objects
821 to be allocated dynamically. */
822 int flag_stack_check;
823
824 /* When non-NULL, indicates that whenever space is allocated on the
825 stack, the resulting stack pointer must not pass this
826 address---that is, for stacks that grow downward, the stack pointer
827 must always be greater than or equal to this address; for stacks
828 that grow upward, the stack pointer must be less than this address.
829 At present, the rtx may be either a REG or a SYMBOL_REF, although
830 the support provided depends on the backend. */
831 rtx stack_limit_rtx;
832
833 /* -fcheck-memory-usage causes extra code to be generated in order to check
834 memory accesses. This is used by a detector of bad memory accesses such
835 as Checker. */
836 int flag_check_memory_usage = 0;
837
838 /* -fprefix-function-name causes function name to be prefixed. This
839 can be used with -fcheck-memory-usage to isolate code compiled with
840 -fcheck-memory-usage. */
841 int flag_prefix_function_name = 0;
842
843 /* 0 if pointer arguments may alias each other. True in C.
844 1 if pointer arguments may not alias each other but may alias
845 global variables.
846 2 if pointer arguments may not alias each other and may not
847 alias global variables. True in Fortran.
848 This defaults to 0 for C. */
849 int flag_argument_noalias = 0;
850
851 /* Nonzero if we should do (language-dependent) alias analysis.
852 Typically, this analysis will assume that expressions of certain
853 types do not alias expressions of certain other types. Only used
854 if alias analysis (in general) is enabled. */
855 int flag_strict_aliasing = 0;
856
857 /* Instrument functions with calls at entry and exit, for profiling. */
858 int flag_instrument_function_entry_exit = 0;
859
860 /* Nonzero means ignore `#ident' directives. 0 means handle them.
861 On SVR4 targets, it also controls whether or not to emit a
862 string identifying the compiler. */
863
864 int flag_no_ident = 0;
865
866 /* This will perform a peephole pass before sched2. */
867 int flag_peephole2 = 0;
868
869 /* This will try to guess branch probabilities. */
870 int flag_guess_branch_prob = 0;
871
872 /* -fbounded-pointers causes gcc to compile pointers as composite
873 objects occupying three words: the pointer value, the base address
874 of the referent object, and the address immediately beyond the end
875 of the referent object. The base and extent allow us to perform
876 runtime bounds checking. -fbounded-pointers implies -fcheck-bounds. */
877 int flag_bounded_pointers = 0;
878
879 /* -fcheck-bounds causes gcc to generate array bounds checks.
880 For C, C++: defaults to value of flag_bounded_pointers.
881 For ObjC: defaults to off.
882 For Java: defaults to on.
883 For Fortran: defaults to off.
884 For CHILL: defaults to off. */
885 int flag_bounds_check = 0;
886
887 /* This will attempt to merge constant section constants, if 1 only
888 string constants and constants from constant pool, if 2 also constant
889 variables. */
890 int flag_merge_constants = 1;
891
892 /* If one, renumber instruction UIDs to reduce the number of
893 unused UIDs if there are a lot of instructions. If greater than
894 one, unconditionally renumber instruction UIDs. */
895 int flag_renumber_insns = 1;
896
897 /* Values of the -falign-* flags: how much to align labels in code.
898 0 means `use default', 1 means `don't align'.
899 For each variable, there is an _log variant which is the power
900 of two not less than the variable, for .align output. */
901
902 int align_loops;
903 int align_loops_log;
904 int align_loops_max_skip;
905 int align_jumps;
906 int align_jumps_log;
907 int align_jumps_max_skip;
908 int align_labels;
909 int align_labels_log;
910 int align_labels_max_skip;
911 int align_functions;
912 int align_functions_log;
913
914 /* Table of supported debugging formats. */
915 static const struct
916 {
917 const char *const arg;
918 /* Since PREFERRED_DEBUGGING_TYPE isn't necessarily a
919 constant expression, we use NO_DEBUG in its place. */
920 const enum debug_info_type debug_type;
921 const int use_extensions_p;
922 const char *const description;
923 } *da,
924 debug_args[] =
925 {
926 { "", NO_DEBUG, DEFAULT_GDB_EXTENSIONS,
927 N_("Generate debugging info in default format") },
928 { "gdb", NO_DEBUG, 1, N_("Generate debugging info in default extended format") },
929 #ifdef DBX_DEBUGGING_INFO
930 { "stabs", DBX_DEBUG, 0, N_("Generate STABS format debug info") },
931 { "stabs+", DBX_DEBUG, 1, N_("Generate extended STABS format debug info") },
932 #endif
933 #ifdef DWARF_DEBUGGING_INFO
934 { "dwarf", DWARF_DEBUG, 0, N_("Generate DWARF-1 format debug info") },
935 { "dwarf+", DWARF_DEBUG, 1,
936 N_("Generate extended DWARF-1 format debug info") },
937 #endif
938 #ifdef DWARF2_DEBUGGING_INFO
939 { "dwarf-2", DWARF2_DEBUG, 0, N_("Generate DWARF-2 debug info") },
940 #endif
941 #ifdef XCOFF_DEBUGGING_INFO
942 { "xcoff", XCOFF_DEBUG, 0, N_("Generate XCOFF format debug info") },
943 { "xcoff+", XCOFF_DEBUG, 1, N_("Generate extended XCOFF format debug info") },
944 #endif
945 #ifdef SDB_DEBUGGING_INFO
946 { "coff", SDB_DEBUG, 0, N_("Generate COFF format debug info") },
947 #endif
948 { 0, 0, 0, 0 }
949 };
950
951 typedef struct
952 {
953 const char *string;
954 int *variable;
955 int on_value;
956 const char *description;
957 }
958 lang_independent_options;
959
960 int flag_trapv = 0;
961
962 /* Add or remove a leading underscore from user symbols. */
963 int flag_leading_underscore = -1;
964
965 /* The user symbol prefix after having resolved same. */
966 const char *user_label_prefix;
967
968 static const param_info lang_independent_params[] = {
969 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT) \
970 { OPTION, DEFAULT, HELP },
971 #include "params.def"
972 #undef DEFPARAM
973 { NULL, 0, NULL }
974 };
975
976 /* A default for same. */
977 #ifndef USER_LABEL_PREFIX
978 #define USER_LABEL_PREFIX ""
979 #endif
980
981 /* Table of language-independent -f options.
982 STRING is the option name. VARIABLE is the address of the variable.
983 ON_VALUE is the value to store in VARIABLE
984 if `-fSTRING' is seen as an option.
985 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */
986
987 lang_independent_options f_options[] =
988 {
989 {"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
990 N_("Perform DWARF2 duplicate elimination") },
991 {"float-store", &flag_float_store, 1,
992 N_("Do not store floats in registers") },
993 {"volatile", &flag_volatile, 1,
994 N_("Consider all mem refs through pointers as volatile") },
995 {"volatile-global", &flag_volatile_global, 1,
996 N_("Consider all mem refs to global data to be volatile") },
997 {"volatile-static", &flag_volatile_static, 1,
998 N_("Consider all mem refs to static data to be volatile") },
999 {"defer-pop", &flag_defer_pop, 1,
1000 N_("Defer popping functions args from stack until later") },
1001 {"omit-frame-pointer", &flag_omit_frame_pointer, 1,
1002 N_("When possible do not generate stack frames") },
1003 {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1,
1004 N_("Optimize sibling and tail recursive calls") },
1005 {"cse-follow-jumps", &flag_cse_follow_jumps, 1,
1006 N_("When running CSE, follow jumps to their targets") },
1007 {"cse-skip-blocks", &flag_cse_skip_blocks, 1,
1008 N_("When running CSE, follow conditional jumps") },
1009 {"expensive-optimizations", &flag_expensive_optimizations, 1,
1010 N_("Perform a number of minor, expensive optimisations") },
1011 {"thread-jumps", &flag_thread_jumps, 1,
1012 N_("Perform jump threading optimisations") },
1013 {"strength-reduce", &flag_strength_reduce, 1,
1014 N_("Perform strength reduction optimisations") },
1015 {"unroll-loops", &flag_unroll_loops, 1,
1016 N_("Perform loop unrolling when iteration count is known") },
1017 {"unroll-all-loops", &flag_unroll_all_loops, 1,
1018 N_("Perform loop unrolling for all loops") },
1019 {"move-all-movables", &flag_move_all_movables, 1,
1020 N_("Force all loop invariant computations out of loops") },
1021 {"reduce-all-givs", &flag_reduce_all_givs, 1,
1022 N_("Strength reduce all loop general induction variables") },
1023 {"writable-strings", &flag_writable_strings, 1,
1024 N_("Store strings in writable data section") },
1025 {"peephole", &flag_no_peephole, 0,
1026 N_("Enable machine specific peephole optimisations") },
1027 {"force-mem", &flag_force_mem, 1,
1028 N_("Copy memory operands into registers before using") },
1029 {"force-addr", &flag_force_addr, 1,
1030 N_("Copy memory address constants into regs before using") },
1031 {"function-cse", &flag_no_function_cse, 0,
1032 N_("Allow function addresses to be held in registers") },
1033 {"inline-functions", &flag_inline_functions, 1,
1034 N_("Integrate simple functions into their callers") },
1035 {"keep-inline-functions", &flag_keep_inline_functions, 1,
1036 N_("Generate code for funcs even if they are fully inlined") },
1037 {"inline", &flag_no_inline, 0,
1038 N_("Pay attention to the 'inline' keyword") },
1039 {"keep-static-consts", &flag_keep_static_consts, 1,
1040 N_("Emit static const variables even if they are not used") },
1041 {"syntax-only", &flag_syntax_only, 1,
1042 N_("Check for syntax errors, then stop") },
1043 {"shared-data", &flag_shared_data, 1,
1044 N_("Mark data as shared rather than private") },
1045 {"caller-saves", &flag_caller_saves, 1,
1046 N_("Enable saving registers around function calls") },
1047 {"pcc-struct-return", &flag_pcc_struct_return, 1,
1048 N_("Return 'short' aggregates in memory, not registers") },
1049 {"reg-struct-return", &flag_pcc_struct_return, 0,
1050 N_("Return 'short' aggregates in registers") },
1051 {"delayed-branch", &flag_delayed_branch, 1,
1052 N_("Attempt to fill delay slots of branch instructions") },
1053 {"gcse", &flag_gcse, 1,
1054 N_("Perform the global common subexpression elimination") },
1055 {"gcse-lm", &flag_gcse_lm, 1,
1056 N_("Perform enhanced load motion during global subexpression elimination") },
1057 {"gcse-sm", &flag_gcse_sm, 1,
1058 N_("Perform store motion after global subexpression elimination") },
1059 {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
1060 N_("Run CSE pass after loop optimisations") },
1061 {"rerun-loop-opt", &flag_rerun_loop_opt, 1,
1062 N_("Run the loop optimiser twice") },
1063 {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
1064 N_("Delete useless null pointer checks") },
1065 {"pretend-float", &flag_pretend_float, 1,
1066 N_("Pretend that host and target use the same FP format") },
1067 {"schedule-insns", &flag_schedule_insns, 1,
1068 N_("Reschedule instructions before register allocation") },
1069 {"schedule-insns2", &flag_schedule_insns_after_reload, 1,
1070 N_("Reschedule instructions after register allocation") },
1071 {"sched-interblock",&flag_schedule_interblock, 1,
1072 N_("Enable scheduling across basic blocks") },
1073 {"sched-spec",&flag_schedule_speculative, 1,
1074 N_("Allow speculative motion of non-loads") },
1075 {"sched-spec-load",&flag_schedule_speculative_load, 1,
1076 N_("Allow speculative motion of some loads") },
1077 {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
1078 N_("Allow speculative motion of more loads") },
1079 {"branch-count-reg",&flag_branch_on_count_reg, 1,
1080 N_("Replace add,compare,branch with branch on count reg") },
1081 {"pic", &flag_pic, 1,
1082 N_("Generate position independent code, if possible") },
1083 {"PIC", &flag_pic, 2, ""},
1084 {"exceptions", &flag_exceptions, 1,
1085 N_("Enable exception handling") },
1086 {"unwind-tables", &flag_unwind_tables, 1,
1087 N_("Just generate unwind tables for exception handling") },
1088 {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1,
1089 N_("Generate unwind tables exact at each instruction boundary") },
1090 {"non-call-exceptions", &flag_non_call_exceptions, 1,
1091 N_("Support synchronous non-call exceptions") },
1092 {"profile-arcs", &profile_arc_flag, 1,
1093 N_("Insert arc based program profiling code") },
1094 {"test-coverage", &flag_test_coverage, 1,
1095 N_("Create data files needed by gcov") },
1096 {"branch-probabilities", &flag_branch_probabilities, 1,
1097 N_("Use profiling information for branch probabilities") },
1098 {"reorder-blocks", &flag_reorder_blocks, 1,
1099 N_("Reorder basic blocks to improve code placement") },
1100 {"rename-registers", &flag_rename_registers, 1,
1101 N_("Do the register renaming optimization pass") },
1102 {"common", &flag_no_common, 0,
1103 N_("Do not put uninitialized globals in the common section") },
1104 {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
1105 N_("Do not generate .size directives") },
1106 {"function-sections", &flag_function_sections, 1,
1107 N_("place each function into its own section") },
1108 {"data-sections", &flag_data_sections, 1,
1109 N_("place data items into their own section") },
1110 {"verbose-asm", &flag_verbose_asm, 1,
1111 N_("Add extra commentry to assembler output") },
1112 {"gnu-linker", &flag_gnu_linker, 1,
1113 N_("Output GNU ld formatted global initialisers") },
1114 {"regmove", &flag_regmove, 1,
1115 N_("Enables a register move optimisation") },
1116 {"optimize-register-move", &flag_regmove, 1,
1117 N_("Do the full regmove optimization pass") },
1118 {"pack-struct", &flag_pack_struct, 1,
1119 N_("Pack structure members together without holes") },
1120 {"stack-check", &flag_stack_check, 1,
1121 N_("Insert stack checking code into the program") },
1122 {"argument-alias", &flag_argument_noalias, 0,
1123 N_("Specify that arguments may alias each other & globals") },
1124 {"argument-noalias", &flag_argument_noalias, 1,
1125 N_("Assume arguments may alias globals but not each other") },
1126 {"argument-noalias-global", &flag_argument_noalias, 2,
1127 N_("Assume arguments do not alias each other or globals") },
1128 {"strict-aliasing", &flag_strict_aliasing, 1,
1129 N_("Assume strict aliasing rules apply") },
1130 {"align-loops", &align_loops, 0,
1131 N_("Align the start of loops") },
1132 {"align-jumps", &align_jumps, 0,
1133 N_("Align labels which are only reached by jumping") },
1134 {"align-labels", &align_labels, 0,
1135 N_("Align all labels") },
1136 {"align-functions", &align_functions, 0,
1137 N_("Align the start of functions") },
1138 {"merge-constants", &flag_merge_constants, 1,
1139 N_("Attempt to merge identical constants accross compilation units") },
1140 {"merge-all-constants", &flag_merge_constants, 2,
1141 N_("Attempt to merge identical constants and constant variables") },
1142 {"check-memory-usage", &flag_check_memory_usage, 1,
1143 N_("Generate code to check every memory access") },
1144 {"prefix-function-name", &flag_prefix_function_name, 1,
1145 N_("Add a prefix to all function names") },
1146 {"dump-unnumbered", &flag_dump_unnumbered, 1,
1147 N_("Suppress output of instruction numbers and line number notes in debugging dumps") },
1148 {"instrument-functions", &flag_instrument_function_entry_exit, 1,
1149 N_("Instrument function entry/exit with profiling calls") },
1150 {"ssa", &flag_ssa, 1,
1151 N_("Enable SSA optimizations") },
1152 {"ssa-ccp", &flag_ssa_ccp, 1,
1153 N_("Enable SSA conditional constant propagation") },
1154 {"ssa-dce", &flag_ssa_dce, 1,
1155 N_("Enable aggressive SSA dead code elimination") },
1156 {"leading-underscore", &flag_leading_underscore, 1,
1157 N_("External symbols have a leading underscore") },
1158 {"ident", &flag_no_ident, 0,
1159 N_("Process #ident directives") },
1160 { "peephole2", &flag_peephole2, 1,
1161 N_("Enables an rtl peephole pass run before sched2") },
1162 { "guess-branch-probability", &flag_guess_branch_prob, 1,
1163 N_("Enables guessing of branch probabilities") },
1164 {"math-errno", &flag_errno_math, 1,
1165 N_("Set errno after built-in math functions") },
1166 {"trapping-math", &flag_trapping_math, 1,
1167 N_("Floating-point operations can trap") },
1168 {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1,
1169 N_("Allow math optimizations that may violate IEEE or ANSI standards") },
1170 {"bounded-pointers", &flag_bounded_pointers, 1,
1171 N_("Compile pointers as triples: value, base & end") },
1172 {"bounds-check", &flag_bounds_check, 1,
1173 N_("Generate code to check bounds before dereferencing pointers and arrays") },
1174 {"single-precision-constant", &flag_single_precision_constant, 1,
1175 N_("Convert floating point constant to single precision constant") },
1176 {"time-report", &time_report, 1,
1177 N_("Report time taken by each compiler pass at end of run") },
1178 {"mem-report", &mem_report, 1,
1179 N_("Report on permanent memory allocation at end of run") },
1180 { "trapv", &flag_trapv, 1,
1181 N_("Trap for signed overflow in addition / subtraction / multiplication") },
1182 };
1183
1184 /* Table of language-specific options. */
1185
1186 static const struct lang_opt
1187 {
1188 const char *const option;
1189 const char *const description;
1190 }
1191 documented_lang_options[] =
1192 {
1193 /* In order not to overload the --help output, the convention
1194 used here is to only describe those options which are not
1195 enabled by default. */
1196
1197 { "-ansi",
1198 N_("Compile just for ISO C89") },
1199 { "-fallow-single-precision",
1200 N_("Do not promote floats to double if using -traditional") },
1201 { "-std= ",
1202 N_("Determine language standard") },
1203
1204 { "-fsigned-bitfields", "" },
1205 { "-funsigned-bitfields",
1206 N_("Make bitfields by unsigned by default") },
1207 { "-fno-signed-bitfields", "" },
1208 { "-fno-unsigned-bitfields","" },
1209 { "-fsigned-char",
1210 N_("Make 'char' be signed by default") },
1211 { "-funsigned-char",
1212 N_("Make 'char' be unsigned by default") },
1213 { "-fno-signed-char", "" },
1214 { "-fno-unsigned-char", "" },
1215
1216 { "-ftraditional", "" },
1217 { "-traditional",
1218 N_("Attempt to support traditional K&R style C") },
1219 { "-fnotraditional", "" },
1220 { "-fno-traditional", "" },
1221
1222 { "-fasm", "" },
1223 { "-fno-asm",
1224 N_("Do not recognise the 'asm' keyword") },
1225 { "-fbuiltin", "" },
1226 { "-fno-builtin",
1227 N_("Do not recognise any built in functions") },
1228 { "-fhosted",
1229 N_("Assume normal C execution environment") },
1230 { "-fno-hosted", "" },
1231 { "-ffreestanding",
1232 N_("Assume that standard libraries & main might not exist") },
1233 { "-fno-freestanding", "" },
1234 { "-fcond-mismatch",
1235 N_("Allow different types as args of ? operator") },
1236 { "-fno-cond-mismatch", "" },
1237 { "-fdollars-in-identifiers",
1238 N_("Allow the use of $ inside identifiers") },
1239 { "-fno-dollars-in-identifiers", "" },
1240 { "-fpreprocessed", "" },
1241 { "-fno-preprocessed", "" },
1242 { "-fshort-double",
1243 N_("Use the same size for double as for float") },
1244 { "-fno-short-double", "" },
1245 { "-fshort-enums",
1246 N_("Use the smallest fitting integer to hold enums") },
1247 { "-fno-short-enums", "" },
1248 { "-fshort-wchar",
1249 N_("Override the underlying type for wchar_t to `unsigned short'") },
1250 { "-fno-short-wchar", "" },
1251
1252 { "-Wall",
1253 N_("Enable most warning messages") },
1254 { "-Wbad-function-cast",
1255 N_("Warn about casting functions to incompatible types") },
1256 { "-Wno-bad-function-cast", "" },
1257 { "-Wno-missing-noreturn", "" },
1258 { "-Wmissing-format-attribute",
1259 N_("Warn about functions which might be candidates for format attributes") },
1260 { "-Wno-missing-format-attribute", "" },
1261 { "-Wcast-qual",
1262 N_("Warn about casts which discard qualifiers") },
1263 { "-Wno-cast-qual", "" },
1264 { "-Wchar-subscripts",
1265 N_("Warn about subscripts whose type is 'char'") },
1266 { "-Wno-char-subscripts", "" },
1267 { "-Wcomment",
1268 N_("Warn if nested comments are detected") },
1269 { "-Wno-comment", "" },
1270 { "-Wcomments",
1271 N_("Warn if nested comments are detected") },
1272 { "-Wno-comments", "" },
1273 { "-Wconversion",
1274 N_("Warn about possibly confusing type conversions") },
1275 { "-Wno-conversion", "" },
1276 { "-Wformat",
1277 N_("Warn about printf/scanf/strftime/strfmon format anomalies") },
1278 { "-Wno-format", "" },
1279 { "-Wformat-y2k", "" },
1280 { "-Wno-format-y2k",
1281 N_("Don't warn about strftime formats yielding 2 digit years") },
1282 { "-Wformat-extra-args", "" },
1283 { "-Wno-format-extra-args",
1284 N_("Don't warn about too many arguments to format functions") },
1285 { "-Wformat-nonliteral",
1286 N_("Warn about non-string-literal format strings") },
1287 { "-Wno-format-nonliteral", "" },
1288 { "-Wformat-security",
1289 N_("Warn about possible security problems with format functions") },
1290 { "-Wno-format-security", "" },
1291 { "-Wimplicit-function-declaration",
1292 N_("Warn about implicit function declarations") },
1293 { "-Wno-implicit-function-declaration", "" },
1294 { "-Werror-implicit-function-declaration", "" },
1295 { "-Wimplicit-int",
1296 N_("Warn when a declaration does not specify a type") },
1297 { "-Wno-implicit-int", "" },
1298 { "-Wimplicit", "" },
1299 { "-Wno-implicit", "" },
1300 { "-Wimport",
1301 N_("Warn about the use of the #import directive") },
1302 { "-Wno-import", "" },
1303 { "-Wlong-long","" },
1304 { "-Wno-long-long",
1305 N_("Do not warn about using 'long long' when -pedantic") },
1306 { "-Wmain",
1307 N_("Warn about suspicious declarations of main") },
1308 { "-Wno-main", "" },
1309 { "-Wmissing-braces",
1310 N_("Warn about possibly missing braces around initialisers") },
1311 { "-Wno-missing-braces", "" },
1312 { "-Wmissing-declarations",
1313 N_("Warn about global funcs without previous declarations") },
1314 { "-Wno-missing-declarations", "" },
1315 { "-Wmissing-prototypes",
1316 N_("Warn about global funcs without prototypes") },
1317 { "-Wno-missing-prototypes", "" },
1318 { "-Wmultichar",
1319 N_("Warn about use of multicharacter literals") },
1320 { "-Wno-multichar", "" },
1321 { "-Wnested-externs",
1322 N_("Warn about externs not at file scope level") },
1323 { "-Wno-nested-externs", "" },
1324 { "-Wparentheses",
1325 N_("Warn about possible missing parentheses") },
1326 { "-Wno-parentheses", "" },
1327 { "-Wsequence-point",
1328 N_("Warn about possible violations of sequence point rules") },
1329 { "-Wno-sequence-point", "" },
1330 { "-Wpointer-arith",
1331 N_("Warn about function pointer arithmetic") },
1332 { "-Wno-pointer-arith", "" },
1333 { "-Wredundant-decls",
1334 N_("Warn about multiple declarations of the same object") },
1335 { "-Wno-redundant-decls", "" },
1336 { "-Wsign-compare",
1337 N_("Warn about signed/unsigned comparisons") },
1338 { "-Wno-sign-compare", "" },
1339 { "-Wfloat-equal",
1340 N_("Warn about testing equality of floating point numbers") },
1341 { "-Wno-float-equal", "" },
1342 { "-Wunknown-pragmas",
1343 N_("Warn about unrecognized pragmas") },
1344 { "-Wno-unknown-pragmas", "" },
1345 { "-Wstrict-prototypes",
1346 N_("Warn about non-prototyped function decls") },
1347 { "-Wno-strict-prototypes", "" },
1348 { "-Wtraditional",
1349 N_("Warn about constructs whose meaning change in ISO C") },
1350 { "-Wno-traditional", "" },
1351 { "-Wtrigraphs",
1352 N_("Warn when trigraphs are encountered") },
1353 { "-Wno-trigraphs", "" },
1354 { "-Wundef", "" },
1355 { "-Wno-undef", "" },
1356 { "-Wwrite-strings",
1357 N_("Mark strings as 'const char *'") },
1358 { "-Wno-write-strings", "" },
1359
1360 #define DEFINE_LANG_NAME(NAME) { NULL, NAME },
1361
1362 #include "options.h"
1363
1364 };
1365
1366 /* Here is a table, controlled by the tm.h file, listing each -m switch
1367 and which bits in `target_switches' it should set or clear.
1368 If VALUE is positive, it is bits to set.
1369 If VALUE is negative, -VALUE is bits to clear.
1370 (The sign bit is not used so there is no confusion.) */
1371
1372 static const struct
1373 {
1374 const char *const name;
1375 const int value;
1376 const char *const description;
1377 }
1378 target_switches [] = TARGET_SWITCHES;
1379
1380 /* This table is similar, but allows the switch to have a value. */
1381
1382 #ifdef TARGET_OPTIONS
1383 static const struct
1384 {
1385 const char *const prefix;
1386 const char **const variable;
1387 const char *const description;
1388 }
1389 target_options [] = TARGET_OPTIONS;
1390 #endif
1391 \f
1392 /* Options controlling warnings. */
1393
1394 /* Don't print warning messages. -w. */
1395
1396 int inhibit_warnings = 0;
1397
1398 /* Don't suppress warnings from system headers. -Wsystem-headers. */
1399
1400 int warn_system_headers = 0;
1401
1402 /* Print various extra warnings. -W. */
1403
1404 int extra_warnings = 0;
1405
1406 /* Treat warnings as errors. -Werror. */
1407
1408 int warnings_are_errors = 0;
1409
1410 /* Nonzero to warn about unused variables, functions et.al. */
1411
1412 int warn_unused_function;
1413 int warn_unused_label;
1414 int warn_unused_parameter;
1415 int warn_unused_variable;
1416 int warn_unused_value;
1417
1418 /* Nonzero to warn about code which is never reached. */
1419
1420 int warn_notreached;
1421
1422 /* Nonzero to warn about variables used before they are initialized. */
1423
1424 int warn_uninitialized;
1425
1426 /* Nonzero means warn about all declarations which shadow others. */
1427
1428 int warn_shadow;
1429
1430 /* Warn if a switch on an enum fails to have a case for every enum value. */
1431
1432 int warn_switch;
1433
1434 /* Nonzero means warn about function definitions that default the return type
1435 or that use a null return and have a return-type other than void. */
1436
1437 int warn_return_type;
1438
1439 /* Nonzero means warn about pointer casts that increase the required
1440 alignment of the target type (and might therefore lead to a crash
1441 due to a misaligned access). */
1442
1443 int warn_cast_align;
1444
1445 /* Nonzero means warn about any objects definitions whose size is larger
1446 than N bytes. Also want about function definitions whose returned
1447 values are larger than N bytes. The value N is in `larger_than_size'. */
1448
1449 int warn_larger_than;
1450 HOST_WIDE_INT larger_than_size;
1451
1452 /* Nonzero means warn if inline function is too large. */
1453
1454 int warn_inline;
1455
1456 /* Warn if a function returns an aggregate,
1457 since there are often incompatible calling conventions for doing this. */
1458
1459 int warn_aggregate_return;
1460
1461 /* Warn if packed attribute on struct is unnecessary and inefficient. */
1462
1463 int warn_packed;
1464
1465 /* Warn when gcc pads a structure to an alignment boundary. */
1466
1467 int warn_padded;
1468
1469 /* Warn when an optimization pass is disabled. */
1470
1471 int warn_disabled_optimization;
1472
1473 /* Warn about functions which might be candidates for attribute noreturn. */
1474
1475 int warn_missing_noreturn;
1476
1477 /* Likewise for -W. */
1478
1479 lang_independent_options W_options[] =
1480 {
1481 {"unused-function", &warn_unused_function, 1,
1482 N_("Warn when a function is unused") },
1483 {"unused-label", &warn_unused_label, 1,
1484 N_("Warn when a label is unused") },
1485 {"unused-parameter", &warn_unused_parameter, 1,
1486 N_("Warn when a function parameter is unused") },
1487 {"unused-variable", &warn_unused_variable, 1,
1488 N_("Warn when a variable is unused") },
1489 {"unused-value", &warn_unused_value, 1,
1490 N_("Warn when an expression value is unused") },
1491 {"system-headers", &warn_system_headers, 1,
1492 N_("Do not suppress warnings from system headers") },
1493 {"error", &warnings_are_errors, 1,
1494 N_("Treat all warnings as errors") },
1495 {"shadow", &warn_shadow, 1,
1496 N_("Warn when one local variable shadows another") },
1497 {"switch", &warn_switch, 1,
1498 N_("Warn about enumerated switches missing a specific case") },
1499 {"aggregate-return", &warn_aggregate_return, 1,
1500 N_("Warn about returning structures, unions or arrays") },
1501 {"cast-align", &warn_cast_align, 1,
1502 N_("Warn about pointer casts which increase alignment") },
1503 {"unreachable-code", &warn_notreached, 1,
1504 N_("Warn about code that will never be executed") },
1505 {"uninitialized", &warn_uninitialized, 1,
1506 N_("Warn about uninitialized automatic variables") },
1507 {"inline", &warn_inline, 1,
1508 N_("Warn when an inlined function cannot be inlined") },
1509 {"packed", &warn_packed, 1,
1510 N_("Warn when the packed attribute has no effect on struct layout") },
1511 {"padded", &warn_padded, 1,
1512 N_("Warn when padding is required to align struct members") },
1513 {"disabled-optimization", &warn_disabled_optimization, 1,
1514 N_("Warn when an optimization pass is disabled") },
1515 {"missing-noreturn", &warn_missing_noreturn, 1,
1516 N_("Warn about functions which might be candidates for attribute noreturn") }
1517 };
1518
1519 void
1520 set_Wunused (setting)
1521 int setting;
1522 {
1523 warn_unused_function = setting;
1524 warn_unused_label = setting;
1525 /* Unused function parameter warnings are reported when either ``-W
1526 -Wunused'' or ``-Wunused-parameter'' is specified. Differentiate
1527 -Wunused by setting WARN_UNUSED_PARAMETER to -1. */
1528 if (!setting)
1529 warn_unused_parameter = 0;
1530 else if (!warn_unused_parameter)
1531 warn_unused_parameter = -1;
1532 warn_unused_variable = setting;
1533 warn_unused_value = setting;
1534 }
1535
1536 /* The following routines are useful in setting all the flags that
1537 -ffast-math and -fno-fast-math imply. */
1538
1539 void
1540 set_fast_math_flags ()
1541 {
1542 flag_trapping_math = 0;
1543 flag_unsafe_math_optimizations = 1;
1544 flag_errno_math = 0;
1545 }
1546
1547 void
1548 set_no_fast_math_flags ()
1549 {
1550 flag_trapping_math = 1;
1551 flag_unsafe_math_optimizations = 0;
1552 flag_errno_math = 1;
1553 }
1554
1555 \f
1556 /* Output files for assembler code (real compiler output)
1557 and debugging dumps. */
1558
1559 FILE *asm_out_file;
1560 FILE *aux_info_file;
1561 FILE *rtl_dump_file = NULL;
1562
1563 /* Decode the string P as an integral parameter.
1564 If the string is indeed an integer return its numeric value else
1565 issue an Invalid Option error for the option PNAME and return DEFVAL.
1566 If PNAME is zero just return DEFVAL, do not call error. */
1567
1568 int
1569 read_integral_parameter (p, pname, defval)
1570 const char *p;
1571 const char *pname;
1572 const int defval;
1573 {
1574 const char *endp = p;
1575
1576 while (*endp)
1577 {
1578 if (ISDIGIT (*endp))
1579 endp++;
1580 else
1581 break;
1582 }
1583
1584 if (*endp != 0)
1585 {
1586 if (pname != 0)
1587 error ("Invalid option `%s'", pname);
1588 return defval;
1589 }
1590
1591 return atoi (p);
1592 }
1593
1594 \f
1595 /* This is the default decl_printable_name function. */
1596
1597 static const char *
1598 decl_name (decl, verbosity)
1599 tree decl;
1600 int verbosity ATTRIBUTE_UNUSED;
1601 {
1602 return IDENTIFIER_POINTER (DECL_NAME (decl));
1603 }
1604 \f
1605
1606 /* This calls abort and is used to avoid problems when abort if a macro.
1607 It is used when we need to pass the address of abort. */
1608
1609 void
1610 do_abort ()
1611 {
1612 abort ();
1613 }
1614
1615 /* When `malloc.c' is compiled with `rcheck' defined,
1616 it calls this function to report clobberage. */
1617
1618 void
1619 botch (s)
1620 const char *s ATTRIBUTE_UNUSED;
1621 {
1622 abort ();
1623 }
1624 \f
1625 /* Return the logarithm of X, base 2, considering X unsigned,
1626 if X is a power of 2. Otherwise, returns -1.
1627
1628 This should be used via the `exact_log2' macro. */
1629
1630 int
1631 exact_log2_wide (x)
1632 unsigned HOST_WIDE_INT x;
1633 {
1634 int log = 0;
1635 /* Test for 0 or a power of 2. */
1636 if (x == 0 || x != (x & -x))
1637 return -1;
1638 while ((x >>= 1) != 0)
1639 log++;
1640 return log;
1641 }
1642
1643 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1644 If X is 0, return -1.
1645
1646 This should be used via the floor_log2 macro. */
1647
1648 int
1649 floor_log2_wide (x)
1650 unsigned HOST_WIDE_INT x;
1651 {
1652 int log = -1;
1653 while (x != 0)
1654 log++,
1655 x >>= 1;
1656 return log;
1657 }
1658
1659 static int float_handler_set;
1660 int float_handled;
1661 jmp_buf float_handler;
1662
1663 /* Signals actually come here. */
1664
1665 static void
1666 float_signal (signo)
1667 /* If this is missing, some compilers complain. */
1668 int signo ATTRIBUTE_UNUSED;
1669 {
1670 if (float_handled == 0)
1671 crash_signal (signo);
1672 float_handled = 0;
1673
1674 /* On System-V derived systems, we must reinstall the signal handler.
1675 This is harmless on BSD-derived systems. */
1676 signal (SIGFPE, float_signal);
1677 longjmp (float_handler, 1);
1678 }
1679
1680 /* Specify where to longjmp to when a floating arithmetic error happens.
1681 If HANDLER is 0, it means don't handle the errors any more. */
1682
1683 static void
1684 set_float_handler (handler)
1685 jmp_buf handler;
1686 {
1687 float_handled = (handler != 0);
1688 if (handler)
1689 memcpy (float_handler, handler, sizeof (float_handler));
1690
1691 if (float_handled && ! float_handler_set)
1692 {
1693 signal (SIGFPE, float_signal);
1694 float_handler_set = 1;
1695 }
1696 }
1697
1698 /* This is a wrapper function for code which might elicit an
1699 arithmetic exception. That code should be passed in as a function
1700 pointer FN, and one argument DATA. DATA is usually a struct which
1701 contains the real input and output for function FN. This function
1702 returns 0 (failure) if longjmp was called (i.e. an exception
1703 occurred.) It returns 1 (success) otherwise. */
1704
1705 int
1706 do_float_handler (fn, data)
1707 void (*fn) PARAMS ((PTR));
1708 PTR data;
1709 {
1710 jmp_buf buf;
1711
1712 if (setjmp (buf))
1713 {
1714 /* We got here via longjmp () caused by an exception in function
1715 fn (). */
1716 set_float_handler (NULL);
1717 return 0;
1718 }
1719
1720 set_float_handler (buf);
1721 (*fn)(data);
1722 set_float_handler (NULL);
1723 return 1;
1724 }
1725
1726 /* Handler for fatal signals, such as SIGSEGV. These are transformed
1727 into ICE messages, which is much more user friendly. */
1728
1729 static void
1730 crash_signal (signo)
1731 int signo;
1732 {
1733 internal_error ("Internal error: %s", strsignal (signo));
1734 }
1735
1736 /* Strip off a legitimate source ending from the input string NAME of
1737 length LEN. Rather than having to know the names used by all of
1738 our front ends, we strip off an ending of a period followed by
1739 up to five characters. (Java uses ".class".) */
1740
1741 void
1742 strip_off_ending (name, len)
1743 char *name;
1744 int len;
1745 {
1746 int i;
1747 for (i = 2; i < 6 && len > i; i++)
1748 {
1749 if (name[len - i] == '.')
1750 {
1751 name[len - i] = '\0';
1752 break;
1753 }
1754 }
1755 }
1756
1757 /* Output a quoted string. */
1758
1759 void
1760 output_quoted_string (asm_file, string)
1761 FILE *asm_file;
1762 const char *string;
1763 {
1764 #ifdef OUTPUT_QUOTED_STRING
1765 OUTPUT_QUOTED_STRING (asm_file, string);
1766 #else
1767 char c;
1768
1769 putc ('\"', asm_file);
1770 while ((c = *string++) != 0)
1771 {
1772 if (c == '\"' || c == '\\')
1773 putc ('\\', asm_file);
1774 putc (c, asm_file);
1775 }
1776 putc ('\"', asm_file);
1777 #endif
1778 }
1779
1780 /* Output a file name in the form wanted by System V. */
1781
1782 void
1783 output_file_directive (asm_file, input_name)
1784 FILE *asm_file;
1785 const char *input_name;
1786 {
1787 int len = strlen (input_name);
1788 const char *na = input_name + len;
1789
1790 /* NA gets INPUT_NAME sans directory names. */
1791 while (na > input_name)
1792 {
1793 if (IS_DIR_SEPARATOR (na[-1]))
1794 break;
1795 na--;
1796 }
1797
1798 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
1799 ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
1800 #else
1801 #ifdef ASM_OUTPUT_SOURCE_FILENAME
1802 ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
1803 #else
1804 fprintf (asm_file, "\t.file\t");
1805 output_quoted_string (asm_file, na);
1806 fputc ('\n', asm_file);
1807 #endif
1808 #endif
1809 }
1810 \f
1811 /* Routine to open a dump file. Return true if the dump file is enabled. */
1812
1813 static int
1814 open_dump_file (index, decl)
1815 enum dump_file_index index;
1816 tree decl;
1817 {
1818 char *dump_name;
1819 const char *open_arg;
1820 char seq[16];
1821
1822 if (! dump_file[index].enabled)
1823 return 0;
1824
1825 timevar_push (TV_DUMP);
1826 if (rtl_dump_file != NULL)
1827 fclose (rtl_dump_file);
1828
1829 sprintf (seq, DUMPFILE_FORMAT, index);
1830
1831 if (! dump_file[index].initialized)
1832 {
1833 /* If we've not initialized the files, do so now. */
1834 if (graph_dump_format != no_graph
1835 && dump_file[index].graph_dump_p)
1836 {
1837 dump_name = concat (seq, dump_file[index].extension, NULL);
1838 clean_graph_dump_file (dump_base_name, dump_name);
1839 free (dump_name);
1840 }
1841 dump_file[index].initialized = 1;
1842 open_arg = "w";
1843 }
1844 else
1845 open_arg = "a";
1846
1847 dump_name = concat (dump_base_name, seq,
1848 dump_file[index].extension, NULL);
1849
1850 rtl_dump_file = fopen (dump_name, open_arg);
1851 if (rtl_dump_file == NULL)
1852 fatal_io_error ("can't open %s", dump_name);
1853
1854 free (dump_name);
1855
1856 if (decl)
1857 fprintf (rtl_dump_file, "\n;; Function %s\n\n",
1858 decl_printable_name (decl, 2));
1859
1860 timevar_pop (TV_DUMP);
1861 return 1;
1862 }
1863
1864 /* Routine to close a dump file. */
1865
1866 static void
1867 close_dump_file (index, func, insns)
1868 enum dump_file_index index;
1869 void (*func) PARAMS ((FILE *, rtx));
1870 rtx insns;
1871 {
1872 if (! rtl_dump_file)
1873 return;
1874
1875 timevar_push (TV_DUMP);
1876 if (insns
1877 && graph_dump_format != no_graph
1878 && dump_file[index].graph_dump_p)
1879 {
1880 char seq[16];
1881 char *suffix;
1882
1883 sprintf (seq, DUMPFILE_FORMAT, index);
1884 suffix = concat (seq, dump_file[index].extension, NULL);
1885 print_rtl_graph_with_bb (dump_base_name, suffix, insns);
1886 free (suffix);
1887 }
1888
1889 if (func && insns)
1890 func (rtl_dump_file, insns);
1891
1892 fflush (rtl_dump_file);
1893 fclose (rtl_dump_file);
1894
1895 rtl_dump_file = NULL;
1896 timevar_pop (TV_DUMP);
1897 }
1898
1899 /* Do any final processing required for the declarations in VEC, of
1900 which there are LEN. We write out inline functions and variables
1901 that have been deferred until this point, but which are required.
1902 Returns non-zero if anything was put out. */
1903
1904 int
1905 wrapup_global_declarations (vec, len)
1906 tree *vec;
1907 int len;
1908 {
1909 tree decl;
1910 int i;
1911 int reconsider;
1912 int output_something = 0;
1913
1914 for (i = 0; i < len; i++)
1915 {
1916 decl = vec[i];
1917
1918 /* We're not deferring this any longer. */
1919 DECL_DEFER_OUTPUT (decl) = 0;
1920
1921 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0
1922 && incomplete_decl_finalize_hook != 0)
1923 (*incomplete_decl_finalize_hook) (decl);
1924 }
1925
1926 /* Now emit any global variables or functions that we have been
1927 putting off. We need to loop in case one of the things emitted
1928 here references another one which comes earlier in the list. */
1929 do
1930 {
1931 reconsider = 0;
1932 for (i = 0; i < len; i++)
1933 {
1934 decl = vec[i];
1935
1936 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
1937 continue;
1938
1939 /* Don't write out static consts, unless we still need them.
1940
1941 We also keep static consts if not optimizing (for debugging),
1942 unless the user specified -fno-keep-static-consts.
1943 ??? They might be better written into the debug information.
1944 This is possible when using DWARF.
1945
1946 A language processor that wants static constants to be always
1947 written out (even if it is not used) is responsible for
1948 calling rest_of_decl_compilation itself. E.g. the C front-end
1949 calls rest_of_decl_compilation from finish_decl.
1950 One motivation for this is that is conventional in some
1951 environments to write things like:
1952 static const char rcsid[] = "... version string ...";
1953 intending to force the string to be in the executable.
1954
1955 A language processor that would prefer to have unneeded
1956 static constants "optimized away" would just defer writing
1957 them out until here. E.g. C++ does this, because static
1958 constants are often defined in header files.
1959
1960 ??? A tempting alternative (for both C and C++) would be
1961 to force a constant to be written if and only if it is
1962 defined in a main file, as opposed to an include file. */
1963
1964 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
1965 && (((! TREE_READONLY (decl) || TREE_PUBLIC (decl))
1966 && !DECL_COMDAT (decl))
1967 || (!optimize
1968 && flag_keep_static_consts
1969 && !DECL_ARTIFICIAL (decl))
1970 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1971 {
1972 reconsider = 1;
1973 rest_of_decl_compilation (decl, NULL, 1, 1);
1974 }
1975
1976 if (TREE_CODE (decl) == FUNCTION_DECL
1977 && DECL_INITIAL (decl) != 0
1978 && DECL_SAVED_INSNS (decl) != 0
1979 && (flag_keep_inline_functions
1980 || (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
1981 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1982 {
1983 reconsider = 1;
1984 output_inline_function (decl);
1985 }
1986 }
1987
1988 if (reconsider)
1989 output_something = 1;
1990 }
1991 while (reconsider);
1992
1993 return output_something;
1994 }
1995
1996 /* Issue appropriate warnings for the global declarations in VEC (of
1997 which there are LEN). Output debugging information for them. */
1998
1999 void
2000 check_global_declarations (vec, len)
2001 tree *vec;
2002 int len;
2003 {
2004 tree decl;
2005 int i;
2006
2007 for (i = 0; i < len; i++)
2008 {
2009 decl = vec[i];
2010
2011 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
2012 && ! TREE_ASM_WRITTEN (decl))
2013 /* Cancel the RTL for this decl so that, if debugging info
2014 output for global variables is still to come,
2015 this one will be omitted. */
2016 SET_DECL_RTL (decl, NULL_RTX);
2017
2018 /* Warn about any function
2019 declared static but not defined.
2020 We don't warn about variables,
2021 because many programs have static variables
2022 that exist only to get some text into the object file. */
2023 if (TREE_CODE (decl) == FUNCTION_DECL
2024 && (warn_unused_function
2025 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2026 && DECL_INITIAL (decl) == 0
2027 && DECL_EXTERNAL (decl)
2028 && ! DECL_ARTIFICIAL (decl)
2029 && ! TREE_PUBLIC (decl))
2030 {
2031 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2032 pedwarn_with_decl (decl,
2033 "`%s' used but never defined");
2034 else
2035 warning_with_decl (decl,
2036 "`%s' declared `static' but never defined");
2037 /* This symbol is effectively an "extern" declaration now. */
2038 TREE_PUBLIC (decl) = 1;
2039 assemble_external (decl);
2040 }
2041
2042 /* Warn about static fns or vars defined but not used,
2043 but not about inline functions or static consts
2044 since defining those in header files is normal practice. */
2045 if (((warn_unused_function
2046 && TREE_CODE (decl) == FUNCTION_DECL && ! DECL_INLINE (decl))
2047 || (warn_unused_variable
2048 && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
2049 && ! DECL_IN_SYSTEM_HEADER (decl)
2050 && ! DECL_EXTERNAL (decl)
2051 && ! TREE_PUBLIC (decl)
2052 && ! TREE_USED (decl)
2053 && (TREE_CODE (decl) == FUNCTION_DECL || ! DECL_REGISTER (decl))
2054 /* The TREE_USED bit for file-scope decls
2055 is kept in the identifier, to handle multiple
2056 external decls in different scopes. */
2057 && ! TREE_USED (DECL_NAME (decl)))
2058 warning_with_decl (decl, "`%s' defined but not used");
2059
2060 timevar_push (TV_SYMOUT);
2061 (*debug_hooks->global_decl) (decl);
2062 timevar_pop (TV_SYMOUT);
2063 }
2064 }
2065
2066 /* Save the current INPUT_FILENAME and LINENO on the top entry in the
2067 INPUT_FILE_STACK. Push a new entry for FILE and LINE, and set the
2068 INPUT_FILENAME and LINENO accordingly. */
2069
2070 void
2071 push_srcloc (file, line)
2072 const char *file;
2073 int line;
2074 {
2075 struct file_stack *fs;
2076
2077 if (input_file_stack)
2078 {
2079 input_file_stack->name = input_filename;
2080 input_file_stack->line = lineno;
2081 }
2082
2083 fs = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2084 fs->name = input_filename = file;
2085 fs->line = lineno = line;
2086 fs->indent_level = 0;
2087 fs->next = input_file_stack;
2088 input_file_stack = fs;
2089 input_file_stack_tick++;
2090 }
2091
2092 /* Pop the top entry off the stack of presently open source files.
2093 Restore the INPUT_FILENAME and LINENO from the new topmost entry on
2094 the stack. */
2095
2096 void
2097 pop_srcloc ()
2098 {
2099 struct file_stack *fs;
2100
2101 fs = input_file_stack;
2102 input_file_stack = fs->next;
2103 free (fs);
2104 input_file_stack_tick++;
2105 /* The initial source file is never popped. */
2106 if (!input_file_stack)
2107 abort ();
2108 input_filename = input_file_stack->name;
2109 lineno = input_file_stack->line;
2110 }
2111
2112 /* Compile an entire translation unit. Write a file of assembly
2113 output and various debugging dumps. */
2114
2115 static void
2116 compile_file ()
2117 {
2118 tree globals;
2119
2120 /* Initialize yet another pass. */
2121
2122 init_final (main_input_filename);
2123 init_branch_prob (dump_base_name);
2124
2125 timevar_push (TV_PARSE);
2126
2127 /* Call the parser, which parses the entire file
2128 (calling rest_of_compilation for each function). */
2129 yyparse ();
2130
2131 /* In case there were missing block closers,
2132 get us back to the global binding level. */
2133 (*lang_hooks.clear_binding_stack) ();
2134
2135 /* Compilation is now finished except for writing
2136 what's left of the symbol table output. */
2137
2138 timevar_pop (TV_PARSE);
2139
2140 if (flag_syntax_only)
2141 return;
2142
2143 globals = getdecls ();
2144
2145 /* Really define vars that have had only a tentative definition.
2146 Really output inline functions that must actually be callable
2147 and have not been output so far. */
2148
2149 {
2150 int len = list_length (globals);
2151 tree *vec = (tree *) xmalloc (sizeof (tree) * len);
2152 int i;
2153 tree decl;
2154
2155 /* Process the decls in reverse order--earliest first.
2156 Put them into VEC from back to front, then take out from front. */
2157
2158 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
2159 vec[len - i - 1] = decl;
2160
2161 wrapup_global_declarations (vec, len);
2162
2163 /* This must occur after the loop to output deferred functions. Else
2164 the profiler initializer would not be emitted if all the functions
2165 in this compilation unit were deferred.
2166
2167 output_func_start_profiler can not cause any additional functions or
2168 data to need to be output, so it need not be in the deferred function
2169 loop above. */
2170 output_func_start_profiler ();
2171
2172 check_global_declarations (vec, len);
2173
2174 /* Clean up. */
2175 free (vec);
2176 }
2177
2178 /* Write out any pending weak symbol declarations. */
2179
2180 weak_finish ();
2181
2182 /* Do dbx symbols. */
2183 timevar_push (TV_SYMOUT);
2184
2185 #ifdef DWARF2_UNWIND_INFO
2186 if (dwarf2out_do_frame ())
2187 dwarf2out_frame_finish ();
2188 #endif
2189
2190 (*debug_hooks->finish) (main_input_filename);
2191 timevar_pop (TV_SYMOUT);
2192
2193 /* Output some stuff at end of file if nec. */
2194
2195 dw2_output_indirect_constants ();
2196
2197 end_final (dump_base_name);
2198
2199 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
2200 {
2201 timevar_push (TV_DUMP);
2202 open_dump_file (DFI_bp, NULL);
2203
2204 end_branch_prob ();
2205
2206 close_dump_file (DFI_bp, NULL, NULL_RTX);
2207 timevar_pop (TV_DUMP);
2208 }
2209
2210 #ifdef ASM_FILE_END
2211 ASM_FILE_END (asm_out_file);
2212 #endif
2213
2214 /* Attach a special .ident directive to the end of the file to identify
2215 the version of GCC which compiled this code. The format of the .ident
2216 string is patterned after the ones produced by native SVR4 compilers. */
2217 #ifdef IDENT_ASM_OP
2218 if (!flag_no_ident)
2219 fprintf (asm_out_file, "%s\"GCC: (GNU) %s\"\n",
2220 IDENT_ASM_OP, version_string);
2221 #endif
2222
2223 if (optimize > 0 && open_dump_file (DFI_combine, NULL))
2224 {
2225 timevar_push (TV_DUMP);
2226 dump_combine_total_stats (rtl_dump_file);
2227 close_dump_file (DFI_combine, NULL, NULL_RTX);
2228 timevar_pop (TV_DUMP);
2229 }
2230 }
2231 \f
2232 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
2233 and TYPE_DECL nodes.
2234
2235 This does nothing for local (non-static) variables, unless the
2236 variable is a register variable with an ASMSPEC. In that case, or
2237 if the variable is not an automatic, it sets up the RTL and
2238 outputs any assembler code (label definition, storage allocation
2239 and initialization).
2240
2241 DECL is the declaration. If ASMSPEC is nonzero, it specifies
2242 the assembler symbol name to be used. TOP_LEVEL is nonzero
2243 if this declaration is not within a function. */
2244
2245 void
2246 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
2247 tree decl;
2248 const char *asmspec;
2249 int top_level;
2250 int at_end;
2251 {
2252 /* Declarations of variables, and of functions defined elsewhere. */
2253
2254 /* The most obvious approach, to put an #ifndef around where
2255 this macro is used, doesn't work since it's inside a macro call. */
2256 #ifndef ASM_FINISH_DECLARE_OBJECT
2257 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP, END)
2258 #endif
2259
2260 /* Forward declarations for nested functions are not "external",
2261 but we need to treat them as if they were. */
2262 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
2263 || TREE_CODE (decl) == FUNCTION_DECL)
2264 {
2265 timevar_push (TV_VARCONST);
2266 if (asmspec)
2267 make_decl_rtl (decl, asmspec);
2268 /* Don't output anything
2269 when a tentative file-scope definition is seen.
2270 But at end of compilation, do output code for them. */
2271 if (at_end || !DECL_DEFER_OUTPUT (decl))
2272 assemble_variable (decl, top_level, at_end, 0);
2273 if (decl == last_assemble_variable_decl)
2274 {
2275 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
2276 top_level, at_end);
2277 }
2278 timevar_pop (TV_VARCONST);
2279 }
2280 else if (DECL_REGISTER (decl) && asmspec != 0)
2281 {
2282 if (decode_reg_name (asmspec) >= 0)
2283 {
2284 SET_DECL_RTL (decl, NULL_RTX);
2285 make_decl_rtl (decl, asmspec);
2286 }
2287 else
2288 {
2289 error ("invalid register name `%s' for register variable", asmspec);
2290 DECL_REGISTER (decl) = 0;
2291 if (!top_level)
2292 expand_decl (decl);
2293 }
2294 }
2295 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2296 else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2297 && TREE_CODE (decl) == TYPE_DECL)
2298 {
2299 timevar_push (TV_SYMOUT);
2300 dbxout_symbol (decl, 0);
2301 timevar_pop (TV_SYMOUT);
2302 }
2303 #endif
2304 #ifdef SDB_DEBUGGING_INFO
2305 else if (write_symbols == SDB_DEBUG && top_level
2306 && TREE_CODE (decl) == TYPE_DECL)
2307 {
2308 timevar_push (TV_SYMOUT);
2309 sdbout_symbol (decl, 0);
2310 timevar_pop (TV_SYMOUT);
2311 }
2312 #endif
2313 }
2314
2315 /* Called after finishing a record, union or enumeral type. */
2316
2317 void
2318 rest_of_type_compilation (type, toplev)
2319 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO) || defined (SDB_DEBUGGING_INFO)
2320 tree type;
2321 int toplev;
2322 #else
2323 tree type ATTRIBUTE_UNUSED;
2324 int toplev ATTRIBUTE_UNUSED;
2325 #endif
2326 {
2327 timevar_push (TV_SYMOUT);
2328 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2329 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2330 dbxout_symbol (TYPE_STUB_DECL (type), !toplev);
2331 #endif
2332 #ifdef SDB_DEBUGGING_INFO
2333 if (write_symbols == SDB_DEBUG)
2334 sdbout_symbol (TYPE_STUB_DECL (type), !toplev);
2335 #endif
2336 #ifdef DWARF2_DEBUGGING_INFO
2337 if (write_symbols == DWARF2_DEBUG && toplev)
2338 dwarf2out_decl (TYPE_STUB_DECL (type));
2339 #endif
2340 timevar_pop (TV_SYMOUT);
2341 }
2342
2343 /* This is called from finish_function (within yyparse)
2344 after each top-level definition is parsed.
2345 It is supposed to compile that function or variable
2346 and output the assembler code for it.
2347 After we return, the tree storage is freed. */
2348
2349 void
2350 rest_of_compilation (decl)
2351 tree decl;
2352 {
2353 rtx insns;
2354 int tem;
2355 int failure = 0;
2356 int rebuild_label_notes_after_reload;
2357 int register_life_up_to_date;
2358
2359 timevar_push (TV_REST_OF_COMPILATION);
2360
2361 /* Now that we're out of the frontend, we shouldn't have any more
2362 CONCATs anywhere. */
2363 generating_concat_p = 0;
2364
2365 /* When processing delayed functions, prepare_function_start() won't
2366 have been run to re-initialize it. */
2367 cse_not_expected = ! optimize;
2368
2369 /* First, make sure that NOTE_BLOCK is set correctly for each
2370 NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note. */
2371 if (!cfun->x_whole_function_mode_p)
2372 identify_blocks ();
2373
2374 /* Then remove any notes we don't need. That will make iterating
2375 over the instruction sequence faster, and allow the garbage
2376 collector to reclaim the memory used by the notes. */
2377 remove_unnecessary_notes ();
2378
2379 /* In function-at-a-time mode, we do not attempt to keep the BLOCK
2380 tree in sensible shape. So, we just recalculate it here. */
2381 if (cfun->x_whole_function_mode_p)
2382 reorder_blocks ();
2383
2384 init_flow ();
2385
2386 /* If we are reconsidering an inline function
2387 at the end of compilation, skip the stuff for making it inline. */
2388
2389 if (DECL_SAVED_INSNS (decl) == 0)
2390 {
2391 int inlinable = 0;
2392 tree parent;
2393 const char *lose;
2394
2395 /* If this is nested inside an inlined external function, pretend
2396 it was only declared. Since we cannot inline such functions,
2397 generating code for this one is not only not necessary but will
2398 confuse some debugging output writers. */
2399 for (parent = DECL_CONTEXT (current_function_decl);
2400 parent != NULL_TREE;
2401 parent = get_containing_scope (parent))
2402 if (TREE_CODE (parent) == FUNCTION_DECL
2403 && DECL_INLINE (parent) && DECL_EXTERNAL (parent))
2404 {
2405 DECL_INITIAL (decl) = 0;
2406 goto exit_rest_of_compilation;
2407 }
2408
2409 /* If requested, consider whether to make this function inline. */
2410 if ((DECL_INLINE (decl) && !flag_no_inline)
2411 || flag_inline_functions)
2412 {
2413 timevar_push (TV_INTEGRATION);
2414 lose = function_cannot_inline_p (decl);
2415 timevar_pop (TV_INTEGRATION);
2416 if (lose || ! optimize)
2417 {
2418 if (warn_inline && DECL_INLINE (decl))
2419 warning_with_decl (decl, lose);
2420 DECL_ABSTRACT_ORIGIN (decl) = 0;
2421 /* Don't really compile an extern inline function.
2422 If we can't make it inline, pretend
2423 it was only declared. */
2424 if (DECL_EXTERNAL (decl))
2425 {
2426 DECL_INITIAL (decl) = 0;
2427 goto exit_rest_of_compilation;
2428 }
2429 }
2430 else
2431 /* ??? Note that this has the effect of making it look
2432 like "inline" was specified for a function if we choose
2433 to inline it. This isn't quite right, but it's
2434 probably not worth the trouble to fix. */
2435 inlinable = DECL_INLINE (decl) = 1;
2436 }
2437
2438 insns = get_insns ();
2439
2440 /* Dump the rtl code if we are dumping rtl. */
2441
2442 if (open_dump_file (DFI_rtl, decl))
2443 {
2444 if (DECL_SAVED_INSNS (decl))
2445 fprintf (rtl_dump_file, ";; (integrable)\n\n");
2446 close_dump_file (DFI_rtl, print_rtl, insns);
2447 }
2448
2449 /* Convert from NOTE_INSN_EH_REGION style notes, and do other
2450 sorts of eh initialization. Delay this until after the
2451 initial rtl dump so that we can see the original nesting. */
2452 convert_from_eh_region_ranges ();
2453
2454 /* If function is inline, and we don't yet know whether to
2455 compile it by itself, defer decision till end of compilation.
2456 finish_compilation will call rest_of_compilation again
2457 for those functions that need to be output. Also defer those
2458 functions that we are supposed to defer. */
2459
2460 if (inlinable
2461 || (DECL_INLINE (decl)
2462 && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
2463 && ! flag_keep_inline_functions)
2464 || DECL_EXTERNAL (decl))))
2465 DECL_DEFER_OUTPUT (decl) = 1;
2466
2467 if (DECL_INLINE (decl))
2468 /* DWARF wants separate debugging info for abstract and
2469 concrete instances of all inline functions, including those
2470 declared inline but not inlined, and those inlined even
2471 though they weren't declared inline. Conveniently, that's
2472 what DECL_INLINE means at this point. */
2473 (*debug_hooks->deferred_inline_function) (decl);
2474
2475 if (DECL_DEFER_OUTPUT (decl))
2476 {
2477 /* If -Wreturn-type, we have to do a bit of compilation. We just
2478 want to call cleanup the cfg to figure out whether or not we can
2479 fall off the end of the function; we do the minimum amount of
2480 work necessary to make that safe. */
2481 if (warn_return_type)
2482 {
2483 int saved_optimize = optimize;
2484
2485 optimize = 0;
2486 rebuild_jump_labels (insns);
2487 find_exception_handler_labels ();
2488 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2489 cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
2490 optimize = saved_optimize;
2491
2492 /* CFG is no longer maintained up-to-date. */
2493 free_bb_for_insn ();
2494 }
2495
2496 current_function_nothrow = nothrow_function_p ();
2497 if (current_function_nothrow)
2498 /* Now we know that this can't throw; set the flag for the benefit
2499 of other functions later in this translation unit. */
2500 TREE_NOTHROW (current_function_decl) = 1;
2501
2502 timevar_push (TV_INTEGRATION);
2503 save_for_inline (decl);
2504 timevar_pop (TV_INTEGRATION);
2505 DECL_SAVED_INSNS (decl)->inlinable = inlinable;
2506 goto exit_rest_of_compilation;
2507 }
2508
2509 /* If specified extern inline but we aren't inlining it, we are
2510 done. This goes for anything that gets here with DECL_EXTERNAL
2511 set, not just things with DECL_INLINE. */
2512 if (DECL_EXTERNAL (decl))
2513 goto exit_rest_of_compilation;
2514 }
2515
2516 ggc_collect ();
2517
2518 /* Initialize some variables used by the optimizers. */
2519 init_function_for_compilation ();
2520
2521 if (! DECL_DEFER_OUTPUT (decl))
2522 TREE_ASM_WRITTEN (decl) = 1;
2523
2524 /* Now that integrate will no longer see our rtl, we need not
2525 distinguish between the return value of this function and the
2526 return value of called functions. Also, we can remove all SETs
2527 of subregs of hard registers; they are only here because of
2528 integrate. Also, we can now initialize pseudos intended to
2529 carry magic hard reg data throughout the function. */
2530 rtx_equal_function_value_matters = 0;
2531 purge_hard_subreg_sets (get_insns ());
2532 emit_initial_value_sets ();
2533
2534 /* Don't return yet if -Wreturn-type; we need to do cleanup_cfg. */
2535 if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
2536 goto exit_rest_of_compilation;
2537
2538 /* We may have potential sibling or tail recursion sites. Select one
2539 (of possibly multiple) methods of performing the call. */
2540 if (flag_optimize_sibling_calls)
2541 {
2542 timevar_push (TV_JUMP);
2543 open_dump_file (DFI_sibling, decl);
2544
2545 optimize_sibling_and_tail_recursive_calls ();
2546
2547 close_dump_file (DFI_sibling, print_rtl, get_insns ());
2548 timevar_pop (TV_JUMP);
2549 }
2550
2551 /* Complete generation of exception handling code. */
2552 find_exception_handler_labels ();
2553 if (doing_eh (0))
2554 {
2555 timevar_push (TV_JUMP);
2556 open_dump_file (DFI_eh, decl);
2557
2558 finish_eh_generation ();
2559
2560 close_dump_file (DFI_eh, print_rtl, get_insns ());
2561 timevar_pop (TV_JUMP);
2562 }
2563
2564 #ifdef FINALIZE_PIC
2565 /* If we are doing position-independent code generation, now
2566 is the time to output special prologues and epilogues.
2567 We do not want to do this earlier, because it just clutters
2568 up inline functions with meaningless insns. */
2569 if (flag_pic)
2570 FINALIZE_PIC;
2571 #endif
2572
2573 insns = get_insns ();
2574
2575 /* Copy any shared structure that should not be shared. */
2576 unshare_all_rtl (current_function_decl, insns);
2577
2578 #ifdef SETJMP_VIA_SAVE_AREA
2579 /* This must be performed before virtual register instantiation. */
2580 if (current_function_calls_alloca)
2581 optimize_save_area_alloca (insns);
2582 #endif
2583
2584 /* Instantiate all virtual registers. */
2585 instantiate_virtual_regs (current_function_decl, insns);
2586
2587 open_dump_file (DFI_jump, decl);
2588
2589 /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
2590 are initialized and to compute whether control can drop off the end
2591 of the function. */
2592
2593 timevar_push (TV_JUMP);
2594 /* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this
2595 before jump optimization switches branch directions. */
2596 expected_value_to_br_prob ();
2597
2598 reg_scan (insns, max_reg_num (), 0);
2599 rebuild_jump_labels (insns);
2600 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2601 cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP);
2602
2603 /* CFG is no longer maintained up-to-date. */
2604 free_bb_for_insn ();
2605 copy_loop_headers (insns);
2606 purge_line_number_notes (insns);
2607
2608 timevar_pop (TV_JUMP);
2609
2610 /* Now is when we stop if -fsyntax-only and -Wreturn-type. */
2611 if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
2612 {
2613 close_dump_file (DFI_jump, print_rtl, insns);
2614 goto exit_rest_of_compilation;
2615 }
2616
2617 /* Long term, this should probably move before the jump optimizer too,
2618 but I didn't want to disturb the rtl_dump_and_exit and related
2619 stuff at this time. */
2620 if (optimize > 0 && flag_ssa)
2621 {
2622 /* Convert to SSA form. */
2623
2624 timevar_push (TV_TO_SSA);
2625 open_dump_file (DFI_ssa, decl);
2626
2627 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2628 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2629 convert_to_ssa ();
2630
2631 close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
2632 timevar_pop (TV_TO_SSA);
2633
2634 /* Perform sparse conditional constant propagation, if requested. */
2635 if (flag_ssa_ccp)
2636 {
2637 timevar_push (TV_SSA_CCP);
2638 open_dump_file (DFI_ssa_ccp, decl);
2639
2640 ssa_const_prop ();
2641
2642 close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
2643 timevar_pop (TV_SSA_CCP);
2644 }
2645
2646 /* It would be useful to cleanup the CFG at this point, but block
2647 merging and possibly other transformations might leave a PHI
2648 node in the middle of a basic block, which is a strict no-no. */
2649
2650 /* The SSA implementation uses basic block numbers in its phi
2651 nodes. Thus, changing the control-flow graph or the basic
2652 blocks, e.g., calling find_basic_blocks () or cleanup_cfg (),
2653 may cause problems. */
2654
2655 if (flag_ssa_dce)
2656 {
2657 /* Remove dead code. */
2658
2659 timevar_push (TV_SSA_DCE);
2660 open_dump_file (DFI_ssa_dce, decl);
2661
2662 insns = get_insns ();
2663 ssa_eliminate_dead_code();
2664
2665 close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
2666 timevar_pop (TV_SSA_DCE);
2667 }
2668
2669 /* Convert from SSA form. */
2670
2671 timevar_push (TV_FROM_SSA);
2672 open_dump_file (DFI_ussa, decl);
2673
2674 convert_from_ssa ();
2675 /* New registers have been created. Rescan their usage. */
2676 reg_scan (insns, max_reg_num (), 1);
2677
2678 close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
2679 timevar_pop (TV_FROM_SSA);
2680
2681 ggc_collect ();
2682 /* CFG is no longer maintained up-to-date. */
2683 free_bb_for_insn ();
2684 }
2685
2686 timevar_push (TV_JUMP);
2687
2688 if (optimize > 0)
2689 {
2690 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2691 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2692
2693 /* ??? Run if-conversion before delete_null_pointer_checks,
2694 since the later does not preserve the CFG. This should
2695 be changed -- no since converting if's that are going to
2696 be deleted. */
2697 timevar_push (TV_IFCVT);
2698 if_convert (0);
2699 timevar_pop (TV_IFCVT);
2700
2701 /* CFG is no longer maintained up-to-date. */
2702 free_bb_for_insn ();
2703 /* Try to identify useless null pointer tests and delete them. */
2704 if (flag_delete_null_pointer_checks)
2705 delete_null_pointer_checks (insns);
2706 }
2707
2708 /* Jump optimization, and the removal of NULL pointer checks, may
2709 have reduced the number of instructions substantially. CSE, and
2710 future passes, allocate arrays whose dimensions involve the
2711 maximum instruction UID, so if we can reduce the maximum UID
2712 we'll save big on memory. */
2713 renumber_insns (rtl_dump_file);
2714 timevar_pop (TV_JUMP);
2715
2716 close_dump_file (DFI_jump, print_rtl, insns);
2717
2718 ggc_collect ();
2719
2720 /* Perform common subexpression elimination.
2721 Nonzero value from `cse_main' means that jumps were simplified
2722 and some code may now be unreachable, so do
2723 jump optimization again. */
2724
2725 if (optimize > 0)
2726 {
2727 open_dump_file (DFI_cse, decl);
2728 timevar_push (TV_CSE);
2729
2730 reg_scan (insns, max_reg_num (), 1);
2731
2732 if (flag_thread_jumps)
2733 {
2734 timevar_push (TV_JUMP);
2735 thread_jumps (insns, max_reg_num (), 1);
2736 timevar_pop (TV_JUMP);
2737 }
2738
2739 tem = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2740
2741 /* If we are not running more CSE passes, then we are no longer
2742 expecting CSE to be run. But always rerun it in a cheap mode. */
2743 cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse;
2744
2745 if (tem || optimize > 1)
2746 {
2747 timevar_push (TV_JUMP);
2748 rebuild_jump_labels (insns);
2749 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2750 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2751 timevar_pop (TV_JUMP);
2752 /* CFG is no longer maintained up-to-date. */
2753 free_bb_for_insn ();
2754 }
2755
2756 /* Run this after jump optmizations remove all the unreachable code
2757 so that unreachable code will not keep values live. */
2758 delete_trivially_dead_insns (insns, max_reg_num (), 0);
2759
2760 /* Try to identify useless null pointer tests and delete them. */
2761 if (flag_delete_null_pointer_checks)
2762 {
2763 timevar_push (TV_JUMP);
2764 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2765
2766 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2767
2768 delete_null_pointer_checks (insns);
2769 /* CFG is no longer maintained up-to-date. */
2770 free_bb_for_insn ();
2771 timevar_pop (TV_JUMP);
2772 }
2773
2774 /* The second pass of jump optimization is likely to have
2775 removed a bunch more instructions. */
2776 renumber_insns (rtl_dump_file);
2777
2778 timevar_pop (TV_CSE);
2779 close_dump_file (DFI_cse, print_rtl, insns);
2780 }
2781
2782 open_dump_file (DFI_addressof, decl);
2783
2784 purge_addressof (insns);
2785 reg_scan (insns, max_reg_num (), 1);
2786
2787 close_dump_file (DFI_addressof, print_rtl, insns);
2788
2789 ggc_collect ();
2790
2791 /* Perform global cse. */
2792
2793 if (optimize > 0 && flag_gcse)
2794 {
2795 int save_csb, save_cfj;
2796 int tem2 = 0;
2797
2798 timevar_push (TV_GCSE);
2799 open_dump_file (DFI_gcse, decl);
2800
2801 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2802 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2803 tem = gcse_main (insns, rtl_dump_file);
2804
2805 save_csb = flag_cse_skip_blocks;
2806 save_cfj = flag_cse_follow_jumps;
2807 flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
2808
2809 /* CFG is no longer maintained up-to-date. */
2810 free_bb_for_insn ();
2811 /* If -fexpensive-optimizations, re-run CSE to clean up things done
2812 by gcse. */
2813 if (flag_expensive_optimizations)
2814 {
2815 timevar_push (TV_CSE);
2816 reg_scan (insns, max_reg_num (), 1);
2817 tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2818 timevar_pop (TV_CSE);
2819 cse_not_expected = !flag_rerun_cse_after_loop;
2820 }
2821
2822 /* If gcse or cse altered any jumps, rerun jump optimizations to clean
2823 things up. Then possibly re-run CSE again. */
2824 while (tem || tem2)
2825 {
2826 tem = tem2 = 0;
2827 timevar_push (TV_JUMP);
2828 rebuild_jump_labels (insns);
2829 delete_trivially_dead_insns (insns, max_reg_num (), 0);
2830 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2831 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
2832 /* CFG is no longer maintained up-to-date. */
2833 free_bb_for_insn ();
2834 timevar_pop (TV_JUMP);
2835
2836 if (flag_expensive_optimizations)
2837 {
2838 timevar_push (TV_CSE);
2839 reg_scan (insns, max_reg_num (), 1);
2840 tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
2841 timevar_pop (TV_CSE);
2842 }
2843 }
2844
2845 close_dump_file (DFI_gcse, print_rtl, insns);
2846 timevar_pop (TV_GCSE);
2847
2848 ggc_collect ();
2849 flag_cse_skip_blocks = save_csb;
2850 flag_cse_follow_jumps = save_cfj;
2851 }
2852
2853 /* Move constant computations out of loops. */
2854
2855 if (optimize > 0)
2856 {
2857 timevar_push (TV_LOOP);
2858 open_dump_file (DFI_loop, decl);
2859 free_bb_for_insn ();
2860
2861 if (flag_rerun_loop_opt)
2862 {
2863 cleanup_barriers ();
2864
2865 /* We only want to perform unrolling once. */
2866
2867 loop_optimize (insns, rtl_dump_file, 0);
2868
2869 /* The first call to loop_optimize makes some instructions
2870 trivially dead. We delete those instructions now in the
2871 hope that doing so will make the heuristics in loop work
2872 better and possibly speed up compilation. */
2873 delete_trivially_dead_insns (insns, max_reg_num (), 0);
2874
2875 /* The regscan pass is currently necessary as the alias
2876 analysis code depends on this information. */
2877 reg_scan (insns, max_reg_num (), 1);
2878 }
2879 cleanup_barriers ();
2880 loop_optimize (insns, rtl_dump_file,
2881 (flag_unroll_loops ? LOOP_UNROLL : 0) | LOOP_BCT);
2882
2883 close_dump_file (DFI_loop, print_rtl, insns);
2884 timevar_pop (TV_LOOP);
2885
2886 ggc_collect ();
2887 }
2888
2889 if (optimize > 0)
2890 {
2891 timevar_push (TV_CSE2);
2892 open_dump_file (DFI_cse2, decl);
2893
2894 if (flag_rerun_cse_after_loop)
2895 {
2896 /* Running another jump optimization pass before the second
2897 cse pass sometimes simplifies the RTL enough to allow
2898 the second CSE pass to do a better job. Jump_optimize can change
2899 max_reg_num so we must rerun reg_scan afterwards.
2900 ??? Rework to not call reg_scan so often. */
2901 timevar_push (TV_JUMP);
2902
2903 /* The previous call to loop_optimize makes some instructions
2904 trivially dead. We delete those instructions now in the
2905 hope that doing so will make the heuristics in jump work
2906 better and possibly speed up compilation. */
2907 delete_trivially_dead_insns (insns, max_reg_num (), 0);
2908
2909 reg_scan (insns, max_reg_num (), 0);
2910
2911 timevar_push (TV_IFCVT);
2912
2913 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2914 cleanup_cfg (CLEANUP_EXPENSIVE);
2915 if_convert (0);
2916
2917 timevar_pop(TV_IFCVT);
2918
2919 timevar_pop (TV_JUMP);
2920
2921 /* CFG is no longer maintained up-to-date. */
2922 free_bb_for_insn ();
2923 reg_scan (insns, max_reg_num (), 0);
2924 tem = cse_main (insns, max_reg_num (), 1, rtl_dump_file);
2925
2926 if (tem)
2927 {
2928 timevar_push (TV_JUMP);
2929 rebuild_jump_labels (insns);
2930 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2931 cleanup_cfg (CLEANUP_EXPENSIVE);
2932 /* CFG is no longer maintained up-to-date. */
2933 free_bb_for_insn ();
2934 timevar_pop (TV_JUMP);
2935 }
2936 }
2937
2938 if (flag_thread_jumps)
2939 {
2940 /* This pass of jump threading straightens out code
2941 that was kinked by loop optimization. */
2942 timevar_push (TV_JUMP);
2943 reg_scan (insns, max_reg_num (), 0);
2944 thread_jumps (insns, max_reg_num (), 0);
2945 timevar_pop (TV_JUMP);
2946 }
2947
2948 close_dump_file (DFI_cse2, print_rtl, insns);
2949 timevar_pop (TV_CSE2);
2950
2951 ggc_collect ();
2952 }
2953
2954 cse_not_expected = 1;
2955
2956 regclass_init ();
2957
2958 /* Do control and data flow analysis; wrote some of the results to
2959 the dump file. */
2960
2961 timevar_push (TV_FLOW);
2962 open_dump_file (DFI_cfg, decl);
2963
2964 find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
2965 cleanup_cfg (optimize ? CLEANUP_EXPENSIVE : 0);
2966 check_function_return_warnings ();
2967
2968 /* It may make more sense to mark constant functions after dead code is
2969 eliminated by life_analyzis, but we need to do it early, as -fprofile-arcs
2970 may insert code making function non-constant, but we still must consider
2971 it as constant, otherwise -fbranch-probabilities will not read data back.
2972
2973 life_analyzis rarely eliminates modification of external memory.
2974 */
2975 mark_constant_function ();
2976
2977 close_dump_file (DFI_cfg, print_rtl_with_bb, insns);
2978
2979 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
2980 {
2981 timevar_push (TV_BRANCH_PROB);
2982 open_dump_file (DFI_bp, decl);
2983
2984 branch_prob ();
2985
2986 close_dump_file (DFI_bp, print_rtl_with_bb, insns);
2987 timevar_pop (TV_BRANCH_PROB);
2988 }
2989
2990 open_dump_file (DFI_life, decl);
2991 if (optimize)
2992 {
2993 struct loops loops;
2994
2995 /* Discover and record the loop depth at the head of each basic
2996 block. The loop infrastructure does the real job for us. */
2997 flow_loops_find (&loops, LOOP_TREE);
2998
2999 /* Estimate using heuristics if no profiling info is available. */
3000 if (flag_guess_branch_prob)
3001 estimate_probability (&loops);
3002
3003 if (rtl_dump_file)
3004 flow_loops_dump (&loops, rtl_dump_file, NULL, 0);
3005
3006 flow_loops_free (&loops);
3007 }
3008 life_analysis (insns, rtl_dump_file, PROP_FINAL);
3009 timevar_pop (TV_FLOW);
3010
3011 no_new_pseudos = 1;
3012
3013 if (warn_uninitialized || extra_warnings)
3014 {
3015 uninitialized_vars_warning (DECL_INITIAL (decl));
3016 if (extra_warnings)
3017 setjmp_args_warning ();
3018 }
3019
3020 close_dump_file (DFI_life, print_rtl_with_bb, insns);
3021
3022 ggc_collect ();
3023
3024 /* If -opt, try combining insns through substitution. */
3025
3026 if (optimize > 0)
3027 {
3028 int rebuild_jump_labels_after_combine = 0;
3029
3030 timevar_push (TV_COMBINE);
3031 open_dump_file (DFI_combine, decl);
3032
3033 rebuild_jump_labels_after_combine
3034 = combine_instructions (insns, max_reg_num ());
3035
3036 /* Always purge dead edges, as we may eliminate an insn throwing
3037 exception. */
3038 rebuild_jump_labels_after_combine |= purge_all_dead_edges (true);
3039
3040 /* Combining insns may have turned an indirect jump into a
3041 direct jump. Rebuid the JUMP_LABEL fields of jumping
3042 instructions. */
3043 if (rebuild_jump_labels_after_combine)
3044 {
3045 timevar_push (TV_JUMP);
3046 rebuild_jump_labels (insns);
3047 timevar_pop (TV_JUMP);
3048
3049 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
3050 }
3051
3052 close_dump_file (DFI_combine, print_rtl_with_bb, insns);
3053 timevar_pop (TV_COMBINE);
3054
3055 ggc_collect ();
3056 }
3057
3058 /* Rerun if-conversion, as combine may have simplified things enough to
3059 now meet sequence length restrictions. */
3060 if (optimize > 0)
3061 {
3062 timevar_push (TV_IFCVT);
3063 open_dump_file (DFI_ce, decl);
3064
3065 no_new_pseudos = 0;
3066 if_convert (1);
3067 no_new_pseudos = 1;
3068
3069 close_dump_file (DFI_ce, print_rtl_with_bb, insns);
3070 timevar_pop (TV_IFCVT);
3071 }
3072
3073 /* Register allocation pre-pass, to reduce number of moves
3074 necessary for two-address machines. */
3075 if (optimize > 0 && (flag_regmove || flag_expensive_optimizations))
3076 {
3077 timevar_push (TV_REGMOVE);
3078 open_dump_file (DFI_regmove, decl);
3079
3080 regmove_optimize (insns, max_reg_num (), rtl_dump_file);
3081
3082 close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
3083 timevar_pop (TV_REGMOVE);
3084
3085 ggc_collect ();
3086 }
3087
3088 /* Do unconditional splitting before register allocation to allow machine
3089 description to add extra information not needed previously. */
3090 split_all_insns (1);
3091
3092 /* Any of the several passes since flow1 will have munged register
3093 lifetime data a bit. */
3094 register_life_up_to_date = 0;
3095
3096 #ifdef OPTIMIZE_MODE_SWITCHING
3097 timevar_push (TV_MODE_SWITCH);
3098
3099 no_new_pseudos = 0;
3100 if (optimize_mode_switching (NULL))
3101 {
3102 /* We did work, and so had to regenerate global life information.
3103 Take advantage of this and don't re-recompute register life
3104 information below. */
3105 register_life_up_to_date = 1;
3106 }
3107 no_new_pseudos = 1;
3108
3109 timevar_pop (TV_MODE_SWITCH);
3110 #endif
3111
3112 timevar_push (TV_SCHED);
3113
3114 #ifdef INSN_SCHEDULING
3115
3116 /* Print function header into sched dump now
3117 because doing the sched analysis makes some of the dump. */
3118 if (optimize > 0 && flag_schedule_insns)
3119 {
3120 open_dump_file (DFI_sched, decl);
3121
3122 /* Do control and data sched analysis,
3123 and write some of the results to dump file. */
3124
3125 schedule_insns (rtl_dump_file);
3126
3127 close_dump_file (DFI_sched, print_rtl_with_bb, insns);
3128
3129 /* Register lifetime information was updated as part of verifying
3130 the schedule. */
3131 register_life_up_to_date = 1;
3132 }
3133 #endif
3134 timevar_pop (TV_SCHED);
3135
3136 ggc_collect ();
3137
3138 /* Determine if the current function is a leaf before running reload
3139 since this can impact optimizations done by the prologue and
3140 epilogue thus changing register elimination offsets. */
3141 current_function_is_leaf = leaf_function_p ();
3142
3143 timevar_push (TV_LOCAL_ALLOC);
3144 open_dump_file (DFI_lreg, decl);
3145
3146 /* Allocate pseudo-regs that are used only within 1 basic block.
3147
3148 RUN_JUMP_AFTER_RELOAD records whether or not we need to rerun the
3149 jump optimizer after register allocation and reloading are finished. */
3150
3151 if (! register_life_up_to_date)
3152 recompute_reg_usage (insns, ! optimize_size);
3153
3154 /* Allocate the reg_renumber array. */
3155 allocate_reg_info (max_regno, FALSE, TRUE);
3156
3157 /* And the reg_equiv_memory_loc array. */
3158 reg_equiv_memory_loc = (rtx *) xcalloc (max_regno, sizeof (rtx));
3159
3160 allocate_initial_values (reg_equiv_memory_loc);
3161
3162 regclass (insns, max_reg_num (), rtl_dump_file);
3163 rebuild_label_notes_after_reload = local_alloc ();
3164
3165 timevar_pop (TV_LOCAL_ALLOC);
3166
3167 if (dump_file[DFI_lreg].enabled)
3168 {
3169 timevar_push (TV_DUMP);
3170
3171 dump_flow_info (rtl_dump_file);
3172 dump_local_alloc (rtl_dump_file);
3173
3174 close_dump_file (DFI_lreg, print_rtl_with_bb, insns);
3175 timevar_pop (TV_DUMP);
3176 }
3177
3178 ggc_collect ();
3179
3180 timevar_push (TV_GLOBAL_ALLOC);
3181 open_dump_file (DFI_greg, decl);
3182
3183 /* If optimizing, allocate remaining pseudo-regs. Do the reload
3184 pass fixing up any insns that are invalid. */
3185
3186 if (optimize)
3187 failure = global_alloc (rtl_dump_file);
3188 else
3189 {
3190 build_insn_chain (insns);
3191 failure = reload (insns, 0);
3192 }
3193
3194 timevar_pop (TV_GLOBAL_ALLOC);
3195
3196 if (dump_file[DFI_greg].enabled)
3197 {
3198 timevar_push (TV_DUMP);
3199
3200 dump_global_regs (rtl_dump_file);
3201
3202 close_dump_file (DFI_greg, print_rtl_with_bb, insns);
3203 timevar_pop (TV_DUMP);
3204 }
3205
3206 if (failure)
3207 goto exit_rest_of_compilation;
3208
3209 ggc_collect ();
3210
3211 open_dump_file (DFI_postreload, decl);
3212
3213 /* Do a very simple CSE pass over just the hard registers. */
3214 if (optimize > 0)
3215 {
3216 timevar_push (TV_RELOAD_CSE_REGS);
3217 reload_cse_regs (insns);
3218 timevar_pop (TV_RELOAD_CSE_REGS);
3219 }
3220
3221 /* Register allocation and reloading may have turned an indirect jump into
3222 a direct jump. If so, we must rebuild the JUMP_LABEL fields of
3223 jumping instructions. */
3224 if (rebuild_label_notes_after_reload)
3225 {
3226 timevar_push (TV_JUMP);
3227
3228 rebuild_jump_labels (insns);
3229
3230 timevar_pop (TV_JUMP);
3231 }
3232
3233 close_dump_file (DFI_postreload, print_rtl_with_bb, insns);
3234
3235 /* Re-create the death notes which were deleted during reload. */
3236 timevar_push (TV_FLOW2);
3237 open_dump_file (DFI_flow2, decl);
3238
3239 #ifdef ENABLE_CHECKING
3240 verify_flow_info ();
3241 #endif
3242
3243 /* If optimizing, then go ahead and split insns now. */
3244 if (optimize > 0)
3245 split_all_insns (0);
3246
3247 cleanup_cfg (optimize ? CLEANUP_EXPENSIVE : 0);
3248
3249 /* On some machines, the prologue and epilogue code, or parts thereof,
3250 can be represented as RTL. Doing so lets us schedule insns between
3251 it and the rest of the code and also allows delayed branch
3252 scheduling to operate in the epilogue. */
3253 thread_prologue_and_epilogue_insns (insns);
3254
3255 if (optimize)
3256 {
3257 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_CROSSJUMP);
3258 life_analysis (insns, rtl_dump_file, PROP_FINAL);
3259
3260 /* This is kind of a heuristic. We need to run combine_stack_adjustments
3261 even for machines with possibly nonzero RETURN_POPS_ARGS
3262 and ACCUMULATE_OUTGOING_ARGS. We expect that only ports having
3263 push instructions will have popping returns. */
3264 #ifndef PUSH_ROUNDING
3265 if (!ACCUMULATE_OUTGOING_ARGS)
3266 #endif
3267 combine_stack_adjustments ();
3268
3269 ggc_collect ();
3270 }
3271
3272 flow2_completed = 1;
3273
3274 close_dump_file (DFI_flow2, print_rtl_with_bb, insns);
3275 timevar_pop (TV_FLOW2);
3276
3277 #ifdef HAVE_peephole2
3278 if (optimize > 0 && flag_peephole2)
3279 {
3280 timevar_push (TV_PEEPHOLE2);
3281 open_dump_file (DFI_peephole2, decl);
3282
3283 peephole2_optimize (rtl_dump_file);
3284
3285 close_dump_file (DFI_peephole2, print_rtl_with_bb, insns);
3286 timevar_pop (TV_PEEPHOLE2);
3287 }
3288 #endif
3289
3290 if (optimize > 0 && flag_rename_registers)
3291 {
3292 timevar_push (TV_RENAME_REGISTERS);
3293 open_dump_file (DFI_rnreg, decl);
3294
3295 regrename_optimize ();
3296
3297 close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
3298 timevar_pop (TV_RENAME_REGISTERS);
3299 }
3300
3301 if (optimize > 0)
3302 {
3303 timevar_push (TV_IFCVT2);
3304 open_dump_file (DFI_ce2, decl);
3305
3306 if_convert (1);
3307
3308 close_dump_file (DFI_ce2, print_rtl_with_bb, insns);
3309 timevar_pop (TV_IFCVT2);
3310 }
3311 #ifdef STACK_REGS
3312 if (optimize)
3313 split_all_insns (1);
3314 #endif
3315
3316 #ifdef INSN_SCHEDULING
3317 if (optimize > 0 && flag_schedule_insns_after_reload)
3318 {
3319 timevar_push (TV_SCHED2);
3320 open_dump_file (DFI_sched2, decl);
3321
3322 /* Do control and data sched analysis again,
3323 and write some more of the results to dump file. */
3324
3325 split_all_insns (1);
3326
3327 schedule_insns (rtl_dump_file);
3328
3329 close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
3330 timevar_pop (TV_SCHED2);
3331
3332 ggc_collect ();
3333 }
3334 #endif
3335
3336 #ifdef LEAF_REGISTERS
3337 current_function_uses_only_leaf_regs
3338 = optimize > 0 && only_leaf_regs_used () && leaf_function_p ();
3339 #endif
3340
3341 #ifdef STACK_REGS
3342 timevar_push (TV_REG_STACK);
3343 open_dump_file (DFI_stack, decl);
3344
3345 reg_to_stack (insns, rtl_dump_file);
3346
3347 close_dump_file (DFI_stack, print_rtl_with_bb, insns);
3348 timevar_pop (TV_REG_STACK);
3349
3350 ggc_collect ();
3351 #endif
3352 if (optimize > 0)
3353 {
3354 timevar_push (TV_REORDER_BLOCKS);
3355 open_dump_file (DFI_bbro, decl);
3356
3357 /* Last attempt to optimize CFG, as life analyzis possibly removed
3358 some instructions. */
3359 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
3360 | CLEANUP_CROSSJUMP);
3361 if (flag_reorder_blocks)
3362 {
3363 reorder_basic_blocks ();
3364 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
3365 }
3366
3367 close_dump_file (DFI_bbro, print_rtl_with_bb, insns);
3368 timevar_pop (TV_REORDER_BLOCKS);
3369 }
3370 compute_alignments ();
3371
3372 /* CFG is no longer maintained up-to-date. */
3373 free_bb_for_insn ();
3374
3375 /* If a machine dependent reorganization is needed, call it. */
3376 #ifdef MACHINE_DEPENDENT_REORG
3377 timevar_push (TV_MACH_DEP);
3378 open_dump_file (DFI_mach, decl);
3379
3380 MACHINE_DEPENDENT_REORG (insns);
3381
3382 close_dump_file (DFI_mach, print_rtl, insns);
3383 timevar_pop (TV_MACH_DEP);
3384
3385 ggc_collect ();
3386 #endif
3387
3388 purge_line_number_notes (insns);
3389 cleanup_barriers ();
3390
3391 /* If a scheduling pass for delayed branches is to be done,
3392 call the scheduling code. */
3393
3394 #ifdef DELAY_SLOTS
3395 if (optimize > 0 && flag_delayed_branch)
3396 {
3397 timevar_push (TV_DBR_SCHED);
3398 open_dump_file (DFI_dbr, decl);
3399
3400 dbr_schedule (insns, rtl_dump_file);
3401
3402 close_dump_file (DFI_dbr, print_rtl, insns);
3403 timevar_pop (TV_DBR_SCHED);
3404
3405 ggc_collect ();
3406 }
3407 #endif
3408
3409 #if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
3410 timevar_push (TV_SHORTEN_BRANCH);
3411 split_all_insns_noflow ();
3412 timevar_pop (TV_SHORTEN_BRANCH);
3413 #endif
3414
3415 convert_to_eh_region_ranges ();
3416
3417 /* Shorten branches. */
3418 timevar_push (TV_SHORTEN_BRANCH);
3419 shorten_branches (get_insns ());
3420 timevar_pop (TV_SHORTEN_BRANCH);
3421
3422 current_function_nothrow = nothrow_function_p ();
3423 if (current_function_nothrow)
3424 /* Now we know that this can't throw; set the flag for the benefit
3425 of other functions later in this translation unit. */
3426 TREE_NOTHROW (current_function_decl) = 1;
3427
3428 /* Now turn the rtl into assembler code. */
3429
3430 timevar_push (TV_FINAL);
3431 {
3432 rtx x;
3433 const char *fnname;
3434
3435 /* Get the function's name, as described by its RTL. This may be
3436 different from the DECL_NAME name used in the source file. */
3437
3438 x = DECL_RTL (decl);
3439 if (GET_CODE (x) != MEM)
3440 abort ();
3441 x = XEXP (x, 0);
3442 if (GET_CODE (x) != SYMBOL_REF)
3443 abort ();
3444 fnname = XSTR (x, 0);
3445
3446 assemble_start_function (decl, fnname);
3447 final_start_function (insns, asm_out_file, optimize);
3448 final (insns, asm_out_file, optimize, 0);
3449 final_end_function ();
3450
3451 #ifdef IA64_UNWIND_INFO
3452 /* ??? The IA-64 ".handlerdata" directive must be issued before
3453 the ".endp" directive that closes the procedure descriptor. */
3454 output_function_exception_table ();
3455 #endif
3456
3457 assemble_end_function (decl, fnname);
3458
3459 #ifndef IA64_UNWIND_INFO
3460 /* Otherwise, it feels unclean to switch sections in the middle. */
3461 output_function_exception_table ();
3462 #endif
3463
3464 if (! quiet_flag)
3465 fflush (asm_out_file);
3466
3467 /* Release all memory allocated by flow. */
3468 free_basic_block_vars (0);
3469
3470 /* Release all memory held by regsets now. */
3471 regset_release_memory ();
3472 }
3473 timevar_pop (TV_FINAL);
3474
3475 ggc_collect ();
3476
3477 /* Write DBX symbols if requested. */
3478
3479 /* Note that for those inline functions where we don't initially
3480 know for certain that we will be generating an out-of-line copy,
3481 the first invocation of this routine (rest_of_compilation) will
3482 skip over this code by doing a `goto exit_rest_of_compilation;'.
3483 Later on, finish_compilation will call rest_of_compilation again
3484 for those inline functions that need to have out-of-line copies
3485 generated. During that call, we *will* be routed past here. */
3486
3487 timevar_push (TV_SYMOUT);
3488 (*debug_hooks->function_decl) (decl);
3489 timevar_pop (TV_SYMOUT);
3490
3491 exit_rest_of_compilation:
3492
3493 /* In case the function was not output,
3494 don't leave any temporary anonymous types
3495 queued up for sdb output. */
3496 #ifdef SDB_DEBUGGING_INFO
3497 if (write_symbols == SDB_DEBUG)
3498 sdbout_types (NULL_TREE);
3499 #endif
3500
3501 reload_completed = 0;
3502 flow2_completed = 0;
3503 no_new_pseudos = 0;
3504
3505 timevar_push (TV_FINAL);
3506
3507 /* Clear out the insn_length contents now that they are no
3508 longer valid. */
3509 init_insn_lengths ();
3510
3511 /* Clear out the real_constant_chain before some of the rtx's
3512 it runs through become garbage. */
3513 clear_const_double_mem ();
3514
3515 /* Show no temporary slots allocated. */
3516 init_temp_slots ();
3517
3518 free_basic_block_vars (0);
3519
3520 timevar_pop (TV_FINAL);
3521
3522 /* Make sure volatile mem refs aren't considered valid operands for
3523 arithmetic insns. We must call this here if this is a nested inline
3524 function, since the above code leaves us in the init_recog state
3525 (from final.c), and the function context push/pop code does not
3526 save/restore volatile_ok.
3527
3528 ??? Maybe it isn't necessary for expand_start_function to call this
3529 anymore if we do it here? */
3530
3531 init_recog_no_volatile ();
3532
3533 /* We're done with this function. Free up memory if we can. */
3534 free_after_parsing (cfun);
3535 if (! DECL_DEFER_OUTPUT (decl))
3536 {
3537 free_after_compilation (cfun);
3538
3539 /* Clear integrate.c's pointer to the cfun structure we just
3540 destroyed. */
3541 DECL_SAVED_INSNS (decl) = 0;
3542 }
3543 cfun = 0;
3544
3545 ggc_collect ();
3546
3547 timevar_pop (TV_REST_OF_COMPILATION);
3548 }
3549 \f
3550 static void
3551 display_help ()
3552 {
3553 int undoc;
3554 unsigned long i;
3555 const char *lang;
3556
3557 printf (_(" -ffixed-<register> Mark <register> as being unavailable to the compiler\n"));
3558 printf (_(" -fcall-used-<register> Mark <register> as being corrupted by function calls\n"));
3559 printf (_(" -fcall-saved-<register> Mark <register> as being preserved across functions\n"));
3560 printf (_(" -finline-limit=<number> Limits the size of inlined functions to <number>\n"));
3561 printf (_(" -fmessage-length=<number> Limits diagnostics messages lengths to <number> characters per line. 0 suppresses line-wrapping\n"));
3562 printf (_(" -fdiagnostics-show-location=[once | every-line] Indicates how often source location information should be emitted, as prefix, at the beginning of diagnostics when line-wrapping\n"));
3563
3564 for (i = ARRAY_SIZE (f_options); i--;)
3565 {
3566 const char *description = f_options[i].description;
3567
3568 if (description != NULL && * description != 0)
3569 printf (" -f%-21s %s\n",
3570 f_options[i].string, _(description));
3571 }
3572
3573 printf (_(" -O[number] Set optimisation level to [number]\n"));
3574 printf (_(" -Os Optimise for space rather than speed\n"));
3575 for (i = LAST_PARAM; i--;)
3576 {
3577 const char *description = compiler_params[i].help;
3578 const int length = 21-strlen(compiler_params[i].option);
3579
3580 if (description != NULL && * description != 0)
3581 printf (" --param %s=<value>%.*s%s\n",
3582 compiler_params[i].option,
3583 length > 0 ? length : 1, " ",
3584 _(description));
3585 }
3586 printf (_(" -pedantic Issue warnings needed by strict compliance to ISO C\n"));
3587 printf (_(" -pedantic-errors Like -pedantic except that errors are produced\n"));
3588 printf (_(" -w Suppress warnings\n"));
3589 printf (_(" -W Enable extra warnings\n"));
3590
3591 for (i = ARRAY_SIZE (W_options); i--;)
3592 {
3593 const char *description = W_options[i].description;
3594
3595 if (description != NULL && * description != 0)
3596 printf (" -W%-21s %s\n",
3597 W_options[i].string, _(description));
3598 }
3599
3600 printf (_(" -Wunused Enable unused warnings\n"));
3601 printf (_(" -Wlarger-than-<number> Warn if an object is larger than <number> bytes\n"));
3602 printf (_(" -p Enable function profiling\n"));
3603 #if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER)
3604 printf (_(" -a Enable block profiling \n"));
3605 #endif
3606 #if defined (BLOCK_PROFILER) || defined (FUNCTION_BLOCK_PROFILER) || defined FUNCTION_BLOCK_PROFILER_EXIT
3607 printf (_(" -ax Enable jump profiling \n"));
3608 #endif
3609 printf (_(" -o <file> Place output into <file> \n"));
3610 printf (_("\
3611 -G <number> Put global and static data smaller than <number>\n\
3612 bytes into a special section (on some targets)\n"));
3613
3614 for (i = ARRAY_SIZE (debug_args); i--;)
3615 {
3616 if (debug_args[i].description != NULL)
3617 printf (" -g%-21s %s\n",
3618 debug_args[i].arg, _(debug_args[i].description));
3619 }
3620
3621 printf (_(" -aux-info <file> Emit declaration info into <file>\n"));
3622 printf (_(" -quiet Do not display functions compiled or elapsed time\n"));
3623 printf (_(" -version Display the compiler's version\n"));
3624 printf (_(" -d[letters] Enable dumps from specific passes of the compiler\n"));
3625 printf (_(" -dumpbase <file> Base name to be used for dumps from specific passes\n"));
3626 #if defined INSN_SCHEDULING
3627 printf (_(" -fsched-verbose=<number> Set the verbosity level of the scheduler\n"));
3628 #endif
3629 printf (_(" --help Display this information\n"));
3630
3631 undoc = 0;
3632 lang = "language";
3633
3634 /* Display descriptions of language specific options.
3635 If there is no description, note that there is an undocumented option.
3636 If the description is empty, do not display anything. (This allows
3637 options to be deliberately undocumented, for whatever reason).
3638 If the option string is missing, then this is a marker, indicating
3639 that the description string is in fact the name of a language, whose
3640 language specific options are to follow. */
3641
3642 if (ARRAY_SIZE (documented_lang_options) > 1)
3643 {
3644 printf (_("\nLanguage specific options:\n"));
3645
3646 for (i = 0; i < ARRAY_SIZE (documented_lang_options); i++)
3647 {
3648 const char *description = documented_lang_options[i].description;
3649 const char *option = documented_lang_options[i].option;
3650
3651 if (description == NULL)
3652 {
3653 undoc = 1;
3654
3655 if (extra_warnings)
3656 printf (_(" %-23.23s [undocumented]\n"), option);
3657 }
3658 else if (*description == 0)
3659 continue;
3660 else if (option == NULL)
3661 {
3662 if (undoc)
3663 printf
3664 (_("\nThere are undocumented %s specific options as well.\n"),
3665 lang);
3666 undoc = 0;
3667
3668 printf (_("\n Options for %s:\n"), description);
3669
3670 lang = description;
3671 }
3672 else
3673 printf (" %-23.23s %s\n", option, _(description));
3674 }
3675 }
3676
3677 if (undoc)
3678 printf (_("\nThere are undocumented %s specific options as well.\n"),
3679 lang);
3680
3681 display_target_options ();
3682 }
3683
3684 static void
3685 display_target_options ()
3686 {
3687 int undoc,i;
3688
3689 if (ARRAY_SIZE (target_switches) > 1
3690 #ifdef TARGET_OPTIONS
3691 || ARRAY_SIZE (target_options) > 1
3692 #endif
3693 )
3694 {
3695 int doc = 0;
3696
3697 undoc = 0;
3698
3699 printf (_("\nTarget specific options:\n"));
3700
3701 for (i = ARRAY_SIZE (target_switches); i--;)
3702 {
3703 const char *option = target_switches[i].name;
3704 const char *description = target_switches[i].description;
3705
3706 if (option == NULL || *option == 0)
3707 continue;
3708 else if (description == NULL)
3709 {
3710 undoc = 1;
3711
3712 if (extra_warnings)
3713 printf (_(" -m%-23.23s [undocumented]\n"), option);
3714 }
3715 else if (* description != 0)
3716 doc += printf (" -m%-23.23s %s\n", option, _(description));
3717 }
3718
3719 #ifdef TARGET_OPTIONS
3720 for (i = ARRAY_SIZE (target_options); i--;)
3721 {
3722 const char *option = target_options[i].prefix;
3723 const char *description = target_options[i].description;
3724
3725 if (option == NULL || *option == 0)
3726 continue;
3727 else if (description == NULL)
3728 {
3729 undoc = 1;
3730
3731 if (extra_warnings)
3732 printf (_(" -m%-23.23s [undocumented]\n"), option);
3733 }
3734 else if (* description != 0)
3735 doc += printf (" -m%-23.23s %s\n", option, _(description));
3736 }
3737 #endif
3738 if (undoc)
3739 {
3740 if (doc)
3741 printf (_("\nThere are undocumented target specific options as well.\n"));
3742 else
3743 printf (_(" They exist, but they are not documented.\n"));
3744 }
3745 }
3746 }
3747 \f
3748 /* Parse a -d... command line switch. */
3749
3750 static void
3751 decode_d_option (arg)
3752 const char *arg;
3753 {
3754 int i, c, matched;
3755
3756 while (*arg)
3757 switch (c = *arg++)
3758 {
3759 case 'a':
3760 for (i = 0; i < (int) DFI_MAX; ++i)
3761 dump_file[i].enabled = 1;
3762 break;
3763 case 'A':
3764 flag_debug_asm = 1;
3765 break;
3766 case 'p':
3767 flag_print_asm_name = 1;
3768 break;
3769 case 'P':
3770 flag_dump_rtl_in_asm = 1;
3771 flag_print_asm_name = 1;
3772 break;
3773 case 'v':
3774 graph_dump_format = vcg;
3775 break;
3776 case 'x':
3777 rtl_dump_and_exit = 1;
3778 break;
3779 case 'y':
3780 (*lang_hooks.set_yydebug) (1);
3781 break;
3782 case 'D': /* These are handled by the preprocessor. */
3783 case 'I':
3784 break;
3785
3786 default:
3787 matched = 0;
3788 for (i = 0; i < (int) DFI_MAX; ++i)
3789 if (c == dump_file[i].debug_switch)
3790 {
3791 dump_file[i].enabled = 1;
3792 matched = 1;
3793 }
3794
3795 if (! matched)
3796 warning ("unrecognized gcc debugging option: %c", c);
3797 break;
3798 }
3799 }
3800
3801 /* Parse a -f... command line switch. ARG is the value after the -f.
3802 It is safe to access 'ARG - 2' to generate the full switch name.
3803 Return the number of strings consumed. */
3804
3805 static int
3806 decode_f_option (arg)
3807 const char *arg;
3808 {
3809 int j;
3810 const char *option_value = NULL;
3811
3812 /* Search for the option in the table of binary f options. */
3813 for (j = ARRAY_SIZE (f_options); j--;)
3814 {
3815 if (!strcmp (arg, f_options[j].string))
3816 {
3817 *f_options[j].variable = f_options[j].on_value;
3818 return 1;
3819 }
3820
3821 if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
3822 && ! strcmp (arg + 3, f_options[j].string))
3823 {
3824 *f_options[j].variable = ! f_options[j].on_value;
3825 return 1;
3826 }
3827 }
3828
3829 if (!strcmp (arg, "fast-math"))
3830 set_fast_math_flags();
3831 else if (!strcmp (arg, "no-fast-math"))
3832 set_no_fast_math_flags();
3833 else if ((option_value = skip_leading_substring (arg, "inline-limit-"))
3834 || (option_value = skip_leading_substring (arg, "inline-limit=")))
3835 {
3836 int val =
3837 read_integral_parameter (option_value, arg - 2,
3838 MAX_INLINE_INSNS);
3839 set_param_value ("max-inline-insns", val);
3840 }
3841 #ifdef INSN_SCHEDULING
3842 else if ((option_value = skip_leading_substring (arg, "sched-verbose=")))
3843 fix_sched_param ("verbose", option_value);
3844 #endif
3845 else if ((option_value = skip_leading_substring (arg, "fixed-")))
3846 fix_register (option_value, 1, 1);
3847 else if ((option_value = skip_leading_substring (arg, "call-used-")))
3848 fix_register (option_value, 0, 1);
3849 else if ((option_value = skip_leading_substring (arg, "call-saved-")))
3850 fix_register (option_value, 0, 0);
3851 else if ((option_value = skip_leading_substring (arg, "align-loops=")))
3852 align_loops = read_integral_parameter (option_value, arg - 2, align_loops);
3853 else if ((option_value = skip_leading_substring (arg, "align-functions=")))
3854 align_functions
3855 = read_integral_parameter (option_value, arg - 2, align_functions);
3856 else if ((option_value = skip_leading_substring (arg, "align-jumps=")))
3857 align_jumps = read_integral_parameter (option_value, arg - 2, align_jumps);
3858 else if ((option_value = skip_leading_substring (arg, "align-labels=")))
3859 align_labels
3860 = read_integral_parameter (option_value, arg - 2, align_labels);
3861 else if ((option_value
3862 = skip_leading_substring (arg, "stack-limit-register=")))
3863 {
3864 int reg = decode_reg_name (option_value);
3865 if (reg < 0)
3866 error ("unrecognized register name `%s'", option_value);
3867 else
3868 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
3869 }
3870 else if ((option_value
3871 = skip_leading_substring (arg, "stack-limit-symbol=")))
3872 {
3873 const char *nm;
3874 nm = ggc_strdup (option_value);
3875 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, nm);
3876 }
3877 else if ((option_value
3878 = skip_leading_substring (arg, "message-length=")))
3879 output_set_maximum_length
3880 (&global_dc->buffer, read_integral_parameter
3881 (option_value, arg - 2, diagnostic_line_cutoff (global_dc)));
3882 else if ((option_value
3883 = skip_leading_substring (arg, "diagnostics-show-location=")))
3884 {
3885 if (!strcmp (option_value, "once"))
3886 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
3887 else if (!strcmp (option_value, "every-line"))
3888 diagnostic_prefixing_rule (global_dc)
3889 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
3890 else
3891 error ("Unrecognized option `%s'", arg - 2);
3892 }
3893 else if (!strcmp (arg, "no-stack-limit"))
3894 stack_limit_rtx = NULL_RTX;
3895 else if (!strcmp (arg, "preprocessed"))
3896 /* Recognise this switch but do nothing. This prevents warnings
3897 about an unrecognized switch if cpplib has not been linked in. */
3898 ;
3899 else
3900 return 0;
3901
3902 return 1;
3903 }
3904
3905 /* Parse a -W... command line switch. ARG is the value after the -W.
3906 It is safe to access 'ARG - 2' to generate the full switch name.
3907 Return the number of strings consumed. */
3908
3909 static int
3910 decode_W_option (arg)
3911 const char *arg;
3912 {
3913 const char *option_value = NULL;
3914 int j;
3915
3916 /* Search for the option in the table of binary W options. */
3917
3918 for (j = ARRAY_SIZE (W_options); j--;)
3919 {
3920 if (!strcmp (arg, W_options[j].string))
3921 {
3922 *W_options[j].variable = W_options[j].on_value;
3923 return 1;
3924 }
3925
3926 if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
3927 && ! strcmp (arg + 3, W_options[j].string))
3928 {
3929 *W_options[j].variable = ! W_options[j].on_value;
3930 return 1;
3931 }
3932 }
3933
3934 if ((option_value = skip_leading_substring (arg, "id-clash-")))
3935 warning ("-Wid-clash-LEN is no longer supported");
3936 else if ((option_value = skip_leading_substring (arg, "larger-than-")))
3937 {
3938 larger_than_size = read_integral_parameter (option_value, arg - 2, -1);
3939
3940 warn_larger_than = larger_than_size != -1;
3941 }
3942 else if (!strcmp (arg, "unused"))
3943 {
3944 set_Wunused (1);
3945 }
3946 else if (!strcmp (arg, "no-unused"))
3947 {
3948 set_Wunused (0);
3949 }
3950 else
3951 return 0;
3952
3953 return 1;
3954 }
3955
3956 /* Parse a -g... command line switch. ARG is the value after the -g.
3957 It is safe to access 'ARG - 2' to generate the full switch name.
3958 Return the number of strings consumed. */
3959
3960 static int
3961 decode_g_option (arg)
3962 const char *arg;
3963 {
3964 static unsigned level=0;
3965 /* A lot of code assumes write_symbols == NO_DEBUG if the
3966 debugging level is 0 (thus -gstabs1 -gstabs0 would lose track
3967 of what debugging type has been selected). This records the
3968 selected type. It is an error to specify more than one
3969 debugging type. */
3970 static enum debug_info_type selected_debug_type = NO_DEBUG;
3971 /* Non-zero if debugging format has been explicitly set.
3972 -g and -ggdb don't explicitly set the debugging format so
3973 -gdwarf -g3 is equivalent to -gdwarf3. */
3974 static int type_explicitly_set_p = 0;
3975 /* Indexed by enum debug_info_type. */
3976 static const char *const debug_type_names[] =
3977 {
3978 "none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff"
3979 };
3980
3981 /* The maximum admissible debug level value. */
3982 static const unsigned max_debug_level = 3;
3983
3984 /* Look up ARG in the table. */
3985 for (da = debug_args; da->arg; da++)
3986 {
3987 const int da_len = strlen (da->arg);
3988
3989 if (da_len == 0 || ! strncmp (arg, da->arg, da_len))
3990 {
3991 enum debug_info_type type = da->debug_type;
3992 const char *p = arg + da_len;
3993
3994 if (*p && ! ISDIGIT (*p))
3995 continue;
3996
3997 /* A debug flag without a level defaults to level 2.
3998 Note we do not want to call read_integral_parameter
3999 for that case since it will call atoi which
4000 will return zero.
4001
4002 ??? We may want to generalize the interface to
4003 read_integral_parameter to better handle this case
4004 if this case shows up often. */
4005 if (*p)
4006 level = read_integral_parameter (p, 0, max_debug_level + 1);
4007 else
4008 level = (level == 0) ? 2 : level;
4009
4010 if (da_len > 1 && *p && !strncmp (arg, "dwarf", da_len))
4011 {
4012 error ("use -gdwarf -g%d for DWARF v1, level %d",
4013 level, level);
4014 if (level == 2)
4015 error ("use -gdwarf-2 for DWARF v2");
4016 }
4017
4018 if (level > max_debug_level)
4019 {
4020 warning ("\
4021 ignoring option `%s' due to invalid debug level specification",
4022 arg - 2);
4023 level = debug_info_level;
4024 }
4025
4026 if (type == NO_DEBUG)
4027 {
4028 type = PREFERRED_DEBUGGING_TYPE;
4029
4030 if (da_len > 1 && strncmp (arg, "gdb", da_len) == 0)
4031 {
4032 #if defined (DWARF2_DEBUGGING_INFO) && !defined (LINKER_DOES_NOT_WORK_WITH_DWARF2)
4033 type = DWARF2_DEBUG;
4034 #else
4035 #ifdef DBX_DEBUGGING_INFO
4036 type = DBX_DEBUG;
4037 #endif
4038 #endif
4039 }
4040 }
4041
4042 if (type == NO_DEBUG)
4043 warning ("`%s': unknown or unsupported -g option", arg - 2);
4044
4045 /* Does it conflict with an already selected type? */
4046 if (type_explicitly_set_p
4047 /* -g/-ggdb don't conflict with anything. */
4048 && da->debug_type != NO_DEBUG
4049 && type != selected_debug_type)
4050 warning ("`%s' ignored, conflicts with `-g%s'",
4051 arg - 2, debug_type_names[(int) selected_debug_type]);
4052 else
4053 {
4054 /* If the format has already been set, -g/-ggdb
4055 only change the debug level. */
4056 if (type_explicitly_set_p && da->debug_type == NO_DEBUG)
4057 /* Don't change debugging type. */
4058 ;
4059 else
4060 {
4061 selected_debug_type = type;
4062 type_explicitly_set_p = da->debug_type != NO_DEBUG;
4063 }
4064
4065 write_symbols = (level == 0
4066 ? NO_DEBUG
4067 : selected_debug_type);
4068 use_gnu_debug_info_extensions = da->use_extensions_p;
4069 debug_info_level = (enum debug_info_level) level;
4070 }
4071
4072 break;
4073 }
4074 }
4075
4076 if (! da->arg)
4077 return 0;
4078
4079 return 1;
4080 }
4081
4082 /* Decode the first argument in the argv as a language-independent option.
4083 Return the number of strings consumed. */
4084
4085 static unsigned int
4086 independent_decode_option (argc, argv)
4087 int argc;
4088 char **argv;
4089 {
4090 char *arg = argv[0];
4091
4092 if (arg[0] != '-' || arg[1] == 0)
4093 {
4094 if (arg[0] == '+')
4095 return 0;
4096
4097 filename = arg;
4098
4099 return 1;
4100 }
4101
4102 arg++;
4103
4104 if (!strcmp (arg, "-help"))
4105 {
4106 display_help ();
4107 exit_after_options = 1;
4108 }
4109
4110 if (!strcmp (arg, "-target-help"))
4111 {
4112 display_target_options ();
4113 exit_after_options = 1;
4114 }
4115
4116 if (!strcmp (arg, "-version"))
4117 {
4118 print_version (stderr, "");
4119 exit_after_options = 1;
4120 }
4121
4122 /* Handle '--param <name>=<value>'. */
4123 if (strcmp (arg, "-param") == 0)
4124 {
4125 char *equal;
4126
4127 if (argc == 1)
4128 {
4129 error ("-param option missing argument");
4130 return 1;
4131 }
4132
4133 /* Get the '<name>=<value>' parameter. */
4134 arg = argv[1];
4135 /* Look for the `='. */
4136 equal = strchr (arg, '=');
4137 if (!equal)
4138 error ("invalid --param option: %s", arg);
4139 else
4140 {
4141 int val;
4142
4143 /* Zero out the `=' sign so that we get two separate strings. */
4144 *equal = '\0';
4145 /* Figure out what value is specified. */
4146 val = read_integral_parameter (equal + 1, NULL, INVALID_PARAM_VAL);
4147 if (val != INVALID_PARAM_VAL)
4148 set_param_value (arg, val);
4149 else
4150 error ("invalid parameter value `%s'", equal + 1);
4151 }
4152
4153 return 2;
4154 }
4155
4156 if (*arg == 'Y')
4157 arg++;
4158
4159 switch (*arg)
4160 {
4161 default:
4162 return 0;
4163
4164 case 'O':
4165 /* Already been treated in main (). Do nothing. */
4166 break;
4167
4168 case 'm':
4169 set_target_switch (arg + 1);
4170 break;
4171
4172 case 'f':
4173 return decode_f_option (arg + 1);
4174
4175 case 'g':
4176 return decode_g_option (arg + 1);
4177
4178 case 'd':
4179 if (!strcmp (arg, "dumpbase"))
4180 {
4181 if (argc == 1)
4182 return 0;
4183
4184 dump_base_name = argv[1];
4185 return 2;
4186 }
4187 else
4188 decode_d_option (arg + 1);
4189 break;
4190
4191 case 'p':
4192 if (!strcmp (arg, "pedantic"))
4193 pedantic = 1;
4194 else if (!strcmp (arg, "pedantic-errors"))
4195 flag_pedantic_errors = pedantic = 1;
4196 else if (arg[1] == 0)
4197 profile_flag = 1;
4198 else
4199 return 0;
4200 break;
4201
4202 case 'q':
4203 if (!strcmp (arg, "quiet"))
4204 quiet_flag = 1;
4205 else
4206 return 0;
4207 break;
4208
4209 case 'v':
4210 if (!strcmp (arg, "version"))
4211 version_flag = 1;
4212 else
4213 return 0;
4214 break;
4215
4216 case 'w':
4217 if (arg[1] == 0)
4218 inhibit_warnings = 1;
4219 else
4220 return 0;
4221 break;
4222
4223 case 'W':
4224 if (arg[1] == 0)
4225 {
4226 extra_warnings = 1;
4227 /* We save the value of warn_uninitialized, since if they put
4228 -Wuninitialized on the command line, we need to generate a
4229 warning about not using it without also specifying -O. */
4230 if (warn_uninitialized != 1)
4231 warn_uninitialized = 2;
4232 }
4233 else
4234 return decode_W_option (arg + 1);
4235 break;
4236
4237 case 'a':
4238 if (arg[1] == 0)
4239 {
4240 #if !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
4241 warning ("`-a' option (basic block profile) not supported");
4242 #else
4243 profile_block_flag = (profile_block_flag < 2) ? 1 : 3;
4244 #endif
4245 }
4246 else if (!strcmp (arg, "ax"))
4247 {
4248 #if !defined (FUNCTION_BLOCK_PROFILER_EXIT) || !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
4249 warning ("`-ax' option (jump profiling) not supported");
4250 #else
4251 profile_block_flag = (!profile_block_flag
4252 || profile_block_flag == 2) ? 2 : 3;
4253 #endif
4254 }
4255 else if (!strncmp (arg, "aux-info", 8))
4256 {
4257 if (arg[8] == '\0')
4258 {
4259 if (argc == 1)
4260 return 0;
4261
4262 aux_info_file_name = argv[1];
4263 flag_gen_aux_info = 1;
4264 return 2;
4265 }
4266 else if (arg[8] == '=')
4267 {
4268 aux_info_file_name = arg + 9;
4269 flag_gen_aux_info = 1;
4270 }
4271 else
4272 return 0;
4273 }
4274 else
4275 return 0;
4276 break;
4277
4278 case 'o':
4279 if (arg[1] == 0)
4280 {
4281 if (argc == 1)
4282 return 0;
4283
4284 asm_file_name = argv[1];
4285 return 2;
4286 }
4287 return 0;
4288
4289 case 'G':
4290 {
4291 int g_switch_val;
4292 int return_val;
4293
4294 if (arg[1] == 0)
4295 {
4296 if (argc == 1)
4297 return 0;
4298
4299 g_switch_val = read_integral_parameter (argv[1], 0, -1);
4300 return_val = 2;
4301 }
4302 else
4303 {
4304 g_switch_val = read_integral_parameter (arg + 1, 0, -1);
4305 return_val = 1;
4306 }
4307
4308 if (g_switch_val == -1)
4309 return_val = 0;
4310 else
4311 {
4312 g_switch_set = TRUE;
4313 g_switch_value = g_switch_val;
4314 }
4315
4316 return return_val;
4317 }
4318 }
4319
4320 return 1;
4321 }
4322 \f
4323 /* Decode -m switches. */
4324 /* Decode the switch -mNAME. */
4325
4326 static void
4327 set_target_switch (name)
4328 const char *name;
4329 {
4330 size_t j;
4331 int valid_target_option = 0;
4332
4333 for (j = 0; j < ARRAY_SIZE (target_switches); j++)
4334 if (!strcmp (target_switches[j].name, name))
4335 {
4336 if (target_switches[j].value < 0)
4337 target_flags &= ~-target_switches[j].value;
4338 else
4339 target_flags |= target_switches[j].value;
4340 valid_target_option = 1;
4341 }
4342
4343 #ifdef TARGET_OPTIONS
4344 if (!valid_target_option)
4345 for (j = 0; j < ARRAY_SIZE (target_options); j++)
4346 {
4347 int len = strlen (target_options[j].prefix);
4348 if (!strncmp (target_options[j].prefix, name, len))
4349 {
4350 *target_options[j].variable = name + len;
4351 valid_target_option = 1;
4352 }
4353 }
4354 #endif
4355
4356 if (!valid_target_option)
4357 error ("Invalid option `%s'", name);
4358 }
4359 \f
4360 /* Print version information to FILE.
4361 Each line begins with INDENT (for the case where FILE is the
4362 assembler output file). */
4363
4364 static void
4365 print_version (file, indent)
4366 FILE *file;
4367 const char *indent;
4368 {
4369 #ifndef __VERSION__
4370 #define __VERSION__ "[?]"
4371 #endif
4372 fnotice (file,
4373 #ifdef __GNUC__
4374 "%s%s%s version %s (%s)\n%s\tcompiled by GNU C version %s.\n"
4375 #else
4376 "%s%s%s version %s (%s) compiled by CC.\n"
4377 #endif
4378 , indent, *indent != 0 ? " " : "",
4379 lang_hooks.name, version_string, TARGET_NAME,
4380 indent, __VERSION__);
4381 }
4382
4383 /* Print an option value and return the adjusted position in the line.
4384 ??? We don't handle error returns from fprintf (disk full); presumably
4385 other code will catch a disk full though. */
4386
4387 static int
4388 print_single_switch (file, pos, max, indent, sep, term, type, name)
4389 FILE *file;
4390 int pos, max;
4391 const char *indent, *sep, *term, *type, *name;
4392 {
4393 /* The ultrix fprintf returns 0 on success, so compute the result we want
4394 here since we need it for the following test. */
4395 int len = strlen (sep) + strlen (type) + strlen (name);
4396
4397 if (pos != 0
4398 && pos + len > max)
4399 {
4400 fprintf (file, "%s", term);
4401 pos = 0;
4402 }
4403 if (pos == 0)
4404 {
4405 fprintf (file, "%s", indent);
4406 pos = strlen (indent);
4407 }
4408 fprintf (file, "%s%s%s", sep, type, name);
4409 pos += len;
4410 return pos;
4411 }
4412
4413 /* Print active target switches to FILE.
4414 POS is the current cursor position and MAX is the size of a "line".
4415 Each line begins with INDENT and ends with TERM.
4416 Each switch is separated from the next by SEP. */
4417
4418 static void
4419 print_switch_values (file, pos, max, indent, sep, term)
4420 FILE *file;
4421 int pos, max;
4422 const char *indent, *sep, *term;
4423 {
4424 size_t j;
4425 char **p;
4426
4427 /* Print the options as passed. */
4428
4429 pos = print_single_switch (file, pos, max, indent, *indent ? " " : "", term,
4430 _("options passed: "), "");
4431
4432 for (p = &save_argv[1]; *p != NULL; p++)
4433 if (**p == '-')
4434 {
4435 /* Ignore these. */
4436 if (strcmp (*p, "-o") == 0)
4437 {
4438 if (p[1] != NULL)
4439 p++;
4440 continue;
4441 }
4442 if (strcmp (*p, "-quiet") == 0)
4443 continue;
4444 if (strcmp (*p, "-version") == 0)
4445 continue;
4446 if ((*p)[1] == 'd')
4447 continue;
4448
4449 pos = print_single_switch (file, pos, max, indent, sep, term, *p, "");
4450 }
4451 if (pos > 0)
4452 fprintf (file, "%s", term);
4453
4454 /* Print the -f and -m options that have been enabled.
4455 We don't handle language specific options but printing argv
4456 should suffice. */
4457
4458 pos = print_single_switch (file, 0, max, indent, *indent ? " " : "", term,
4459 _("options enabled: "), "");
4460
4461 for (j = 0; j < ARRAY_SIZE (f_options); j++)
4462 if (*f_options[j].variable == f_options[j].on_value)
4463 pos = print_single_switch (file, pos, max, indent, sep, term,
4464 "-f", f_options[j].string);
4465
4466 /* Print target specific options. */
4467
4468 for (j = 0; j < ARRAY_SIZE (target_switches); j++)
4469 if (target_switches[j].name[0] != '\0'
4470 && target_switches[j].value > 0
4471 && ((target_switches[j].value & target_flags)
4472 == target_switches[j].value))
4473 {
4474 pos = print_single_switch (file, pos, max, indent, sep, term,
4475 "-m", target_switches[j].name);
4476 }
4477
4478 #ifdef TARGET_OPTIONS
4479 for (j = 0; j < ARRAY_SIZE (target_options); j++)
4480 if (*target_options[j].variable != NULL)
4481 {
4482 char prefix[256];
4483 sprintf (prefix, "-m%s", target_options[j].prefix);
4484 pos = print_single_switch (file, pos, max, indent, sep, term,
4485 prefix, *target_options[j].variable);
4486 }
4487 #endif
4488
4489 fprintf (file, "%s", term);
4490 }
4491 \f
4492 /* Open assembly code output file. Do this even if -fsyntax-only is
4493 on, because then the driver will have provided the name of a
4494 temporary file or bit bucket for us. NAME is the file specified on
4495 the command line, possibly NULL. */
4496 static void
4497 init_asm_output (name)
4498 const char *name;
4499 {
4500 if (name == NULL && asm_file_name == 0)
4501 asm_out_file = stdout;
4502 else
4503 {
4504 if (asm_file_name == 0)
4505 {
4506 int len = strlen (dump_base_name);
4507 char *dumpname = (char *) xmalloc (len + 6);
4508 memcpy (dumpname, dump_base_name, len + 1);
4509 strip_off_ending (dumpname, len);
4510 strcat (dumpname, ".s");
4511 asm_file_name = dumpname;
4512 }
4513 if (!strcmp (asm_file_name, "-"))
4514 asm_out_file = stdout;
4515 else
4516 asm_out_file = fopen (asm_file_name, "w");
4517 if (asm_out_file == 0)
4518 fatal_io_error ("can't open %s for writing", asm_file_name);
4519 }
4520
4521 #ifdef IO_BUFFER_SIZE
4522 setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
4523 _IOFBF, IO_BUFFER_SIZE);
4524 #endif
4525
4526 if (!flag_syntax_only)
4527 {
4528 #ifdef ASM_FILE_START
4529 ASM_FILE_START (asm_out_file);
4530 #endif
4531
4532 #ifdef ASM_COMMENT_START
4533 if (flag_verbose_asm)
4534 {
4535 /* Print the list of options in effect. */
4536 print_version (asm_out_file, ASM_COMMENT_START);
4537 print_switch_values (asm_out_file, 0, MAX_LINE,
4538 ASM_COMMENT_START, " ", "\n");
4539 /* Add a blank line here so it appears in assembler output but not
4540 screen output. */
4541 fprintf (asm_out_file, "\n");
4542 }
4543 #endif
4544 }
4545 }
4546 \f
4547 /* Initialization of the front end environment, before command line
4548 options are parsed. Signal handlers, internationalization etc.
4549 ARGV0 is main's argv[0]. */
4550 static void
4551 general_init (argv0)
4552 char *argv0;
4553 {
4554 char *p;
4555
4556 p = argv0 + strlen (argv0);
4557 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
4558 --p;
4559 progname = p;
4560
4561 xmalloc_set_program_name (progname);
4562
4563 gcc_init_libintl ();
4564
4565 /* Install handler for SIGFPE, which may be received while we do
4566 compile-time floating point arithmetic. */
4567 signal (SIGFPE, float_signal);
4568
4569 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
4570 #ifdef SIGSEGV
4571 signal (SIGSEGV, crash_signal);
4572 #endif
4573 #ifdef SIGILL
4574 signal (SIGILL, crash_signal);
4575 #endif
4576 #ifdef SIGBUS
4577 signal (SIGBUS, crash_signal);
4578 #endif
4579 #ifdef SIGABRT
4580 signal (SIGABRT, crash_signal);
4581 #endif
4582 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
4583 signal (SIGIOT, crash_signal);
4584 #endif
4585
4586 /* Initialize the diagnostics reporting machinery, so option parsing
4587 can give warnings and errors. */
4588 diagnostic_initialize (global_dc);
4589 }
4590 \f
4591 /* Parse command line options and set default flag values, called
4592 after language-independent option-independent initialization. Do
4593 minimal options processing. Outputting diagnostics is OK, but GC
4594 and identifier hashtables etc. are not initialized yet. */
4595 static void
4596 parse_options_and_default_flags (argc, argv)
4597 int argc;
4598 char **argv;
4599 {
4600 int i;
4601
4602 /* Save in case md file wants to emit args as a comment. */
4603 save_argc = argc;
4604 save_argv = argv;
4605
4606 /* Initialize register usage now so switches may override. */
4607 init_reg_sets ();
4608
4609 /* Register the language-independent parameters. */
4610 add_params (lang_independent_params, LAST_PARAM);
4611
4612 /* Perform language-specific options initialization. */
4613 (*lang_hooks.init_options) ();
4614
4615 /* Scan to see what optimization level has been specified. That will
4616 determine the default value of many flags. */
4617 for (i = 1; i < argc; i++)
4618 {
4619 if (!strcmp (argv[i], "-O"))
4620 {
4621 optimize = 1;
4622 optimize_size = 0;
4623 }
4624 else if (argv[i][0] == '-' && argv[i][1] == 'O')
4625 {
4626 /* Handle -Os, -O2, -O3, -O69, ... */
4627 char *p = &argv[i][2];
4628
4629 if ((p[0] == 's') && (p[1] == 0))
4630 {
4631 optimize_size = 1;
4632
4633 /* Optimizing for size forces optimize to be 2. */
4634 optimize = 2;
4635 }
4636 else
4637 {
4638 const int optimize_val = read_integral_parameter (p, p - 2, -1);
4639 if (optimize_val != -1)
4640 {
4641 optimize = optimize_val;
4642 optimize_size = 0;
4643 }
4644 }
4645 }
4646 }
4647
4648 if (!optimize)
4649 {
4650 flag_merge_constants = 0;
4651 }
4652
4653 if (optimize >= 1)
4654 {
4655 flag_defer_pop = 1;
4656 flag_thread_jumps = 1;
4657 #ifdef DELAY_SLOTS
4658 flag_delayed_branch = 1;
4659 #endif
4660 #ifdef CAN_DEBUG_WITHOUT_FP
4661 flag_omit_frame_pointer = 1;
4662 #endif
4663 flag_guess_branch_prob = 1;
4664 }
4665
4666 if (optimize >= 2)
4667 {
4668 flag_optimize_sibling_calls = 1;
4669 flag_cse_follow_jumps = 1;
4670 flag_cse_skip_blocks = 1;
4671 flag_gcse = 1;
4672 flag_expensive_optimizations = 1;
4673 flag_strength_reduce = 1;
4674 flag_rerun_cse_after_loop = 1;
4675 flag_rerun_loop_opt = 1;
4676 flag_caller_saves = 1;
4677 flag_force_mem = 1;
4678 flag_peephole2 = 1;
4679 #ifdef INSN_SCHEDULING
4680 flag_schedule_insns = 1;
4681 flag_schedule_insns_after_reload = 1;
4682 #endif
4683 flag_regmove = 1;
4684 flag_strict_aliasing = 1;
4685 flag_delete_null_pointer_checks = 1;
4686 flag_reorder_blocks = 1;
4687 }
4688
4689 if (optimize >= 3)
4690 {
4691 flag_inline_functions = 1;
4692 flag_rename_registers = 1;
4693 }
4694
4695 if (optimize < 2 || optimize_size)
4696 {
4697 align_loops = 1;
4698 align_jumps = 1;
4699 align_labels = 1;
4700 align_functions = 1;
4701 }
4702
4703 /* Initialize whether `char' is signed. */
4704 flag_signed_char = DEFAULT_SIGNED_CHAR;
4705 #ifdef DEFAULT_SHORT_ENUMS
4706 /* Initialize how much space enums occupy, by default. */
4707 flag_short_enums = DEFAULT_SHORT_ENUMS;
4708 #endif
4709
4710 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
4711 modify it. */
4712 target_flags = 0;
4713 set_target_switch ("");
4714
4715 /* Unwind tables are always present in an ABI-conformant IA-64
4716 object file, so the default should be ON. */
4717 #ifdef IA64_UNWIND_INFO
4718 flag_unwind_tables = IA64_UNWIND_INFO;
4719 #endif
4720
4721 #ifdef OPTIMIZATION_OPTIONS
4722 /* Allow default optimizations to be specified on a per-machine basis. */
4723 OPTIMIZATION_OPTIONS (optimize, optimize_size);
4724 #endif
4725
4726 /* Perform normal command line switch decoding. */
4727 for (i = 1; i < argc;)
4728 {
4729 int lang_processed;
4730 int indep_processed;
4731
4732 /* Give the language a chance to decode the option for itself. */
4733 lang_processed = (*lang_hooks.decode_option) (argc - i, argv + i);
4734
4735 if (lang_processed >= 0)
4736 /* Now see if the option also has a language independent meaning.
4737 Some options are both language specific and language independent,
4738 eg --help. */
4739 indep_processed = independent_decode_option (argc - i, argv + i);
4740 else
4741 {
4742 lang_processed = -lang_processed;
4743 indep_processed = 0;
4744 }
4745
4746 if (lang_processed || indep_processed)
4747 i += MAX (lang_processed, indep_processed);
4748 else
4749 {
4750 const char *option = NULL;
4751 const char *lang = NULL;
4752 unsigned int j;
4753
4754 /* It is possible that the command line switch is not valid for the
4755 current language, but it is valid for another language. In order
4756 to be compatible with previous versions of the compiler (which
4757 did not issue an error message in this case) we check for this
4758 possibility here. If we do find a match, then if extra_warnings
4759 is set we generate a warning message, otherwise we will just
4760 ignore the option. */
4761 for (j = 0; j < ARRAY_SIZE (documented_lang_options); j++)
4762 {
4763 option = documented_lang_options[j].option;
4764
4765 if (option == NULL)
4766 lang = documented_lang_options[j].description;
4767 else if (! strncmp (argv[i], option, strlen (option)))
4768 break;
4769 }
4770
4771 if (j != ARRAY_SIZE (documented_lang_options))
4772 {
4773 if (extra_warnings)
4774 {
4775 warning ("Ignoring command line option '%s'", argv[i]);
4776 if (lang)
4777 warning
4778 ("(It is valid for %s but not the selected language)",
4779 lang);
4780 }
4781 }
4782 else if (argv[i][0] == '-' && argv[i][1] == 'g')
4783 warning ("`%s': unknown or unsupported -g option", &argv[i][2]);
4784 else
4785 error ("Unrecognized option `%s'", argv[i]);
4786
4787 i++;
4788 }
4789 }
4790
4791 /* All command line options have been parsed; allow the front end to
4792 perform consistency checks, etc. */
4793 (*lang_hooks.post_options) ();
4794 }
4795 \f
4796 /* Process the options that have been parsed. */
4797 static void
4798 process_options ()
4799 {
4800 /* Checker uses the frame pointer. */
4801 if (flag_check_memory_usage)
4802 flag_omit_frame_pointer = 0;
4803
4804 if (optimize == 0)
4805 {
4806 /* Inlining does not work if not optimizing,
4807 so force it not to be done. */
4808 flag_no_inline = 1;
4809 warn_inline = 0;
4810
4811 /* The c_decode_option function and decode_option hook set
4812 this to `2' if -Wall is used, so we can avoid giving out
4813 lots of errors for people who don't realize what -Wall does. */
4814 if (warn_uninitialized == 1)
4815 warning ("-Wuninitialized is not supported without -O");
4816 }
4817
4818 #ifdef OVERRIDE_OPTIONS
4819 /* Some machines may reject certain combinations of options. */
4820 OVERRIDE_OPTIONS;
4821 #endif
4822
4823 /* Set up the align_*_log variables, defaulting them to 1 if they
4824 were still unset. */
4825 if (align_loops <= 0) align_loops = 1;
4826 if (align_loops_max_skip > align_loops || !align_loops)
4827 align_loops_max_skip = align_loops - 1;
4828 align_loops_log = floor_log2 (align_loops * 2 - 1);
4829 if (align_jumps <= 0) align_jumps = 1;
4830 if (align_jumps_max_skip > align_jumps || !align_jumps)
4831 align_jumps_max_skip = align_jumps - 1;
4832 align_jumps_log = floor_log2 (align_jumps * 2 - 1);
4833 if (align_labels <= 0) align_labels = 1;
4834 align_labels_log = floor_log2 (align_labels * 2 - 1);
4835 if (align_labels_max_skip > align_labels || !align_labels)
4836 align_labels_max_skip = align_labels - 1;
4837 if (align_functions <= 0) align_functions = 1;
4838 align_functions_log = floor_log2 (align_functions * 2 - 1);
4839
4840 if (profile_block_flag == 3)
4841 {
4842 warning ("`-ax' and `-a' are conflicting options. `-a' ignored");
4843 profile_block_flag = 2;
4844 }
4845
4846 /* Unrolling all loops implies that standard loop unrolling must also
4847 be done. */
4848 if (flag_unroll_all_loops)
4849 flag_unroll_loops = 1;
4850 /* Loop unrolling requires that strength_reduction be on also. Silently
4851 turn on strength reduction here if it isn't already on. Also, the loop
4852 unrolling code assumes that cse will be run after loop, so that must
4853 be turned on also. */
4854 if (flag_unroll_loops)
4855 {
4856 flag_strength_reduce = 1;
4857 flag_rerun_cse_after_loop = 1;
4858 }
4859
4860 if (flag_non_call_exceptions)
4861 flag_asynchronous_unwind_tables = 1;
4862 if (flag_asynchronous_unwind_tables)
4863 flag_unwind_tables = 1;
4864
4865 /* Warn about options that are not supported on this machine. */
4866 #ifndef INSN_SCHEDULING
4867 if (flag_schedule_insns || flag_schedule_insns_after_reload)
4868 warning ("instruction scheduling not supported on this target machine");
4869 #endif
4870 #ifndef DELAY_SLOTS
4871 if (flag_delayed_branch)
4872 warning ("this target machine does not have delayed branches");
4873 #endif
4874
4875 /* Some operating systems do not allow profiling without a frame
4876 pointer. */
4877 if (!TARGET_ALLOWS_PROFILING_WITHOUT_FRAME_POINTER
4878 && profile_flag
4879 && flag_omit_frame_pointer)
4880 {
4881 error ("profiling does not work without a frame pointer");
4882 flag_omit_frame_pointer = 0;
4883 }
4884
4885 user_label_prefix = USER_LABEL_PREFIX;
4886 if (flag_leading_underscore != -1)
4887 {
4888 /* If the default prefix is more complicated than "" or "_",
4889 issue a warning and ignore this option. */
4890 if (user_label_prefix[0] == 0 ||
4891 (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
4892 {
4893 user_label_prefix = flag_leading_underscore ? "_" : "";
4894 }
4895 else
4896 warning ("-f%sleading-underscore not supported on this target machine",
4897 flag_leading_underscore ? "" : "no-");
4898 }
4899
4900 /* If we are in verbose mode, write out the version and maybe all the
4901 option flags in use. */
4902 if (version_flag)
4903 {
4904 print_version (stderr, "");
4905 if (! quiet_flag)
4906 print_switch_values (stderr, 0, MAX_LINE, "", " ", "\n");
4907 }
4908
4909 if (! quiet_flag)
4910 time_report = 1;
4911
4912 if (flag_syntax_only)
4913 {
4914 write_symbols = NO_DEBUG;
4915 profile_flag = 0;
4916 profile_block_flag = 0;
4917 }
4918
4919 /* Now we know write_symbols, set up the debug hooks based on it.
4920 By default we do nothing for debug output. */
4921 #if defined(DBX_DEBUGGING_INFO)
4922 if (write_symbols == DBX_DEBUG)
4923 debug_hooks = &dbx_debug_hooks;
4924 #endif
4925 #if defined(XCOFF_DEBUGGING_INFO)
4926 if (write_symbols == XCOFF_DEBUG)
4927 debug_hooks = &xcoff_debug_hooks;
4928 #endif
4929 #ifdef SDB_DEBUGGING_INFO
4930 if (write_symbols == SDB_DEBUG)
4931 debug_hooks = &sdb_debug_hooks;
4932 #endif
4933 #ifdef DWARF_DEBUGGING_INFO
4934 if (write_symbols == DWARF_DEBUG)
4935 debug_hooks = &dwarf_debug_hooks;
4936 #endif
4937 #ifdef DWARF2_DEBUGGING_INFO
4938 if (write_symbols == DWARF2_DEBUG)
4939 debug_hooks = &dwarf2_debug_hooks;
4940 #endif
4941
4942 /* If auxiliary info generation is desired, open the output file.
4943 This goes in the same directory as the source file--unlike
4944 all the other output files. */
4945 if (flag_gen_aux_info)
4946 {
4947 aux_info_file = fopen (aux_info_file_name, "w");
4948 if (aux_info_file == 0)
4949 fatal_io_error ("can't open %s", aux_info_file_name);
4950 }
4951
4952 if (! targetm.have_named_sections)
4953 {
4954 if (flag_function_sections)
4955 {
4956 warning ("-ffunction-sections not supported for this target");
4957 flag_function_sections = 0;
4958 }
4959 if (flag_data_sections)
4960 {
4961 warning ("-fdata-sections not supported for this target");
4962 flag_data_sections = 0;
4963 }
4964 }
4965
4966 if (flag_function_sections
4967 && (profile_flag || profile_block_flag))
4968 {
4969 warning ("-ffunction-sections disabled; it makes profiling impossible");
4970 flag_function_sections = 0;
4971 }
4972
4973 #ifndef OBJECT_FORMAT_ELF
4974 if (flag_function_sections && write_symbols != NO_DEBUG)
4975 warning ("-ffunction-sections may affect debugging on some targets");
4976 #endif
4977 }
4978 \f
4979 /* Language-independent initialization, before language-dependent
4980 initialization. */
4981 static void
4982 lang_independent_init ()
4983 {
4984 decl_printable_name = decl_name;
4985 lang_expand_expr = (lang_expand_expr_t) do_abort;
4986
4987 /* Set the language-dependent identifier size. */
4988 tree_code_length[(int) IDENTIFIER_NODE]
4989 = ((lang_hooks.identifier_size - sizeof (struct tree_common))
4990 / sizeof (tree));
4991
4992 /* Initialize the garbage-collector, and string pools. FIXME: We
4993 should do this later, in independent_init () when we know we
4994 actually want to compile something, but cpplib currently wants to
4995 use the hash table immediately in cpp_create_reader. */
4996 init_ggc ();
4997 ggc_add_rtx_root (&stack_limit_rtx, 1);
4998 ggc_add_tree_root (&current_function_decl, 1);
4999 ggc_add_tree_root (&current_function_func_begin_label, 1);
5000
5001 init_stringpool ();
5002 init_obstacks ();
5003
5004 init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
5005 || debug_info_level == DINFO_LEVEL_VERBOSE
5006 || flag_test_coverage
5007 || warn_notreached);
5008 init_regs ();
5009 init_alias_once ();
5010 init_stmt ();
5011 init_loop ();
5012 init_reload ();
5013 init_function_once ();
5014 init_stor_layout_once ();
5015 init_varasm_once ();
5016 init_EXPR_INSN_LIST_cache ();
5017
5018 /* The following initialization functions need to generate rtl, so
5019 provide a dummy function context for them. */
5020 init_dummy_function_start ();
5021 init_expmed ();
5022 init_expr_once ();
5023 if (flag_caller_saves)
5024 init_caller_save ();
5025 expand_dummy_function_end ();
5026 }
5027 \f
5028 /* Language-dependent initialization. Returns non-zero on success. */
5029 static int
5030 lang_dependent_init (name)
5031 const char *name;
5032 {
5033 if (dump_base_name == 0)
5034 dump_base_name = name ? name : "gccdump";
5035
5036 /* Front-end initialization. This hook can assume that GC,
5037 identifier hashes etc. are set up, but debug initialization is
5038 not done yet. This routine must return the original filename
5039 (e.g. foo.i -> foo.c) so can correctly initialize debug output. */
5040 name = (*lang_hooks.init) (name);
5041 if (name == NULL)
5042 return 0;
5043
5044 /* Is this duplication necessary? */
5045 name = ggc_strdup (name);
5046 main_input_filename = input_filename = name;
5047 init_asm_output (name);
5048
5049 /* These create various _DECL nodes, so need to be called after the
5050 front end is initialized. */
5051 init_eh ();
5052 init_optabs ();
5053
5054 /* Put an entry on the input file stack for the main input file. */
5055 push_srcloc (input_filename, 0);
5056
5057 /* If dbx symbol table desired, initialize writing it and output the
5058 predefined types. */
5059 timevar_push (TV_SYMOUT);
5060
5061 #ifdef DWARF2_UNWIND_INFO
5062 if (dwarf2out_do_frame ())
5063 dwarf2out_frame_init ();
5064 #endif
5065
5066 /* Now we have the correct original filename, we can initialize
5067 debug output. */
5068 (*debug_hooks->init) (name);
5069
5070 timevar_pop (TV_SYMOUT);
5071
5072 return 1;
5073 }
5074 \f
5075 /* Clean up: close opened files, etc. */
5076
5077 static void
5078 finalize ()
5079 {
5080 /* Close the dump files. */
5081 if (flag_gen_aux_info)
5082 {
5083 fclose (aux_info_file);
5084 if (errorcount)
5085 unlink (aux_info_file_name);
5086 }
5087
5088 /* Close non-debugging input and output files. Take special care to note
5089 whether fclose returns an error, since the pages might still be on the
5090 buffer chain while the file is open. */
5091
5092 if (asm_out_file)
5093 {
5094 if (ferror (asm_out_file) != 0)
5095 fatal_io_error ("error writing to %s", asm_file_name);
5096 if (fclose (asm_out_file) != 0)
5097 fatal_io_error ("error closing %s", asm_file_name);
5098 }
5099
5100 /* Do whatever is necessary to finish printing the graphs. */
5101 if (graph_dump_format != no_graph)
5102 {
5103 int i;
5104
5105 for (i = 0; i < (int) DFI_MAX; ++i)
5106 if (dump_file[i].initialized && dump_file[i].graph_dump_p)
5107 {
5108 char seq[16];
5109 char *suffix;
5110
5111 sprintf (seq, DUMPFILE_FORMAT, i);
5112 suffix = concat (seq, dump_file[i].extension, NULL);
5113 finish_graph_dump_file (dump_base_name, suffix);
5114 free (suffix);
5115 }
5116 }
5117
5118 if (mem_report)
5119 {
5120 ggc_print_statistics ();
5121 stringpool_statistics ();
5122 dump_tree_statistics ();
5123 }
5124
5125 /* Free up memory for the benefit of leak detectors. */
5126 free_reg_info ();
5127
5128 /* Language-specific end of compilation actions. */
5129 (*lang_hooks.finish) ();
5130 }
5131 \f
5132 /* Initialize the compiler, and compile the input file. */
5133 static void
5134 do_compile ()
5135 {
5136 /* The bulk of command line switch processing. */
5137 process_options ();
5138
5139 /* We cannot start timing until after options are processed since that
5140 says if we run timers or not. */
5141 init_timevar ();
5142 timevar_start (TV_TOTAL);
5143
5144 /* Language-independent initialization. Also sets up GC, identifier
5145 hashes etc. */
5146 lang_independent_init ();
5147
5148 /* Language-dependent initialization. Returns true on success. */
5149 if (lang_dependent_init (filename))
5150 compile_file ();
5151
5152 finalize ();
5153
5154 /* Stop timing and print the times. */
5155 timevar_stop (TV_TOTAL);
5156 timevar_print (stderr);
5157 }
5158 \f
5159 /* Entry point of cc1, cc1plus, jc1, f771, etc.
5160 Decode command args, then call compile_file.
5161 Exit code is FATAL_EXIT_CODE if can't open files or if there were
5162 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
5163
5164 It is not safe to call this function more than once. */
5165
5166 int
5167 toplev_main (argc, argv)
5168 int argc;
5169 char **argv;
5170 {
5171 /* Initialization of GCC's environment, and diagnostics. */
5172 general_init (argv [0]);
5173
5174 /* Parse the options and do minimal processing; basically just
5175 enough to default flags appropriately. */
5176 parse_options_and_default_flags (argc, argv);
5177
5178 /* Exit early if we can (e.g. -help). */
5179 if (!exit_after_options)
5180 do_compile ();
5181
5182 if (errorcount || sorrycount)
5183 return (FATAL_EXIT_CODE);
5184
5185 return (SUCCESS_EXIT_CODE);
5186 }