1 /* Top level of GNU C compiler
2 Copyright (C) 1987, 88, 89, 92-6, 1997 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* This is the top level of cc1/c++.
22 It parses command args, opens files, invokes the various passes
23 in the proper order, and counts the time used by each.
24 Error messages and low-level interface to malloc also handled here. */
35 #include <sys/types.h>
42 #include <sys/param.h>
43 /* This is for hpux. It is a real screw. They should change hpux. */
45 #include <sys/times.h>
46 #include <time.h> /* Correct for hpux at least. Is it good on other USG? */
47 #undef FFS /* Some systems define this in param.h. */
51 #include <sys/resource.h>
60 #include "insn-attr.h"
67 #ifdef XCOFF_DEBUGGING_INFO
72 /* The extra parameters substantially improve the I/O performance. */
74 vms_fopen (fname
, type
)
78 /* The <stdio.h> in the gcc-vms-1.42 distribution prototypes fopen with two
79 fixed arguments, which matches ANSI's specification but not VAXCRTL's
80 pre-ANSI implementation. This hack circumvents the mismatch problem. */
81 FILE *(*vmslib_fopen
)() = (FILE *(*)()) fopen
;
84 return (*vmslib_fopen
) (fname
, type
, "mbc=32",
85 "deq=64", "fop=tef", "shr=nil");
87 return (*vmslib_fopen
) (fname
, type
, "mbc=32");
89 #define fopen vms_fopen
92 #ifndef DEFAULT_GDB_EXTENSIONS
93 #define DEFAULT_GDB_EXTENSIONS 1
96 /* If more than one debugging type is supported, you must define
97 PREFERRED_DEBUGGING_TYPE to choose a format in a system-dependent way.
99 This is one long line cause VAXC can't handle a \-newline. */
100 #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) + defined (DWARF_DEBUGGING_INFO) + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO))
101 #ifndef PREFERRED_DEBUGGING_TYPE
102 You Lose
! You must define PREFERRED_DEBUGGING_TYPE
!
103 #endif /* no PREFERRED_DEBUGGING_TYPE */
104 #else /* Only one debugging format supported. Define PREFERRED_DEBUGGING_TYPE
105 so the following code needn't care. */
106 #ifdef DBX_DEBUGGING_INFO
107 #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
109 #ifdef SDB_DEBUGGING_INFO
110 #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG
112 #ifdef DWARF_DEBUGGING_INFO
113 #define PREFERRED_DEBUGGING_TYPE DWARF_DEBUG
115 #ifdef DWARF2_DEBUGGING_INFO
116 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
118 #ifdef XCOFF_DEBUGGING_INFO
119 #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG
121 #endif /* More than one debugger format enabled. */
123 /* If still not defined, must have been because no debugging formats
125 #ifndef PREFERRED_DEBUGGING_TYPE
126 #define PREFERRED_DEBUGGING_TYPE NO_DEBUG
129 extern int rtx_equal_function_value_matters
;
131 #if ! (defined (VMS) || defined (OS2))
132 extern char **environ
;
134 extern char *version_string
, *language_string
;
136 /* Carry information from ASM_DECLARE_OBJECT_NAME
137 to ASM_FINISH_DECLARE_OBJECT. */
139 extern int size_directive_output
;
140 extern tree last_assemble_variable_decl
;
142 extern void init_lex ();
143 extern void init_decl_processing ();
144 extern void init_obstacks ();
145 extern void init_tree_codes ();
146 extern void init_rtl ();
147 extern void init_regs ();
148 extern void init_optabs ();
149 extern void init_stmt ();
150 extern void init_reg_sets ();
151 extern void dump_flow_info ();
152 extern void dump_sched_info ();
153 extern void dump_local_alloc ();
154 extern void regset_release_memory ();
156 void rest_of_decl_compilation ();
157 void error_with_file_and_line
PVPROTO((char *file
, int line
, char *s
, ...));
158 void error_with_decl
PVPROTO((tree decl
, char *s
, ...));
159 void error_for_asm
PVPROTO((rtx insn
, char *s
, ...));
160 void error
PVPROTO((char *s
, ...));
161 void fatal
PVPROTO((char *s
, ...));
162 void warning_with_file_and_line
PVPROTO((char *file
, int line
, char *s
, ...));
163 void warning_with_decl
PVPROTO((tree decl
, char *s
, ...));
164 void warning_for_asm
PVPROTO((rtx insn
, char *s
, ...));
165 void warning
PVPROTO((char *s
, ...));
166 void pedwarn
PVPROTO((char *s
, ...));
167 void pedwarn_with_decl
PVPROTO((tree decl
, char *s
, ...));
168 void pedwarn_with_file_and_line
PVPROTO((char *file
, int line
, char *s
, ...));
169 void sorry
PVPROTO((char *s
, ...));
170 void really_sorry
PVPROTO((char *s
, ...));
175 void set_target_switch ();
176 static char *decl_name ();
178 void print_version ();
179 int print_single_switch ();
180 void print_switch_values ();
181 /* Length of line when printing switch values. */
185 extern char *sbrk ();
188 /* Name of program invoked, sans directories. */
192 /* Copy of arguments to main. */
196 /* Name of current original source file (what was input to cpp).
197 This comes from each #-command in the actual input. */
199 char *input_filename
;
201 /* Name of top-level original source file (what was input to cpp).
202 This comes from the #-command at the beginning of the actual input.
203 If there isn't any there, then this is the cc1 input file name. */
205 char *main_input_filename
;
208 /* Stream for reading from the input file. */
212 /* Current line number in real source file. */
216 /* Stack of currently pending input files. */
218 struct file_stack
*input_file_stack
;
220 /* Incremented on each change to input_file_stack. */
221 int input_file_stack_tick
;
223 /* FUNCTION_DECL for function now being parsed or compiled. */
225 extern tree current_function_decl
;
227 /* Name to use as base of names for dump output files. */
229 char *dump_base_name
;
231 /* Bit flags that specify the machine subtype we are compiling for.
232 Bits are tested using macros TARGET_... defined in the tm.h file
233 and set by `-m...' switches. Must be defined in rtlanal.c. */
235 extern int target_flags
;
237 /* Flags saying which kinds of debugging dump have been requested. */
240 int rtl_dump_and_exit
= 0;
241 int jump_opt_dump
= 0;
242 int addressof_dump
= 0;
246 int branch_prob_dump
= 0;
248 int combine_dump
= 0;
249 int regmove_dump
= 0;
251 int local_reg_dump
= 0;
252 int global_reg_dump
= 0;
254 int jump2_opt_dump
= 0;
255 int dbr_sched_dump
= 0;
256 int flag_print_asm_name
= 0;
257 int stack_reg_dump
= 0;
259 /* Name for output file of assembly code, specified with -o. */
263 /* Value of the -G xx switch, and whether it was passed or not. */
267 /* Type(s) of debugging information we are producing (if any).
268 See flags.h for the definitions of the different possible
269 types of debugging information. */
270 enum debug_info_type write_symbols
= NO_DEBUG
;
272 /* Level of debugging information we are producing. See flags.h
273 for the definitions of the different possible levels. */
274 enum debug_info_level debug_info_level
= DINFO_LEVEL_NONE
;
276 /* Nonzero means use GNU-only extensions in the generated symbolic
277 debugging information. */
278 /* Currently, this only has an effect when write_symbols is set to
279 DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
280 int use_gnu_debug_info_extensions
= 0;
282 /* Nonzero means do optimizations. -O.
283 Particular numeric values stand for particular amounts of optimization;
284 thus, -O2 stores 2 here. However, the optimizations beyond the basic
285 ones are not controlled directly by this variable. Instead, they are
286 controlled by individual `flag_...' variables that are defaulted
287 based on this variable. */
291 /* Number of error messages and warning messages so far. */
294 int warningcount
= 0;
297 /* Flag to output bytecode instead of native assembler */
298 int output_bytecode
= 0;
300 /* Pointer to function to compute the name to use to print a declaration.
301 DECL is the declaration in question.
302 VERBOSITY determines what information will be printed:
303 0: DECL_NAME, demangled as necessary.
304 1: and scope information.
305 2: and any other information that might be interesting, such as function
306 parameter types in C++. */
308 char *(*decl_printable_name
) (/* tree decl, int verbosity */);
310 /* Pointer to function to compute rtl for a language-specific tree code. */
312 struct rtx_def
*(*lang_expand_expr
) ();
314 /* Pointer to function to finish handling an incomplete decl at the
315 end of compilation. */
317 void (*incomplete_decl_finalize_hook
) () = 0;
319 /* Highest label number used at the end of reload. */
321 int max_label_num_after_reload
;
323 /* Nonzero if generating code to do profiling. */
325 int profile_flag
= 0;
327 /* Nonzero if generating code to do profiling on a line-by-line basis. */
329 int profile_block_flag
;
331 /* Nonzero if generating code to profile program flow graph arcs. */
333 int profile_arc_flag
= 0;
335 /* Nonzero if generating info for gcov to calculate line test coverage. */
337 int flag_test_coverage
= 0;
339 /* Nonzero indicates that branch taken probabilities should be calculated. */
341 int flag_branch_probabilities
= 0;
343 /* Nonzero for -pedantic switch: warn about anything
344 that standard spec forbids. */
348 /* Temporarily suppress certain warnings.
349 This is set while reading code from a system header file. */
351 int in_system_header
= 0;
353 /* Nonzero means do stupid register allocation.
354 Currently, this is 1 if `optimize' is 0. */
356 int obey_regdecls
= 0;
358 /* Don't print functions as they are compiled and don't print
359 times taken by the various passes. -quiet. */
365 /* Nonzero means `char' should be signed. */
367 int flag_signed_char
;
369 /* Nonzero means give an enum type only as many bytes as it needs. */
371 int flag_short_enums
;
373 /* Nonzero for -fcaller-saves: allocate values in regs that need to
374 be saved across function calls, if that produces overall better code.
375 Optional now, so people can test it. */
377 #ifdef DEFAULT_CALLER_SAVES
378 int flag_caller_saves
= 1;
380 int flag_caller_saves
= 0;
383 /* Nonzero if structures and unions should be returned in memory.
385 This should only be defined if compatibility with another compiler or
386 with an ABI is needed, because it results in slower code. */
388 #ifndef DEFAULT_PCC_STRUCT_RETURN
389 #define DEFAULT_PCC_STRUCT_RETURN 1
392 /* Nonzero for -fpcc-struct-return: return values the same way PCC does. */
394 int flag_pcc_struct_return
= DEFAULT_PCC_STRUCT_RETURN
;
396 /* Nonzero for -fforce-mem: load memory value into a register
397 before arithmetic on it. This makes better cse but slower compilation. */
399 int flag_force_mem
= 0;
401 /* Nonzero for -fforce-addr: load memory address into a register before
402 reference to memory. This makes better cse but slower compilation. */
404 int flag_force_addr
= 0;
406 /* Nonzero for -fdefer-pop: don't pop args after each function call;
407 instead save them up to pop many calls' args with one insns. */
409 int flag_defer_pop
= 0;
411 /* Nonzero for -ffloat-store: don't allocate floats and doubles
412 in extended-precision registers. */
414 int flag_float_store
= 0;
416 /* Nonzero for -fcse-follow-jumps:
417 have cse follow jumps to do a more extensive job. */
419 int flag_cse_follow_jumps
;
421 /* Nonzero for -fcse-skip-blocks:
422 have cse follow a branch around a block. */
423 int flag_cse_skip_blocks
;
425 /* Nonzero for -fexpensive-optimizations:
426 perform miscellaneous relatively-expensive optimizations. */
427 int flag_expensive_optimizations
;
429 /* Nonzero for -fthread-jumps:
430 have jump optimize output of loop. */
432 int flag_thread_jumps
;
434 /* Nonzero enables strength-reduction in loop.c. */
436 int flag_strength_reduce
= 0;
438 /* Nonzero enables loop unrolling in unroll.c. Only loops for which the
439 number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
440 UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
443 int flag_unroll_loops
;
445 /* Nonzero enables loop unrolling in unroll.c. All loops are unrolled.
446 This is generally not a win. */
448 int flag_unroll_all_loops
;
450 /* Nonzero forces all invariant computations in loops to be moved
453 int flag_move_all_movables
= 0;
455 /* Nonzero forces all general induction variables in loops to be
458 int flag_reduce_all_givs
= 0;
460 /* Nonzero for -fwritable-strings:
461 store string constants in data segment and don't uniquize them. */
463 int flag_writable_strings
= 0;
465 /* Nonzero means don't put addresses of constant functions in registers.
466 Used for compiling the Unix kernel, where strange substitutions are
467 done on the assembly output. */
469 int flag_no_function_cse
= 0;
471 /* Nonzero for -fomit-frame-pointer:
472 don't make a frame pointer in simple functions that don't require one. */
474 int flag_omit_frame_pointer
= 0;
476 /* Nonzero means place each function into its own section on those platforms
477 which support arbitrary section names and unlimited numbers of sections. */
479 int flag_function_sections
= 0;
481 /* Nonzero to inhibit use of define_optimization peephole opts. */
483 int flag_no_peephole
= 0;
485 /* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math
486 operations in the interest of optimization. For example it allows
487 GCC to assume arguments to sqrt are nonnegative numbers, allowing
488 faster code for sqrt to be generated. */
490 int flag_fast_math
= 0;
492 /* Nonzero means all references through pointers are volatile. */
496 /* Nonzero means treat all global and extern variables as global. */
498 int flag_volatile_global
;
500 /* Nonzero means just do syntax checking; don't output anything. */
502 int flag_syntax_only
= 0;
504 /* Nonzero means to rerun cse after loop optimization. This increases
505 compilation time about 20% and picks up a few more common expressions. */
507 static int flag_rerun_cse_after_loop
;
509 /* Nonzero means to run loop optimizations twice. */
511 static int flag_rerun_loop_opt
;
513 /* Nonzero for -finline-functions: ok to inline functions that look like
514 good inline candidates. */
516 int flag_inline_functions
;
518 /* Nonzero for -fkeep-inline-functions: even if we make a function
519 go inline everywhere, keep its definition around for debugging
522 int flag_keep_inline_functions
;
524 /* Nonzero means that functions will not be inlined. */
528 /* Nonzero means that we should emit static const variables
529 regardless of whether or not optimization is turned on. */
531 int flag_keep_static_consts
= 1;
533 /* Nonzero means we should be saving declaration info into a .X file. */
535 int flag_gen_aux_info
= 0;
537 /* Specified name of aux-info file. */
539 static char *aux_info_file_name
;
541 /* Nonzero means make the text shared if supported. */
543 int flag_shared_data
;
545 /* Nonzero means schedule into delayed branch slots if supported. */
547 int flag_delayed_branch
;
549 /* Nonzero if we are compiling pure (sharable) code.
550 Value is 1 if we are doing reasonable (i.e. simple
551 offset into offset table) pic. Value is 2 if we can
552 only perform register offsets. */
556 /* Nonzero means generate extra code for exception handling and enable
557 exception handling. */
559 int flag_exceptions
= 2;
561 /* Nonzero means don't place uninitialized global data in common storage
566 /* Nonzero means pretend it is OK to examine bits of target floats,
567 even if that isn't true. The resulting code will have incorrect constants,
568 but the same series of instructions that the native compiler would make. */
570 int flag_pretend_float
;
572 /* Nonzero means change certain warnings into errors.
573 Usually these are warnings about failure to conform to some standard. */
575 int flag_pedantic_errors
= 0;
577 /* flag_schedule_insns means schedule insns within basic blocks (before
579 flag_schedule_insns_after_reload means schedule insns after
582 int flag_schedule_insns
= 0;
583 int flag_schedule_insns_after_reload
= 0;
586 /* The following flags have effect only for scheduling before register
589 flag_schedule_interblock means schedule insns accross basic blocks.
590 flag_schedule_speculative means allow speculative motion of non-load insns.
591 flag_schedule_speculative_load means allow speculative motion of some
593 flag_schedule_speculative_load_dangerous allows speculative motion of more
595 flag_schedule_reverse_before_reload means try to reverse original order
597 flag_schedule_reverse_after_reload means try to reverse original order
600 int flag_schedule_interblock
= 1;
601 int flag_schedule_speculative
= 1;
602 int flag_schedule_speculative_load
= 0;
603 int flag_schedule_speculative_load_dangerous
= 0;
604 int flag_schedule_reverse_before_reload
= 0;
605 int flag_schedule_reverse_after_reload
= 0;
608 /* flag_on_branch_count_reg means try to replace add-1,compare,branch tupple
609 by a cheaper branch, on a count register. */
610 int flag_branch_on_count_reg
;
614 /* -finhibit-size-directive inhibits output of .size for ELF.
615 This is used only for compiling crtstuff.c,
616 and it may be extended to other effects
617 needed for crtstuff.c on other systems. */
618 int flag_inhibit_size_directive
= 0;
620 /* -fverbose-asm causes extra commentary information to be produced in
621 the generated assembly code (to make it more readable). This option
622 is generally only of use to those who actually need to read the
623 generated assembly code (perhaps while debugging the compiler itself).
624 -fverbose-asm is the default. -fno-verbose-asm causes the extra information
625 to be omitted and is useful when comparing two assembler files. */
627 int flag_verbose_asm
= 1;
629 /* -dA causes debug commentary information to be produced in
630 the generated assembly code (to make it more readable). This option
631 is generally only of use to those who actually need to read the
632 generated assembly code (perhaps while debugging the compiler itself).
633 Currently, this switch is only used by dwarfout.c; however, it is intended
634 to be a catchall for printing debug information in the assembler file. */
636 int flag_debug_asm
= 0;
638 /* -fgnu-linker specifies use of the GNU linker for initializations.
639 (Or, more generally, a linker that handles initializations.)
640 -fno-gnu-linker says that collect2 will be used. */
642 int flag_gnu_linker
= 0;
644 int flag_gnu_linker
= 1;
647 /* Tag all structures with __attribute__(packed) */
648 int flag_pack_struct
= 0;
650 /* Emit code to check for stack overflow; also may cause large objects
651 to be allocated dynamically. */
652 int flag_stack_check
;
654 /* -fcheck-memory-usage causes extra code to be generated in order to check
655 memory accesses. This is used by a detector of bad memory accesses such
657 int flag_check_memory_usage
= 0;
659 /* -fprefix-function-name causes function name to be prefixed. This
660 can be used with -fcheck-memory-usage to isolate code compiled with
661 -fcheck-memory-usage. */
662 int flag_prefix_function_name
= 0;
664 int flag_regmove
= 0;
666 /* 1 if alias checking is on (by default, when -O). */
667 int flag_alias_check
= 0;
669 /* 0 if pointer arguments may alias each other. True in C.
670 1 if pointer arguments may not alias each other but may alias
672 2 if pointer arguments may not alias each other and may not
673 alias global variables. True in Fortran.
674 This defaults to 0 for C. */
675 int flag_argument_noalias
= 0;
677 /* Table of language-independent -f options.
678 STRING is the option name. VARIABLE is the address of the variable.
679 ON_VALUE is the value to store in VARIABLE
680 if `-fSTRING' is seen as an option.
681 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */
683 struct { char *string
; int *variable
; int on_value
;} f_options
[] =
685 {"float-store", &flag_float_store
, 1},
686 {"volatile", &flag_volatile
, 1},
687 {"volatile-global", &flag_volatile_global
, 1},
688 {"defer-pop", &flag_defer_pop
, 1},
689 {"omit-frame-pointer", &flag_omit_frame_pointer
, 1},
690 {"cse-follow-jumps", &flag_cse_follow_jumps
, 1},
691 {"cse-skip-blocks", &flag_cse_skip_blocks
, 1},
692 {"expensive-optimizations", &flag_expensive_optimizations
, 1},
693 {"thread-jumps", &flag_thread_jumps
, 1},
694 {"strength-reduce", &flag_strength_reduce
, 1},
695 {"unroll-loops", &flag_unroll_loops
, 1},
696 {"unroll-all-loops", &flag_unroll_all_loops
, 1},
697 {"move-all-movables", &flag_move_all_movables
, 1},
698 {"reduce-all-givs", &flag_reduce_all_givs
, 1},
699 {"writable-strings", &flag_writable_strings
, 1},
700 {"peephole", &flag_no_peephole
, 0},
701 {"force-mem", &flag_force_mem
, 1},
702 {"force-addr", &flag_force_addr
, 1},
703 {"function-cse", &flag_no_function_cse
, 0},
704 {"inline-functions", &flag_inline_functions
, 1},
705 {"keep-inline-functions", &flag_keep_inline_functions
, 1},
706 {"inline", &flag_no_inline
, 0},
707 {"keep-static-consts", &flag_keep_static_consts
, 1},
708 {"syntax-only", &flag_syntax_only
, 1},
709 {"shared-data", &flag_shared_data
, 1},
710 {"caller-saves", &flag_caller_saves
, 1},
711 {"pcc-struct-return", &flag_pcc_struct_return
, 1},
712 {"reg-struct-return", &flag_pcc_struct_return
, 0},
713 {"delayed-branch", &flag_delayed_branch
, 1},
714 {"rerun-cse-after-loop", &flag_rerun_cse_after_loop
, 1},
715 {"rerun-loop-opt", &flag_rerun_loop_opt
, 1},
716 {"pretend-float", &flag_pretend_float
, 1},
717 {"schedule-insns", &flag_schedule_insns
, 1},
718 {"schedule-insns2", &flag_schedule_insns_after_reload
, 1},
720 {"sched-interblock",&flag_schedule_interblock
, 1},
721 {"sched-spec",&flag_schedule_speculative
, 1},
722 {"sched-spec-load",&flag_schedule_speculative_load
, 1},
723 {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous
, 1},
724 {"sched-reverse-S",&flag_schedule_reverse_before_reload
, 1},
725 {"sched-reverse-R",&flag_schedule_reverse_after_reload
, 1},
726 {"branch-count-reg",&flag_branch_on_count_reg
, 1},
728 {"pic", &flag_pic
, 1},
729 {"PIC", &flag_pic
, 2},
730 {"exceptions", &flag_exceptions
, 1},
731 {"sjlj-exceptions", &exceptions_via_longjmp
, 1},
732 {"asynchronous-exceptions", &asynchronous_exceptions
, 1},
733 {"profile-arcs", &profile_arc_flag
, 1},
734 {"test-coverage", &flag_test_coverage
, 1},
735 {"branch-probabilities", &flag_branch_probabilities
, 1},
736 {"fast-math", &flag_fast_math
, 1},
737 {"common", &flag_no_common
, 0},
738 {"inhibit-size-directive", &flag_inhibit_size_directive
, 1},
739 {"function-sections", &flag_function_sections
, 1},
740 {"verbose-asm", &flag_verbose_asm
, 1},
741 {"gnu-linker", &flag_gnu_linker
, 1},
742 {"regmove", &flag_regmove
, 1},
743 {"pack-struct", &flag_pack_struct
, 1},
744 {"stack-check", &flag_stack_check
, 1},
745 {"bytecode", &output_bytecode
, 1},
746 {"alias-check", &flag_alias_check
, 1},
747 {"argument-alias", &flag_argument_noalias
, 0},
748 {"argument-noalias", &flag_argument_noalias
, 1},
749 {"argument-noalias-global", &flag_argument_noalias
, 2},
750 {"check-memory-usage", &flag_check_memory_usage
, 1},
751 {"prefix-function-name", &flag_prefix_function_name
, 1}
754 /* Table of language-specific options. */
756 char *lang_options
[] =
759 "-fallow-single-precision",
761 "-fsigned-bitfields",
762 "-funsigned-bitfields",
763 "-fno-signed-bitfields",
764 "-fno-unsigned-bitfields",
768 "-fno-unsigned-char",
784 "-fno-cond-mismatch",
785 "-fdollars-in-identifiers",
786 "-fno-dollars-in-identifiers",
795 "-Wbad-function-cast",
796 "-Wno-bad-function-cast",
800 "-Wno-char-subscripts",
811 "-Wimplicit-function-declaration",
812 "-Wno-implicit-function-declaration",
813 "-Werror-implicit-function-declaration",
821 "-Wno-missing-braces",
822 "-Wmissing-declarations",
823 "-Wno-missing-declarations",
824 "-Wmissing-prototypes",
825 "-Wno-missing-prototypes",
827 "-Wno-nested-externs",
831 "-Wno-pointer-arith",
833 "-Wno-redundant-decls",
836 "-Wstrict-prototypes",
837 "-Wno-strict-prototypes",
845 "-Wno-write-strings",
847 /* these are for obj c */
863 /* Options controlling warnings */
865 /* Don't print warning messages. -w. */
867 int inhibit_warnings
= 0;
869 /* Print various extra warnings. -W. */
871 int extra_warnings
= 0;
873 /* Treat warnings as errors. -Werror. */
875 int warnings_are_errors
= 0;
877 /* Nonzero to warn about unused local variables. */
881 /* Nonzero to warn about variables used before they are initialized. */
883 int warn_uninitialized
;
885 /* Nonzero means warn about all declarations which shadow others. */
889 /* Warn if a switch on an enum fails to have a case for every enum value. */
893 /* Nonzero means warn about function definitions that default the return type
894 or that use a null return and have a return-type other than void. */
896 int warn_return_type
;
898 /* Nonzero means warn about pointer casts that increase the required
899 alignment of the target type (and might therefore lead to a crash
900 due to a misaligned access). */
904 /* Nonzero means warn about any identifiers that match in the first N
905 characters. The value N is in `id_clash_len'. */
908 unsigned id_clash_len
;
910 /* Nonzero means warn about any objects definitions whose size is larger
911 than N bytes. Also want about function definitions whose returned
912 values are larger than N bytes. The value N is in `larger_than_size'. */
914 int warn_larger_than
;
915 unsigned larger_than_size
;
917 /* Nonzero means warn if inline function is too large. */
921 /* Warn if a function returns an aggregate,
922 since there are often incompatible calling conventions for doing this. */
924 int warn_aggregate_return
;
926 /* Likewise for -W. */
928 struct { char *string
; int *variable
; int on_value
;} W_options
[] =
930 {"unused", &warn_unused
, 1},
931 {"error", &warnings_are_errors
, 1},
932 {"shadow", &warn_shadow
, 1},
933 {"switch", &warn_switch
, 1},
934 {"aggregate-return", &warn_aggregate_return
, 1},
935 {"cast-align", &warn_cast_align
, 1},
936 {"uninitialized", &warn_uninitialized
, 1},
937 {"inline", &warn_inline
, 1}
940 /* Output files for assembler code (real compiler output)
941 and debugging dumps. */
946 FILE *jump_opt_dump_file
;
947 FILE *addressof_dump_file
;
949 FILE *loop_dump_file
;
950 FILE *cse2_dump_file
;
951 FILE *branch_prob_dump_file
;
952 FILE *flow_dump_file
;
953 FILE *combine_dump_file
;
954 FILE *regmove_dump_file
;
955 FILE *sched_dump_file
;
956 FILE *local_reg_dump_file
;
957 FILE *global_reg_dump_file
;
958 FILE *sched2_dump_file
;
959 FILE *jump2_opt_dump_file
;
960 FILE *dbr_sched_dump_file
;
961 FILE *stack_reg_dump_file
;
963 /* Time accumulators, to count the total time spent in various passes. */
967 int integration_time
;
972 int branch_prob_time
;
977 int local_alloc_time
;
978 int global_alloc_time
;
981 int shorten_branch_time
;
987 /* Return time used so far, in microseconds. */
997 struct rusage rusage
;
1002 int proc_system_time
;
1003 int child_user_time
;
1004 int child_system_time
;
1016 return (clock() * 1000);
1017 #else /* not _WIN32 */
1020 return (tms
.tms_utime
+ tms
.tms_stime
) * (1000000 / HZ
);
1023 getrusage (0, &rusage
);
1024 return (rusage
.ru_utime
.tv_sec
* 1000000 + rusage
.ru_utime
.tv_usec
1025 + rusage
.ru_stime
.tv_sec
* 1000000 + rusage
.ru_stime
.tv_usec
);
1028 return (vms_times
.proc_user_time
+ vms_times
.proc_system_time
) * 10000;
1034 #define TIMEVAR(VAR, BODY) \
1035 do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
1038 print_time (str
, total
)
1043 "time in %s: %d.%06d\n",
1044 str
, total
/ 1000000, total
% 1000000);
1047 /* Count an error or warning. Return 1 if the message should be printed. */
1050 count_error (warningp
)
1053 if (warningp
&& inhibit_warnings
)
1056 if (warningp
&& !warnings_are_errors
)
1060 static int warning_message
= 0;
1062 if (warningp
&& !warning_message
)
1064 fprintf (stderr
, "%s: warnings being treated as errors\n", progname
);
1065 warning_message
= 1;
1073 /* Print a fatal error message. NAME is the text.
1074 Also include a system error message based on `errno'. */
1077 pfatal_with_name (name
)
1080 fprintf (stderr
, "%s: ", progname
);
1082 exit (FATAL_EXIT_CODE
);
1086 fatal_io_error (name
)
1089 fprintf (stderr
, "%s: %s: I/O error\n", progname
, name
);
1090 exit (FATAL_EXIT_CODE
);
1093 /* Called to give a better error message for a bad insn rather than
1094 just calling abort(). */
1097 fatal_insn (message
, insn
)
1101 if (!output_bytecode
)
1107 fflush (asm_out_file
);
1109 fflush (aux_info_file
);
1111 fflush (rtl_dump_file
);
1112 if (jump_opt_dump_file
)
1113 fflush (jump_opt_dump_file
);
1114 if (addressof_dump_file
)
1115 fflush (addressof_dump_file
);
1117 fflush (cse_dump_file
);
1119 fflush (loop_dump_file
);
1121 fflush (cse2_dump_file
);
1123 fflush (flow_dump_file
);
1124 if (combine_dump_file
)
1125 fflush (combine_dump_file
);
1126 if (regmove_dump_file
)
1127 fflush (regmove_dump_file
);
1128 if (sched_dump_file
)
1129 fflush (sched_dump_file
);
1130 if (local_reg_dump_file
)
1131 fflush (local_reg_dump_file
);
1132 if (global_reg_dump_file
)
1133 fflush (global_reg_dump_file
);
1134 if (sched2_dump_file
)
1135 fflush (sched2_dump_file
);
1136 if (jump2_opt_dump_file
)
1137 fflush (jump2_opt_dump_file
);
1138 if (dbr_sched_dump_file
)
1139 fflush (dbr_sched_dump_file
);
1140 if (stack_reg_dump_file
)
1141 fflush (stack_reg_dump_file
);
1147 /* Called to give a better error message when we don't have an insn to match
1148 what we are looking for or if the insn's constraints aren't satisfied,
1149 rather than just calling abort(). */
1152 fatal_insn_not_found (insn
)
1155 if (INSN_CODE (insn
) < 0)
1156 fatal_insn ("internal error--unrecognizable insn:", insn
);
1158 fatal_insn ("internal error--insn does not satisfy its constraints:", insn
);
1161 /* This is the default decl_printable_name function. */
1164 decl_name (decl
, verbosity
)
1168 return IDENTIFIER_POINTER (DECL_NAME (decl
));
1171 static int need_error_newline
;
1173 /* Function of last error message;
1174 more generally, function such that if next error message is in it
1175 then we don't have to mention the function name. */
1176 static tree last_error_function
= NULL
;
1178 /* Used to detect when input_file_stack has changed since last described. */
1179 static int last_error_tick
;
1181 /* Called when the start of a function definition is parsed,
1182 this function prints on stderr the name of the function. */
1185 announce_function (decl
)
1190 if (rtl_dump_and_exit
)
1191 fprintf (stderr
, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl
)));
1193 fprintf (stderr
, " %s", (*decl_printable_name
) (decl
, 2));
1195 need_error_newline
= 1;
1196 last_error_function
= current_function_decl
;
1200 /* The default function to print out name of current function that caused
1204 default_print_error_function (file
)
1207 if (last_error_function
!= current_function_decl
)
1209 char *kind
= "function";
1210 if (current_function_decl
!= 0
1211 && TREE_CODE (TREE_TYPE (current_function_decl
)) == METHOD_TYPE
)
1215 fprintf (stderr
, "%s: ", file
);
1217 if (current_function_decl
== NULL
)
1218 fprintf (stderr
, "At top level:\n");
1221 char *name
= (*decl_printable_name
) (current_function_decl
, 2);
1222 fprintf (stderr
, "In %s `%s':\n", kind
, name
);
1225 last_error_function
= current_function_decl
;
1229 /* Called by report_error_function to print out function name.
1230 * Default may be overridden by language front-ends. */
1232 void (*print_error_function
) PROTO((char *)) = default_print_error_function
;
1234 /* Prints out, if necessary, the name of the current function
1235 that caused an error. Called from all error and warning functions. */
1238 report_error_function (file
)
1241 struct file_stack
*p
;
1243 if (need_error_newline
)
1245 fprintf (stderr
, "\n");
1246 need_error_newline
= 0;
1249 (*print_error_function
) (file
);
1251 if (input_file_stack
&& input_file_stack
->next
!= 0
1252 && input_file_stack_tick
!= last_error_tick
1253 && file
== input_filename
)
1255 fprintf (stderr
, "In file included");
1256 for (p
= input_file_stack
->next
; p
; p
= p
->next
)
1258 fprintf (stderr
, " from %s:%d", p
->name
, p
->line
);
1260 fprintf (stderr
, ",\n ");
1262 fprintf (stderr
, ":\n");
1263 last_error_tick
= input_file_stack_tick
;
1267 /* Print a message. */
1270 vmessage (prefix
, s
, ap
)
1276 fprintf (stderr
, "%s: ", prefix
);
1279 vfprintf (stderr
, s
, ap
);
1282 HOST_WIDE_INT v1
= va_arg(ap
, HOST_WIDE_INT
);
1283 HOST_WIDE_INT v2
= va_arg(ap
, HOST_WIDE_INT
);
1284 HOST_WIDE_INT v3
= va_arg(ap
, HOST_WIDE_INT
);
1285 HOST_WIDE_INT v4
= va_arg(ap
, HOST_WIDE_INT
);
1286 fprintf (stderr
, s
, v1
, v2
, v3
, v4
);
1291 /* Print a message relevant to line LINE of file FILE. */
1294 v_message_with_file_and_line (file
, line
, prefix
, s
, ap
)
1302 fprintf (stderr
, "%s:%d: ", file
, line
);
1304 fprintf (stderr
, "%s: ", progname
);
1306 vmessage (prefix
, s
, ap
);
1307 fputc ('\n', stderr
);
1310 /* Print a message relevant to the given DECL. */
1313 v_message_with_decl (decl
, prefix
, s
, ap
)
1321 fprintf (stderr
, "%s:%d: ",
1322 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
));
1325 fprintf (stderr
, "%s: ", prefix
);
1327 /* Do magic to get around lack of varargs support for insertion
1328 of arguments into existing list. We know that the decl is first;
1329 we ass_u_me that it will be printed with "%s". */
1331 for (p
= s
; *p
; ++p
)
1335 if (*(p
+ 1) == '%')
1342 if (p
> s
) /* Print the left-hand substring. */
1344 char fmt
[sizeof "%.255s"];
1347 if (width
> 255L) width
= 255L; /* arbitrary */
1348 sprintf (fmt
, "%%.%lds", width
);
1349 fprintf (stderr
, fmt
, s
);
1352 if (*p
== '%') /* Print the name. */
1354 char *n
= (DECL_NAME (decl
)
1355 ? (*decl_printable_name
) (decl
, 2)
1361 if (isalpha (*(p
- 1) & 0xFF))
1366 if (*p
) /* Print the rest of the message. */
1367 vmessage ((char *)NULL
, p
, ap
);
1369 fputc ('\n', stderr
);
1372 /* Figure file and line of the given INSN. */
1375 file_and_line_for_asm (insn
, pfile
, pline
)
1380 rtx body
= PATTERN (insn
);
1383 /* Find the (or one of the) ASM_OPERANDS in the insn. */
1384 if (GET_CODE (body
) == SET
&& GET_CODE (SET_SRC (body
)) == ASM_OPERANDS
)
1385 asmop
= SET_SRC (body
);
1386 else if (GET_CODE (body
) == ASM_OPERANDS
)
1388 else if (GET_CODE (body
) == PARALLEL
1389 && GET_CODE (XVECEXP (body
, 0, 0)) == SET
)
1390 asmop
= SET_SRC (XVECEXP (body
, 0, 0));
1391 else if (GET_CODE (body
) == PARALLEL
1392 && GET_CODE (XVECEXP (body
, 0, 0)) == ASM_OPERANDS
)
1393 asmop
= XVECEXP (body
, 0, 0);
1399 *pfile
= ASM_OPERANDS_SOURCE_FILE (asmop
);
1400 *pline
= ASM_OPERANDS_SOURCE_LINE (asmop
);
1404 *pfile
= input_filename
;
1409 /* Report an error at line LINE of file FILE. */
1412 v_error_with_file_and_line (file
, line
, s
, ap
)
1419 report_error_function (file
);
1420 v_message_with_file_and_line (file
, line
, (char *)NULL
, s
, ap
);
1424 error_with_file_and_line
VPROTO((char *file
, int line
, char *s
, ...))
1436 file
= va_arg (ap
, char *);
1437 line
= va_arg (ap
, int);
1438 s
= va_arg (ap
, char *);
1441 v_error_with_file_and_line (file
, line
, s
, ap
);
1445 /* Report an error at the declaration DECL.
1446 S is a format string which uses %s to substitute the declaration
1447 name; subsequent substitutions are a la printf. */
1450 v_error_with_decl (decl
, s
, ap
)
1456 report_error_function (DECL_SOURCE_FILE (decl
));
1457 v_message_with_decl (decl
, (char *)NULL
, s
, ap
);
1461 error_with_decl
VPROTO((tree decl
, char *s
, ...))
1472 decl
= va_arg (ap
, tree
);
1473 s
= va_arg (ap
, char *);
1476 v_error_with_decl (decl
, s
, ap
);
1480 /* Report an error at the line number of the insn INSN.
1481 This is used only when INSN is an `asm' with operands,
1482 and each ASM_OPERANDS records its own source file and line. */
1485 v_error_for_asm (insn
, s
, ap
)
1494 file_and_line_for_asm (insn
, &file
, &line
);
1495 report_error_function (file
);
1496 v_message_with_file_and_line (file
, line
, (char *)NULL
, s
, ap
);
1500 error_for_asm
VPROTO((rtx insn
, char *s
, ...))
1511 insn
= va_arg (ap
, rtx
);
1512 s
= va_arg (ap
, char *);
1515 v_error_for_asm (insn
, s
, ap
);
1519 /* Report an error at the current line number. */
1526 v_error_with_file_and_line (input_filename
, lineno
, s
, ap
);
1530 error
VPROTO((char *s
, ...))
1540 s
= va_arg (ap
, char *);
1547 /* Report a fatal error at the current line number. */
1555 exit (FATAL_EXIT_CODE
);
1559 fatal
VPROTO((char *s
, ...))
1569 s
= va_arg (ap
, char *);
1576 /* Report a warning at line LINE of file FILE. */
1579 v_warning_with_file_and_line (file
, line
, s
, ap
)
1585 if (count_error (1))
1587 report_error_function (file
);
1588 v_message_with_file_and_line (file
, line
, "warning", s
, ap
);
1593 warning_with_file_and_line
VPROTO((char *file
, int line
, char *s
, ...))
1605 file
= va_arg (ap
, char *);
1606 line
= va_arg (ap
, int);
1607 s
= va_arg (ap
, char *);
1610 v_warning_with_file_and_line (file
, line
, s
, ap
);
1614 /* Report a warning at the declaration DECL.
1615 S is a format string which uses %s to substitute the declaration
1616 name; subsequent substitutions are a la printf. */
1619 v_warning_with_decl (decl
, s
, ap
)
1624 if (count_error (1))
1626 report_error_function (DECL_SOURCE_FILE (decl
));
1627 v_message_with_decl (decl
, "warning", s
, ap
);
1632 warning_with_decl
VPROTO((tree decl
, char *s
, ...))
1643 decl
= va_arg (ap
, tree
);
1644 s
= va_arg (ap
, char *);
1647 v_warning_with_decl (decl
, s
, ap
);
1651 /* Report a warning at the line number of the insn INSN.
1652 This is used only when INSN is an `asm' with operands,
1653 and each ASM_OPERANDS records its own source file and line. */
1656 v_warning_for_asm (insn
, s
, ap
)
1661 if (count_error (1))
1666 file_and_line_for_asm (insn
, &file
, &line
);
1667 report_error_function (file
);
1668 v_message_with_file_and_line (file
, line
, "warning", s
, ap
);
1673 warning_for_asm
VPROTO((rtx insn
, char *s
, ...))
1684 insn
= va_arg (ap
, rtx
);
1685 s
= va_arg (ap
, char *);
1688 v_warning_for_asm (insn
, s
, ap
);
1692 /* Report a warning at the current line number. */
1699 v_warning_with_file_and_line (input_filename
, lineno
, s
, ap
);
1703 warning
VPROTO((char *s
, ...))
1713 s
= va_arg (ap
, char *);
1720 /* These functions issue either warnings or errors depending on
1721 -pedantic-errors. */
1728 if (flag_pedantic_errors
)
1735 pedwarn
VPROTO((char *s
, ...))
1745 s
= va_arg (ap
, char *);
1753 v_pedwarn_with_decl (decl
, s
, ap
)
1758 /* We don't want -pedantic-errors to cause the compilation to fail from
1759 "errors" in system header files. Sometimes fixincludes can't fix what's
1760 broken (eg: unsigned char bitfields - fixing it may change the alignment
1761 which will cause programs to mysteriously fail because the C library
1762 or kernel uses the original layout). There's no point in issuing a
1763 warning either, it's just unnecessary noise. */
1765 if (! DECL_IN_SYSTEM_HEADER (decl
))
1767 if (flag_pedantic_errors
)
1768 v_error_with_decl (decl
, s
, ap
);
1770 v_warning_with_decl (decl
, s
, ap
);
1775 pedwarn_with_decl
VPROTO((tree decl
, char *s
, ...))
1786 decl
= va_arg (ap
, tree
);
1787 s
= va_arg (ap
, char *);
1790 v_pedwarn_with_decl (decl
, s
, ap
);
1795 v_pedwarn_with_file_and_line (file
, line
, s
, ap
)
1801 if (flag_pedantic_errors
)
1802 v_error_with_file_and_line (file
, line
, s
, ap
);
1804 v_warning_with_file_and_line (file
, line
, s
, ap
);
1808 pedwarn_with_file_and_line
VPROTO((char *file
, int line
, char *s
, ...))
1820 file
= va_arg (ap
, char *);
1821 line
= va_arg (ap
, int);
1822 s
= va_arg (ap
, char *);
1825 v_pedwarn_with_file_and_line (file
, line
, s
, ap
);
1829 /* Apologize for not implementing some feature. */
1838 fprintf (stderr
, "%s:%d: ", input_filename
, lineno
);
1840 fprintf (stderr
, "%s: ", progname
);
1841 vmessage ("sorry, not implemented", s
, ap
);
1842 fputc ('\n', stderr
);
1846 sorry
VPROTO((char *s
, ...))
1856 s
= va_arg (ap
, char *);
1863 /* Apologize for not implementing some feature, then quit. */
1866 v_really_sorry (s
, ap
)
1872 fprintf (stderr
, "%s:%d: ", input_filename
, lineno
);
1874 fprintf (stderr
, "%s: ", progname
);
1875 vmessage ("sorry, not implemented", s
, ap
);
1876 fatal (" (fatal)\n");
1880 really_sorry
VPROTO((char *s
, ...))
1890 s
= va_arg (ap
, char *);
1893 v_really_sorry (s
, ap
);
1897 /* More 'friendly' abort that prints the line and file.
1898 config.h can #define abort fancy_abort if you like that sort of thing.
1900 I don't think this is actually a good idea.
1901 Other sorts of crashes will look a certain way.
1902 It is a good thing if crashes from calling abort look the same way.
1908 fatal ("internal gcc abort");
1911 /* This calls abort and is used to avoid problems when abort if a macro.
1912 It is used when we need to pass the address of abort. */
1920 /* When `malloc.c' is compiled with `rcheck' defined,
1921 it calls this function to report clobberage. */
1929 /* Same as `malloc' but report error if no memory available. */
1935 register char *value
= (char *) malloc (size
);
1936 if (value
== 0 && size
!= 0)
1937 fatal ("virtual memory exhausted");
1941 /* Same as `realloc' but report error if no memory available.
1942 Also handle null PTR even if the vendor realloc gets it wrong. */
1945 xrealloc (ptr
, size
)
1950 ? (char *) realloc (ptr
, size
)
1951 : (char *) malloc (size
));
1953 fatal ("virtual memory exhausted");
1957 /* Same as `strdup' but report error if no memory available. */
1963 register char *result
= (char *) malloc (strlen (s
) + 1);
1966 fatal ("virtual memory exhausted");
1971 /* Return the logarithm of X, base 2, considering X unsigned,
1972 if X is a power of 2. Otherwise, returns -1.
1974 This should be used via the `exact_log2' macro. */
1978 register unsigned HOST_WIDE_INT x
;
1980 register int log
= 0;
1981 /* Test for 0 or a power of 2. */
1982 if (x
== 0 || x
!= (x
& -x
))
1984 while ((x
>>= 1) != 0)
1989 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1990 If X is 0, return -1.
1992 This should be used via the floor_log2 macro. */
1996 register unsigned HOST_WIDE_INT x
;
1998 register int log
= -1;
2005 static int float_handler_set
;
2007 jmp_buf float_handler
;
2009 /* Signals actually come here. */
2012 float_signal (signo
)
2013 /* If this is missing, some compilers complain. */
2016 if (float_handled
== 0)
2018 #if defined (USG) || defined (hpux)
2019 signal (SIGFPE
, float_signal
); /* re-enable the signal catcher */
2022 signal (SIGFPE
, float_signal
);
2023 longjmp (float_handler
, 1);
2026 /* Specify where to longjmp to when a floating arithmetic error happens.
2027 If HANDLER is 0, it means don't handle the errors any more. */
2030 set_float_handler (handler
)
2033 float_handled
= (handler
!= 0);
2035 bcopy ((char *) handler
, (char *) float_handler
, sizeof (float_handler
));
2037 if (float_handled
&& ! float_handler_set
)
2039 signal (SIGFPE
, float_signal
);
2040 float_handler_set
= 1;
2044 /* Specify, in HANDLER, where to longjmp to when a floating arithmetic
2045 error happens, pushing the previous specification into OLD_HANDLER.
2046 Return an indication of whether there was a previous handler in effect. */
2049 push_float_handler (handler
, old_handler
)
2050 jmp_buf handler
, old_handler
;
2052 int was_handled
= float_handled
;
2056 bcopy ((char *) float_handler
, (char *) old_handler
,
2057 sizeof (float_handler
));
2059 bcopy ((char *) handler
, (char *) float_handler
, sizeof (float_handler
));
2063 /* Restore the previous specification of whether and where to longjmp to
2064 when a floating arithmetic error happens. */
2067 pop_float_handler (handled
, handler
)
2071 float_handled
= handled
;
2073 bcopy ((char *) handler
, (char *) float_handler
, sizeof (float_handler
));
2076 /* Handler for SIGPIPE. */
2080 /* If this is missing, some compilers complain. */
2083 fatal ("output pipe has been closed");
2086 /* Strip off a legitimate source ending from the input string NAME of
2087 length LEN. Rather than having to know the names used by all of
2088 our front ends, we strip off an ending of a period followed by one,
2089 two, or three characters. */
2092 strip_off_ending (name
, len
)
2096 if (len
> 2 && name
[len
- 2] == '.')
2097 name
[len
- 2] = '\0';
2098 else if (len
> 3 && name
[len
- 3] == '.')
2099 name
[len
- 3] = '\0';
2100 else if (len
> 4 && name
[len
- 4] == '.')
2101 name
[len
- 4] = '\0';
2104 /* Output a quoted string. */
2107 output_quoted_string (asm_file
, string
)
2111 #ifdef OUTPUT_QUOTED_STRING
2112 OUTPUT_QUOTED_STRING (asm_file
, string
);
2116 putc ('\"', asm_file
);
2117 while ((c
= *string
++) != 0)
2119 if (c
== '\"' || c
== '\\')
2120 putc ('\\', asm_file
);
2123 putc ('\"', asm_file
);
2127 /* Output a file name in the form wanted by System V. */
2130 output_file_directive (asm_file
, input_name
)
2134 int len
= strlen (input_name
);
2135 char *na
= input_name
+ len
;
2137 /* NA gets INPUT_NAME sans directory names. */
2138 while (na
> input_name
)
2145 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
2146 ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file
, na
);
2148 #ifdef ASM_OUTPUT_SOURCE_FILENAME
2149 ASM_OUTPUT_SOURCE_FILENAME (asm_file
, na
);
2151 fprintf (asm_file
, "\t.file\t");
2152 output_quoted_string (asm_file
, na
);
2153 fputc ('\n', asm_file
);
2158 /* Routine to build language identifier for object file. */
2161 output_lang_identify (asm_out_file
)
2164 int len
= strlen (lang_identify ()) + sizeof ("__gnu_compiled_") + 1;
2165 char *s
= (char *) alloca (len
);
2166 sprintf (s
, "__gnu_compiled_%s", lang_identify ());
2167 ASM_OUTPUT_LABEL (asm_out_file
, s
);
2170 /* Routine to open a dump file. */
2173 open_dump_file (base_name
, suffix
)
2178 char *dumpname
= (char *) alloca (strlen (base_name
) + strlen (suffix
) + 1);
2180 strcpy (dumpname
, base_name
);
2181 strcat (dumpname
, suffix
);
2182 f
= fopen (dumpname
, "w");
2184 pfatal_with_name (dumpname
);
2188 /* Compile an entire file of output from cpp, named NAME.
2189 Write a file of assembly output and various debugging dumps. */
2198 int name_specified
= name
!= 0;
2200 if (dump_base_name
== 0)
2201 dump_base_name
= name
? name
: "gccdump";
2205 integration_time
= 0;
2210 branch_prob_time
= 0;
2215 local_alloc_time
= 0;
2216 global_alloc_time
= 0;
2219 shorten_branch_time
= 0;
2226 /* Open input file. */
2228 if (name
== 0 || !strcmp (name
, "-"))
2234 finput
= fopen (name
, "r");
2236 pfatal_with_name (name
);
2238 #ifdef IO_BUFFER_SIZE
2239 setvbuf (finput
, (char *) xmalloc (IO_BUFFER_SIZE
), _IOFBF
, IO_BUFFER_SIZE
);
2241 #endif /* !USE_CPPLIB */
2243 /* Initialize data in various passes. */
2252 /* Some of these really don't need to be called when generating bytecode,
2253 but the options would have to be parsed first to know that. -bson */
2255 init_emit_once (debug_info_level
== DINFO_LEVEL_NORMAL
2256 || debug_info_level
== DINFO_LEVEL_VERBOSE
2257 || flag_test_coverage
);
2259 init_decl_processing ();
2267 if (flag_caller_saves
)
2268 init_caller_save ();
2270 /* If auxiliary info generation is desired, open the output file.
2271 This goes in the same directory as the source file--unlike
2272 all the other output files. */
2273 if (flag_gen_aux_info
)
2275 aux_info_file
= fopen (aux_info_file_name
, "w");
2276 if (aux_info_file
== 0)
2277 pfatal_with_name (aux_info_file_name
);
2280 /* If rtl dump desired, open the output file. */
2282 rtl_dump_file
= open_dump_file (dump_base_name
, ".rtl");
2284 /* If jump_opt dump desired, open the output file. */
2286 jump_opt_dump_file
= open_dump_file (dump_base_name
, ".jump");
2288 /* If addressof dump desired, open the output file. */
2290 addressof_dump_file
= open_dump_file (dump_base_name
, ".addressof");
2292 /* If cse dump desired, open the output file. */
2294 cse_dump_file
= open_dump_file (dump_base_name
, ".cse");
2296 /* If loop dump desired, open the output file. */
2298 loop_dump_file
= open_dump_file (dump_base_name
, ".loop");
2300 /* If cse2 dump desired, open the output file. */
2302 cse2_dump_file
= open_dump_file (dump_base_name
, ".cse2");
2304 /* If branch_prob dump desired, open the output file. */
2305 if (branch_prob_dump
)
2306 branch_prob_dump_file
= open_dump_file (dump_base_name
, ".bp");
2308 /* If flow dump desired, open the output file. */
2310 flow_dump_file
= open_dump_file (dump_base_name
, ".flow");
2312 /* If combine dump desired, open the output file. */
2314 combine_dump_file
= open_dump_file (dump_base_name
, ".combine");
2316 /* If regmove dump desired, open the output file. */
2318 regmove_dump_file
= open_dump_file (dump_base_name
, ".regmove");
2320 /* If scheduling dump desired, open the output file. */
2322 sched_dump_file
= open_dump_file (dump_base_name
, ".sched");
2324 /* If local_reg dump desired, open the output file. */
2326 local_reg_dump_file
= open_dump_file (dump_base_name
, ".lreg");
2328 /* If global_reg dump desired, open the output file. */
2329 if (global_reg_dump
)
2330 global_reg_dump_file
= open_dump_file (dump_base_name
, ".greg");
2332 /* If 2nd scheduling dump desired, open the output file. */
2334 sched2_dump_file
= open_dump_file (dump_base_name
, ".sched2");
2336 /* If jump2_opt dump desired, open the output file. */
2338 jump2_opt_dump_file
= open_dump_file (dump_base_name
, ".jump2");
2340 /* If dbr_sched dump desired, open the output file. */
2342 dbr_sched_dump_file
= open_dump_file (dump_base_name
, ".dbr");
2346 /* If stack_reg dump desired, open the output file. */
2348 stack_reg_dump_file
= open_dump_file (dump_base_name
, ".stack");
2352 /* Open assembler code output file. */
2354 if (! name_specified
&& asm_file_name
== 0)
2355 asm_out_file
= stdout
;
2358 int len
= strlen (dump_base_name
);
2359 register char *dumpname
= (char *) xmalloc (len
+ 6);
2360 strcpy (dumpname
, dump_base_name
);
2361 strip_off_ending (dumpname
, len
);
2362 strcat (dumpname
, ".s");
2363 if (asm_file_name
== 0)
2365 asm_file_name
= (char *) xmalloc (strlen (dumpname
) + 1);
2366 strcpy (asm_file_name
, dumpname
);
2368 if (!strcmp (asm_file_name
, "-"))
2369 asm_out_file
= stdout
;
2371 asm_out_file
= fopen (asm_file_name
, "w");
2372 if (asm_out_file
== 0)
2373 pfatal_with_name (asm_file_name
);
2376 #ifdef IO_BUFFER_SIZE
2377 setvbuf (asm_out_file
, (char *) xmalloc (IO_BUFFER_SIZE
),
2378 _IOFBF
, IO_BUFFER_SIZE
);
2381 input_filename
= name
;
2383 /* Put an entry on the input file stack for the main input file. */
2385 = (struct file_stack
*) xmalloc (sizeof (struct file_stack
));
2386 input_file_stack
->next
= 0;
2387 input_file_stack
->name
= input_filename
;
2389 /* Gross. Gross. lang_init is (I think) the first callback into
2390 the language front end, and is thus the first opportunity to
2391 have the selected language override the default value for any
2394 So the default value for flag_exceptions is 2 (uninitialized).
2395 If we encounter -fno-exceptions or -fexceptions, then flag_exceptions
2396 will be set to zero or one respectively.
2398 flag_exceptions can also be set by lang_init to something other
2399 than the default "uninitialized" value of 2.
2401 After lang_init, if the value is still 2, then we default to
2402 -fno-exceptions (value will be reset to zero).
2404 When our EH mechanism is low enough overhead that we can enable
2405 it by default for languages other than C++, then all this braindamage
2408 /* Perform language-specific initialization.
2409 This may set main_input_filename. */
2412 if (flag_exceptions
== 2)
2413 flag_exceptions
= 0;
2415 /* If the input doesn't start with a #line, use the input name
2416 as the official input file name. */
2417 if (main_input_filename
== 0)
2418 main_input_filename
= name
;
2420 if (!output_bytecode
)
2422 ASM_FILE_START (asm_out_file
);
2424 #ifdef ASM_COMMENT_START
2425 if (flag_verbose_asm
)
2427 /* Print the list of options in effect. */
2428 print_version (asm_out_file
, ASM_COMMENT_START
);
2429 print_switch_values (asm_out_file
, 0, MAX_LINE
,
2430 ASM_COMMENT_START
, " ", "\n");
2431 /* Add a blank line here so it appears in assembler output but not
2433 fprintf (asm_out_file
, "\n");
2438 /* Output something to inform GDB that this compilation was by GCC. Also
2439 serves to tell GDB file consists of bytecodes. */
2440 if (output_bytecode
)
2441 fprintf (asm_out_file
, "bc_gcc2_compiled.:\n");
2444 #ifndef ASM_IDENTIFY_GCC
2445 fprintf (asm_out_file
, "gcc2_compiled.:\n");
2447 ASM_IDENTIFY_GCC (asm_out_file
);
2451 /* Output something to identify which front-end produced this file. */
2452 #ifdef ASM_IDENTIFY_LANGUAGE
2453 ASM_IDENTIFY_LANGUAGE (asm_out_file
);
2456 #ifndef ASM_OUTPUT_SECTION_NAME
2457 if (flag_function_sections
)
2459 warning ("-ffunction-sections not supported for this target.");
2460 flag_function_sections
= 0;
2464 if (flag_function_sections
2465 && (profile_flag
|| profile_block_flag
))
2467 warning ("-ffunction-sections disabled; it makes profiling impossible.");
2468 flag_function_sections
= 0;
2471 if (flag_function_sections
&& write_symbols
!= NO_DEBUG
)
2472 warning ("-ffunction-sections may affect debugging on some targets.");
2474 if (output_bytecode
)
2476 if (profile_flag
|| profile_block_flag
)
2477 error ("profiling not supported in bytecode compilation");
2481 /* ??? Note: There used to be a conditional here
2482 to call assemble_zeros without fail if DBX_DEBUGGING_INFO is defined.
2483 This was to guarantee separation between gcc_compiled. and
2484 the first function, for the sake of dbx on Suns.
2485 However, having the extra zero here confused the Emacs
2486 code for unexec, and might confuse other programs too.
2487 Therefore, I took out that change.
2488 In future versions we should find another way to solve
2489 that dbx problem. -- rms, 23 May 93. */
2491 /* Don't let the first function fall at the same address
2492 as gcc_compiled., if profiling. */
2493 if (profile_flag
|| profile_block_flag
)
2494 assemble_zeros (UNITS_PER_WORD
);
2497 /* If dbx symbol table desired, initialize writing it
2498 and output the predefined types. */
2499 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2500 if (write_symbols
== DBX_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
2501 TIMEVAR (symout_time
, dbxout_init (asm_out_file
, main_input_filename
,
2504 #ifdef SDB_DEBUGGING_INFO
2505 if (write_symbols
== SDB_DEBUG
)
2506 TIMEVAR (symout_time
, sdbout_init (asm_out_file
, main_input_filename
,
2509 #ifdef DWARF_DEBUGGING_INFO
2510 if (write_symbols
== DWARF_DEBUG
)
2511 TIMEVAR (symout_time
, dwarfout_init (asm_out_file
, main_input_filename
));
2513 #ifdef DWARF2_UNWIND_INFO
2514 if (dwarf2out_do_frame ())
2515 dwarf2out_frame_init ();
2517 #ifdef DWARF2_DEBUGGING_INFO
2518 if (write_symbols
== DWARF2_DEBUG
)
2519 TIMEVAR (symout_time
, dwarf2out_init (asm_out_file
, main_input_filename
));
2522 /* Initialize yet another pass. */
2524 if (!output_bytecode
)
2525 init_final (main_input_filename
);
2526 init_branch_prob (dump_base_name
);
2528 start_time
= get_run_time ();
2530 /* Call the parser, which parses the entire file
2531 (calling rest_of_compilation for each function). */
2533 if (yyparse () != 0)
2535 if (errorcount
== 0)
2536 fprintf (stderr
, "Errors detected in input file (your bison.simple is out of date)");
2538 /* In case there were missing closebraces,
2539 get us back to the global binding level. */
2540 while (! global_bindings_p ())
2544 output_func_start_profiler ();
2546 /* Compilation is now finished except for writing
2547 what's left of the symbol table output. */
2549 parse_time
+= get_run_time () - start_time
;
2551 parse_time
-= integration_time
;
2552 parse_time
-= varconst_time
;
2554 globals
= getdecls ();
2556 /* Really define vars that have had only a tentative definition.
2557 Really output inline functions that must actually be callable
2558 and have not been output so far. */
2561 int len
= list_length (globals
);
2562 tree
*vec
= (tree
*) alloca (sizeof (tree
) * len
);
2567 /* Process the decls in reverse order--earliest first.
2568 Put them into VEC from back to front, then take out from front. */
2570 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
2571 vec
[len
- i
- 1] = decl
;
2573 for (i
= 0; i
< len
; i
++)
2577 /* We're not deferring this any longer. */
2578 DECL_DEFER_OUTPUT (decl
) = 0;
2580 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_SIZE (decl
) == 0
2581 && incomplete_decl_finalize_hook
!= 0)
2582 (*incomplete_decl_finalize_hook
) (decl
);
2585 /* Now emit any global variables or functions that we have been putting
2586 off. We need to loop in case one of the things emitted here
2587 references another one which comes earlier in the list. */
2591 for (i
= 0; i
< len
; i
++)
2595 if (TREE_ASM_WRITTEN (decl
) || DECL_EXTERNAL (decl
))
2598 /* Don't write out static consts, unless we still need them.
2600 We also keep static consts if not optimizing (for debugging),
2601 unless the user specified -fno-keep-static-consts.
2602 ??? They might be better written into the debug information.
2603 This is possible when using DWARF.
2605 A language processor that wants static constants to be always
2606 written out (even if it is not used) is responsible for
2607 calling rest_of_decl_compilation itself. E.g. the C front-end
2608 calls rest_of_decl_compilation from finish_decl.
2609 One motivation for this is that is conventional in some
2610 environments to write things like:
2611 static const char rcsid[] = "... version string ...";
2612 intending to force the string to be in the executable.
2614 A language processor that would prefer to have unneeded
2615 static constants "optimized away" would just defer writing
2616 them out until here. E.g. C++ does this, because static
2617 constants are often defined in header files.
2619 ??? A tempting alternative (for both C and C++) would be
2620 to force a constant to be written if and only if it is
2621 defined in a main file, as opposed to an include file. */
2623 if (TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
)
2624 && (! TREE_READONLY (decl
)
2625 || TREE_PUBLIC (decl
)
2626 || (!optimize
&& flag_keep_static_consts
)
2627 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))))
2630 rest_of_decl_compilation (decl
, NULL_PTR
, 1, 1);
2633 if (TREE_CODE (decl
) == FUNCTION_DECL
2634 && DECL_INITIAL (decl
) != 0
2635 && DECL_SAVED_INSNS (decl
) != 0
2636 && (flag_keep_inline_functions
2637 || TREE_PUBLIC (decl
)
2638 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))))
2641 temporary_allocation ();
2642 output_inline_function (decl
);
2643 permanent_allocation (1);
2648 /* Now that all possible functions have been output, we can dump
2649 the exception table. */
2651 output_exception_table ();
2653 for (i
= 0; i
< len
; i
++)
2657 if (TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
)
2658 && ! TREE_ASM_WRITTEN (decl
))
2659 /* Cancel the RTL for this decl so that, if debugging info
2660 output for global variables is still to come,
2661 this one will be omitted. */
2662 DECL_RTL (decl
) = NULL
;
2664 /* Warn about any function
2665 declared static but not defined.
2666 We don't warn about variables,
2667 because many programs have static variables
2668 that exist only to get some text into the object file. */
2669 if (TREE_CODE (decl
) == FUNCTION_DECL
2671 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
2672 && DECL_INITIAL (decl
) == 0
2673 && DECL_EXTERNAL (decl
)
2674 && ! DECL_ARTIFICIAL (decl
)
2675 && ! TREE_PUBLIC (decl
))
2677 pedwarn_with_decl (decl
,
2678 "`%s' declared `static' but never defined");
2679 /* This symbol is effectively an "extern" declaration now. */
2680 TREE_PUBLIC (decl
) = 1;
2681 assemble_external (decl
);
2684 /* Warn about static fns or vars defined but not used,
2685 but not about inline functions or static consts
2686 since defining those in header files is normal practice. */
2688 && ((TREE_CODE (decl
) == FUNCTION_DECL
&& ! DECL_INLINE (decl
))
2689 || (TREE_CODE (decl
) == VAR_DECL
&& ! TREE_READONLY (decl
)))
2690 && ! DECL_IN_SYSTEM_HEADER (decl
)
2691 && ! DECL_EXTERNAL (decl
)
2692 && ! TREE_PUBLIC (decl
)
2693 && ! TREE_USED (decl
)
2694 && (TREE_CODE (decl
) == FUNCTION_DECL
|| ! DECL_REGISTER (decl
))
2695 /* The TREE_USED bit for file-scope decls
2696 is kept in the identifier, to handle multiple
2697 external decls in different scopes. */
2698 && ! TREE_USED (DECL_NAME (decl
)))
2699 warning_with_decl (decl
, "`%s' defined but not used");
2701 #ifdef SDB_DEBUGGING_INFO
2702 /* The COFF linker can move initialized global vars to the end.
2703 And that can screw up the symbol ordering.
2704 By putting the symbols in that order to begin with,
2705 we avoid a problem. mcsun!unido!fauern!tumuc!pes@uunet.uu.net. */
2706 if (write_symbols
== SDB_DEBUG
&& TREE_CODE (decl
) == VAR_DECL
2707 && TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)
2708 && ! DECL_EXTERNAL (decl
)
2709 && DECL_RTL (decl
) != 0)
2710 TIMEVAR (symout_time
, sdbout_symbol (decl
, 0));
2712 /* Output COFF information for non-global
2713 file-scope initialized variables. */
2714 if (write_symbols
== SDB_DEBUG
2715 && TREE_CODE (decl
) == VAR_DECL
2716 && DECL_INITIAL (decl
)
2717 && ! DECL_EXTERNAL (decl
)
2718 && DECL_RTL (decl
) != 0
2719 && GET_CODE (DECL_RTL (decl
)) == MEM
)
2720 TIMEVAR (symout_time
, sdbout_toplevel_data (decl
));
2721 #endif /* SDB_DEBUGGING_INFO */
2722 #ifdef DWARF_DEBUGGING_INFO
2723 /* Output DWARF information for file-scope tentative data object
2724 declarations, file-scope (extern) function declarations (which
2725 had no corresponding body) and file-scope tagged type declarations
2726 and definitions which have not yet been forced out. */
2728 if (write_symbols
== DWARF_DEBUG
2729 && (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
)))
2730 TIMEVAR (symout_time
, dwarfout_file_scope_decl (decl
, 1));
2732 #ifdef DWARF2_DEBUGGING_INFO
2733 /* Output DWARF2 information for file-scope tentative data object
2734 declarations, file-scope (extern) function declarations (which
2735 had no corresponding body) and file-scope tagged type declarations
2736 and definitions which have not yet been forced out. */
2738 if (write_symbols
== DWARF2_DEBUG
2739 && (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
)))
2740 TIMEVAR (symout_time
, dwarf2out_decl (decl
));
2745 /* Write out any pending weak symbol declarations. */
2749 /* Do dbx symbols */
2750 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2751 if (write_symbols
== DBX_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
2752 TIMEVAR (symout_time
,
2754 dbxout_finish (asm_out_file
, main_input_filename
);
2758 #ifdef DWARF_DEBUGGING_INFO
2759 if (write_symbols
== DWARF_DEBUG
)
2760 TIMEVAR (symout_time
,
2766 #ifdef DWARF2_UNWIND_INFO
2767 if (dwarf2out_do_frame ())
2768 dwarf2out_frame_finish ();
2771 #ifdef DWARF2_DEBUGGING_INFO
2772 if (write_symbols
== DWARF2_DEBUG
)
2773 TIMEVAR (symout_time
,
2775 dwarf2out_finish ();
2779 /* Output some stuff at end of file if nec. */
2781 if (!output_bytecode
)
2783 end_final (dump_base_name
);
2784 end_branch_prob (branch_prob_dump_file
);
2787 ASM_FILE_END (asm_out_file
);
2791 /* Language-specific end of compilation actions. */
2795 if (output_bytecode
)
2796 bc_write_file (asm_out_file
);
2798 /* Close the dump files. */
2800 if (flag_gen_aux_info
)
2802 fclose (aux_info_file
);
2804 unlink (aux_info_file_name
);
2808 fclose (rtl_dump_file
);
2811 fclose (jump_opt_dump_file
);
2814 fclose (addressof_dump_file
);
2817 fclose (cse_dump_file
);
2820 fclose (loop_dump_file
);
2823 fclose (cse2_dump_file
);
2825 if (branch_prob_dump
)
2826 fclose (branch_prob_dump_file
);
2829 fclose (flow_dump_file
);
2833 dump_combine_total_stats (combine_dump_file
);
2834 fclose (combine_dump_file
);
2838 fclose (regmove_dump_file
);
2841 fclose (sched_dump_file
);
2844 fclose (local_reg_dump_file
);
2846 if (global_reg_dump
)
2847 fclose (global_reg_dump_file
);
2850 fclose (sched2_dump_file
);
2853 fclose (jump2_opt_dump_file
);
2856 fclose (dbr_sched_dump_file
);
2860 fclose (stack_reg_dump_file
);
2863 /* Close non-debugging input and output files. Take special care to note
2864 whether fclose returns an error, since the pages might still be on the
2865 buffer chain while the file is open. */
2872 if (ferror (asm_out_file
) != 0 || fclose (asm_out_file
) != 0)
2873 fatal_io_error (asm_file_name
);
2875 /* Print the times. */
2879 fprintf (stderr
,"\n");
2880 print_time ("parse", parse_time
);
2882 if (!output_bytecode
)
2884 print_time ("integration", integration_time
);
2885 print_time ("jump", jump_time
);
2886 print_time ("cse", cse_time
);
2887 print_time ("loop", loop_time
);
2888 print_time ("cse2", cse2_time
);
2889 print_time ("branch-prob", branch_prob_time
);
2890 print_time ("flow", flow_time
);
2891 print_time ("combine", combine_time
);
2892 print_time ("regmove", regmove_time
);
2893 print_time ("sched", sched_time
);
2894 print_time ("local-alloc", local_alloc_time
);
2895 print_time ("global-alloc", global_alloc_time
);
2896 print_time ("sched2", sched2_time
);
2897 print_time ("dbranch", dbr_sched_time
);
2898 print_time ("shorten-branch", shorten_branch_time
);
2899 print_time ("stack-reg", stack_reg_time
);
2900 print_time ("final", final_time
);
2901 print_time ("varconst", varconst_time
);
2902 print_time ("symout", symout_time
);
2903 print_time ("dump", dump_time
);
2908 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
2909 and TYPE_DECL nodes.
2911 This does nothing for local (non-static) variables.
2912 Otherwise, it sets up the RTL and outputs any assembler code
2913 (label definition, storage allocation and initialization).
2915 DECL is the declaration. If ASMSPEC is nonzero, it specifies
2916 the assembler symbol name to be used. TOP_LEVEL is nonzero
2917 if this declaration is not within a function. */
2920 rest_of_decl_compilation (decl
, asmspec
, top_level
, at_end
)
2926 /* Declarations of variables, and of functions defined elsewhere. */
2928 /* The most obvious approach, to put an #ifndef around where
2929 this macro is used, doesn't work since it's inside a macro call. */
2930 #ifndef ASM_FINISH_DECLARE_OBJECT
2931 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP, END)
2934 /* Forward declarations for nested functions are not "external",
2935 but we need to treat them as if they were. */
2936 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)
2937 || TREE_CODE (decl
) == FUNCTION_DECL
)
2938 TIMEVAR (varconst_time
,
2940 make_decl_rtl (decl
, asmspec
, top_level
);
2941 /* Initialized extern variable exists to be replaced
2942 with its value, or represents something that will be
2943 output in another file. */
2944 if (! (TREE_CODE (decl
) == VAR_DECL
2945 && DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
2946 && DECL_INITIAL (decl
) != 0
2947 && DECL_INITIAL (decl
) != error_mark_node
))
2948 /* Don't output anything
2949 when a tentative file-scope definition is seen.
2950 But at end of compilation, do output code for them. */
2951 if (! (! at_end
&& top_level
2952 && (DECL_INITIAL (decl
) == 0
2953 || DECL_INITIAL (decl
) == error_mark_node
)))
2954 assemble_variable (decl
, top_level
, at_end
, 0);
2955 if (!output_bytecode
2956 && decl
== last_assemble_variable_decl
)
2958 ASM_FINISH_DECLARE_OBJECT (asm_out_file
, decl
,
2962 else if (DECL_REGISTER (decl
) && asmspec
!= 0)
2964 if (decode_reg_name (asmspec
) >= 0)
2966 DECL_RTL (decl
) = 0;
2967 make_decl_rtl (decl
, asmspec
, top_level
);
2970 error ("invalid register name `%s' for register variable", asmspec
);
2972 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2973 else if ((write_symbols
== DBX_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
2974 && TREE_CODE (decl
) == TYPE_DECL
)
2975 TIMEVAR (symout_time
, dbxout_symbol (decl
, 0));
2977 #ifdef SDB_DEBUGGING_INFO
2978 else if (write_symbols
== SDB_DEBUG
&& top_level
2979 && TREE_CODE (decl
) == TYPE_DECL
)
2980 TIMEVAR (symout_time
, sdbout_symbol (decl
, 0));
2984 /* Called after finishing a record, union or enumeral type. */
2987 rest_of_type_compilation (type
, toplev
)
2991 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2992 if (write_symbols
== DBX_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
2993 TIMEVAR (symout_time
, dbxout_symbol (TYPE_STUB_DECL (type
), !toplev
));
2995 #ifdef SDB_DEBUGGING_INFO
2996 if (write_symbols
== SDB_DEBUG
)
2997 TIMEVAR (symout_time
, sdbout_symbol (TYPE_STUB_DECL (type
), !toplev
));
3001 /* This is called from finish_function (within yyparse)
3002 after each top-level definition is parsed.
3003 It is supposed to compile that function or variable
3004 and output the assembler code for it.
3005 After we return, the tree storage is freed. */
3008 rest_of_compilation (decl
)
3012 int start_time
= get_run_time ();
3014 /* Nonzero if we have saved the original DECL_INITIAL of the function,
3015 to be restored after we finish compiling the function
3016 (for use when compiling inline calls to this function). */
3017 tree saved_block_tree
= 0;
3018 /* Likewise, for DECL_ARGUMENTS. */
3019 tree saved_arguments
= 0;
3022 if (output_bytecode
)
3025 /* If we are reconsidering an inline function
3026 at the end of compilation, skip the stuff for making it inline. */
3028 if (DECL_SAVED_INSNS (decl
) == 0)
3033 /* If requested, consider whether to make this function inline. */
3034 if (DECL_INLINE (decl
) || flag_inline_functions
)
3035 TIMEVAR (integration_time
,
3037 lose
= function_cannot_inline_p (decl
);
3038 if (lose
|| ! optimize
)
3040 if (warn_inline
&& DECL_INLINE (decl
))
3041 warning_with_decl (decl
, lose
);
3042 DECL_ABSTRACT_ORIGIN (decl
) = 0;
3043 /* Don't really compile an extern inline function.
3044 If we can't make it inline, pretend
3045 it was only declared. */
3046 if (DECL_EXTERNAL (decl
))
3048 DECL_INITIAL (decl
) = 0;
3049 goto exit_rest_of_compilation
;
3053 /* ??? Note that this has the effect of making it look
3054 like "inline" was specified for a function if we choose
3055 to inline it. This isn't quite right, but it's
3056 probably not worth the trouble to fix. */
3057 inlineable
= DECL_INLINE (decl
) = 1;
3060 insns
= get_insns ();
3062 /* Dump the rtl code if we are dumping rtl. */
3067 fprintf (rtl_dump_file
, "\n;; Function %s\n\n",
3068 (*decl_printable_name
) (decl
, 2));
3069 if (DECL_SAVED_INSNS (decl
))
3070 fprintf (rtl_dump_file
, ";; (integrable)\n\n");
3071 print_rtl (rtl_dump_file
, insns
);
3072 fflush (rtl_dump_file
);
3075 /* If we can, defer compiling inlines until EOF.
3076 save_for_inline_copying can be extremely expensive. */
3077 if (inlineable
&& ! decl_function_context (decl
))
3078 DECL_DEFER_OUTPUT (decl
) = 1;
3080 /* If function is inline, and we don't yet know whether to
3081 compile it by itself, defer decision till end of compilation.
3082 finish_compilation will call rest_of_compilation again
3083 for those functions that need to be output. Also defer those
3084 functions that we are supposed to defer. We cannot defer
3085 functions containing nested functions since the nested function
3086 data is in our non-saved obstack. */
3088 /* If this is a nested inline, remove ADDRESSOF now so we can
3089 finish compiling ourselves. Otherwise, wait until EOF.
3090 We have to do this because the purge_addressof transformation
3091 changes the DECL_RTL for many variables, which confuses integrate. */
3094 if (decl_function_context (decl
))
3095 purge_addressof (insns
);
3097 DECL_DEFER_OUTPUT (decl
) = 1;
3100 if (! current_function_contains_functions
3101 && (DECL_DEFER_OUTPUT (decl
)
3102 || (DECL_INLINE (decl
)
3103 && ((! TREE_PUBLIC (decl
) && ! TREE_ADDRESSABLE (decl
)
3104 && ! flag_keep_inline_functions
)
3105 || DECL_EXTERNAL (decl
)))))
3107 DECL_DEFER_OUTPUT (decl
) = 1;
3109 /* If -Wreturn-type, we have to do a bit of compilation. */
3110 if (! warn_return_type
)
3112 #ifdef DWARF_DEBUGGING_INFO
3113 /* Generate the DWARF info for the "abstract" instance
3114 of a function which we may later generate inlined and/or
3115 out-of-line instances of. */
3116 if (write_symbols
== DWARF_DEBUG
)
3118 set_decl_abstract_flags (decl
, 1);
3119 TIMEVAR (symout_time
, dwarfout_file_scope_decl (decl
, 0));
3120 set_decl_abstract_flags (decl
, 0);
3123 #ifdef DWARF2_DEBUGGING_INFO
3124 /* Generate the DWARF2 info for the "abstract" instance
3125 of a function which we may later generate inlined and/or
3126 out-of-line instances of. */
3127 if (write_symbols
== DWARF2_DEBUG
)
3129 set_decl_abstract_flags (decl
, 1);
3130 TIMEVAR (symout_time
, dwarf2out_decl (decl
));
3131 set_decl_abstract_flags (decl
, 0);
3134 TIMEVAR (integration_time
, save_for_inline_nocopy (decl
));
3135 RTX_INTEGRATED_P (DECL_SAVED_INSNS (decl
)) = inlineable
;
3136 goto exit_rest_of_compilation
;
3140 /* If we have to compile the function now, save its rtl and subdecls
3141 so that its compilation will not affect what others get. */
3142 if (inlineable
|| DECL_DEFER_OUTPUT (decl
))
3144 #ifdef DWARF_DEBUGGING_INFO
3145 /* Generate the DWARF info for the "abstract" instance of
3146 a function which we will generate an out-of-line instance
3147 of almost immediately (and which we may also later generate
3148 various inlined instances of). */
3149 if (write_symbols
== DWARF_DEBUG
)
3151 set_decl_abstract_flags (decl
, 1);
3152 TIMEVAR (symout_time
, dwarfout_file_scope_decl (decl
, 0));
3153 set_decl_abstract_flags (decl
, 0);
3156 #ifdef DWARF2_DEBUGGING_INFO
3157 /* Generate the DWARF2 info for the "abstract" instance of
3158 a function which we will generate an out-of-line instance
3159 of almost immediately (and which we may also later generate
3160 various inlined instances of). */
3161 if (write_symbols
== DWARF2_DEBUG
)
3163 set_decl_abstract_flags (decl
, 1);
3164 TIMEVAR (symout_time
, dwarf2out_decl (decl
));
3165 set_decl_abstract_flags (decl
, 0);
3168 saved_block_tree
= DECL_INITIAL (decl
);
3169 saved_arguments
= DECL_ARGUMENTS (decl
);
3170 TIMEVAR (integration_time
, save_for_inline_copying (decl
));
3171 RTX_INTEGRATED_P (DECL_SAVED_INSNS (decl
)) = inlineable
;
3174 /* If specified extern inline but we aren't inlining it, we are
3176 if (DECL_INLINE (decl
) && DECL_EXTERNAL (decl
))
3177 goto exit_rest_of_compilation
;
3180 if (! DECL_DEFER_OUTPUT (decl
))
3181 TREE_ASM_WRITTEN (decl
) = 1;
3183 /* Now that integrate will no longer see our rtl, we need not distinguish
3184 between the return value of this function and the return value of called
3186 rtx_equal_function_value_matters
= 0;
3188 /* Don't return yet if -Wreturn-type; we need to do jump_optimize. */
3189 if ((rtl_dump_and_exit
|| flag_syntax_only
) && !warn_return_type
)
3191 goto exit_rest_of_compilation
;
3194 /* Add an unwinder for exception handling, if needed.
3195 This must be done before we finalize PIC code. */
3199 /* If we are doing position-independent code generation, now
3200 is the time to output special prologues and epilogues.
3201 We do not want to do this earlier, because it just clutters
3202 up inline functions with meaningless insns. */
3207 /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
3208 Note that that may have been done above, in save_for_inline_copying.
3209 The call to resume_temporary_allocation near the end of this function
3210 goes back to the usual state of affairs. This must be done after
3211 we've built up any unwinders for exception handling, and done
3212 the FINALIZE_PIC work, if necessary. */
3214 rtl_in_current_obstack ();
3216 insns
= get_insns ();
3218 /* Copy any shared structure that should not be shared. */
3220 unshare_all_rtl (insns
);
3222 /* Instantiate all virtual registers. */
3224 instantiate_virtual_regs (current_function_decl
, get_insns ());
3226 /* See if we have allocated stack slots that are not directly addressable.
3227 If so, scan all the insns and create explicit address computation
3228 for all references to such slots. */
3229 /* fixup_stack_slots (); */
3231 /* Find all the EH handlers. */
3232 find_exception_handler_labels ();
3234 /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
3235 are initialized and to compute whether control can drop off the end
3237 TIMEVAR (jump_time
, reg_scan (insns
, max_reg_num (), 0));
3238 TIMEVAR (jump_time
, jump_optimize (insns
, 0, 0, 1));
3240 /* Now is when we stop if -fsyntax-only and -Wreturn-type. */
3241 if (rtl_dump_and_exit
|| flag_syntax_only
|| DECL_DEFER_OUTPUT (decl
))
3242 goto exit_rest_of_compilation
;
3244 /* Dump rtl code after jump, if we are doing that. */
3249 fprintf (jump_opt_dump_file
, "\n;; Function %s\n\n",
3250 (*decl_printable_name
) (decl
, 2));
3251 print_rtl (jump_opt_dump_file
, insns
);
3252 fflush (jump_opt_dump_file
);
3255 /* Perform common subexpression elimination.
3256 Nonzero value from `cse_main' means that jumps were simplified
3257 and some code may now be unreachable, so do
3258 jump optimization again. */
3263 fprintf (cse_dump_file
, "\n;; Function %s\n\n",
3264 (*decl_printable_name
) (decl
, 2));
3269 TIMEVAR (cse_time
, reg_scan (insns
, max_reg_num (), 1));
3271 if (flag_thread_jumps
)
3272 /* Hacks by tiemann & kenner. */
3273 TIMEVAR (jump_time
, thread_jumps (insns
, max_reg_num (), 1));
3275 TIMEVAR (cse_time
, tem
= cse_main (insns
, max_reg_num (),
3277 TIMEVAR (cse_time
, delete_dead_from_cse (insns
, max_reg_num ()));
3279 if (tem
|| optimize
> 1)
3280 TIMEVAR (jump_time
, jump_optimize (insns
, 0, 0, 0));
3283 /* Dump rtl code after cse, if we are doing that. */
3288 print_rtl (cse_dump_file
, insns
);
3289 fflush (cse_dump_file
);
3292 purge_addressof (insns
);
3293 reg_scan (insns
, max_reg_num (), 1);
3298 fprintf (addressof_dump_file
, "\n;; Function %s\n\n",
3299 (*decl_printable_name
) (decl
, 2));
3300 print_rtl (addressof_dump_file
, insns
);
3301 fflush (addressof_dump_file
);
3307 fprintf (loop_dump_file
, "\n;; Function %s\n\n",
3308 (*decl_printable_name
) (decl
, 2));
3311 /* Move constant computations out of loops. */
3317 int save_flag_unroll_loops
;
3318 int save_flag_unroll_all_loops
;
3320 if (flag_rerun_loop_opt
)
3322 /* We only want to perform unrolling once. */
3323 save_flag_unroll_loops
= flag_unroll_loops
;
3324 save_flag_unroll_all_loops
= flag_unroll_all_loops
;
3325 flag_unroll_loops
= 0;
3326 flag_unroll_all_loops
= 0;
3328 loop_optimize (insns
, loop_dump_file
);
3330 /* The regscan pass may not be necessary, but let's
3331 be safe until we can prove otherwise. */
3332 reg_scan (insns
, max_reg_num (), 1);
3334 /* Restore loop unrolling flags. */
3335 flag_unroll_loops
= save_flag_unroll_loops
;
3336 flag_unroll_all_loops
= save_flag_unroll_all_loops
;
3338 loop_optimize (insns
, loop_dump_file
);
3342 /* Dump rtl code after loop opt, if we are doing that. */
3347 print_rtl (loop_dump_file
, insns
);
3348 fflush (loop_dump_file
);
3354 fprintf (cse2_dump_file
, "\n;; Function %s\n\n",
3355 (*decl_printable_name
) (decl
, 2));
3358 if (optimize
> 0 && flag_rerun_cse_after_loop
)
3360 /* Running another jump optimization pass before the second
3361 cse pass sometimes simplifies the RTL enough to allow
3362 the second CSE pass to do a better job. Jump_optimize can change
3363 max_reg_num so we must rerun reg_scan afterwards.
3364 ??? Rework to not call reg_scan so often. */
3365 TIMEVAR (jump_time
, reg_scan (insns
, max_reg_num (), 0));
3366 TIMEVAR (jump_time
, jump_optimize (insns
, 0, 0, 1));
3368 TIMEVAR (cse2_time
, reg_scan (insns
, max_reg_num (), 0));
3369 TIMEVAR (cse2_time
, tem
= cse_main (insns
, max_reg_num (),
3370 1, cse2_dump_file
));
3372 TIMEVAR (jump_time
, jump_optimize (insns
, 0, 0, 0));
3375 if (optimize
> 0 && flag_thread_jumps
)
3377 /* This pass of jump threading straightens out code
3378 that was kinked by loop optimization. */
3379 TIMEVAR (jump_time
, reg_scan (insns
, max_reg_num (), 0));
3380 TIMEVAR (jump_time
, thread_jumps (insns
, max_reg_num (), 0));
3382 /* Dump rtl code after cse, if we are doing that. */
3387 print_rtl (cse2_dump_file
, insns
);
3388 fflush (cse2_dump_file
);
3391 if (branch_prob_dump
)
3394 fprintf (branch_prob_dump_file
, "\n;; Function %s\n\n",
3395 (*decl_printable_name
) (decl
, 2));
3398 if (profile_arc_flag
|| flag_test_coverage
|| flag_branch_probabilities
)
3399 TIMEVAR (branch_prob_time
,
3401 branch_prob (insns
, branch_prob_dump_file
);
3404 if (branch_prob_dump
)
3407 print_rtl (branch_prob_dump_file
, insns
);
3408 fflush (branch_prob_dump_file
);
3410 /* We are no longer anticipating cse in this function, at least. */
3412 cse_not_expected
= 1;
3414 /* Now we choose between stupid (pcc-like) register allocation
3415 (if we got the -noreg switch and not -opt)
3416 and smart register allocation. */
3418 if (optimize
> 0) /* Stupid allocation probably won't work */
3419 obey_regdecls
= 0; /* if optimizations being done. */
3423 /* Print function header into flow dump now
3424 because doing the flow analysis makes some of the dump. */
3429 fprintf (flow_dump_file
, "\n;; Function %s\n\n",
3430 (*decl_printable_name
) (decl
, 2));
3437 regclass (insns
, max_reg_num ());
3438 stupid_life_analysis (insns
, max_reg_num (),
3444 /* Do control and data flow analysis,
3445 and write some of the results to dump file. */
3447 TIMEVAR (flow_time
, flow_analysis (insns
, max_reg_num (),
3449 if (warn_uninitialized
)
3451 uninitialized_vars_warning (DECL_INITIAL (decl
));
3452 setjmp_args_warning ();
3456 /* Dump rtl after flow analysis. */
3461 print_rtl_with_bb (flow_dump_file
, insns
);
3462 fflush (flow_dump_file
);
3465 /* If -opt, try combining insns through substitution. */
3468 TIMEVAR (combine_time
, combine_instructions (insns
, max_reg_num ()));
3470 /* Dump rtl code after insn combination. */
3475 fprintf (combine_dump_file
, "\n;; Function %s\n\n",
3476 (*decl_printable_name
) (decl
, 2));
3477 dump_combine_stats (combine_dump_file
);
3478 print_rtl_with_bb (combine_dump_file
, insns
);
3479 fflush (combine_dump_file
);
3485 fprintf (regmove_dump_file
, "\n;; Function %s\n\n",
3486 (*decl_printable_name
) (decl
, 2));
3489 /* Register allocation pre-pass, to reduce number of moves
3490 necessary for two-address machines. */
3491 if (optimize
> 0 && flag_regmove
)
3492 TIMEVAR (regmove_time
, regmove_optimize (insns
, max_reg_num (),
3493 regmove_dump_file
));
3498 print_rtl_with_bb (regmove_dump_file
, insns
);
3499 fflush (regmove_dump_file
);
3502 /* Print function header into sched dump now
3503 because doing the sched analysis makes some of the dump. */
3508 fprintf (sched_dump_file
, "\n;; Function %s\n\n",
3509 (*decl_printable_name
) (decl
, 2));
3512 if (optimize
> 0 && flag_schedule_insns
)
3514 /* Do control and data sched analysis,
3515 and write some of the results to dump file. */
3517 TIMEVAR (sched_time
, schedule_insns (sched_dump_file
));
3520 /* Dump rtl after instruction scheduling. */
3525 print_rtl_with_bb (sched_dump_file
, insns
);
3526 fflush (sched_dump_file
);
3529 /* Unless we did stupid register allocation,
3530 allocate pseudo-regs that are used only within 1 basic block. */
3533 TIMEVAR (local_alloc_time
,
3535 regclass (insns
, max_reg_num ());
3539 /* Dump rtl code after allocating regs within basic blocks. */
3544 fprintf (local_reg_dump_file
, "\n;; Function %s\n\n",
3545 (*decl_printable_name
) (decl
, 2));
3546 dump_flow_info (local_reg_dump_file
);
3547 dump_local_alloc (local_reg_dump_file
);
3548 print_rtl_with_bb (local_reg_dump_file
, insns
);
3549 fflush (local_reg_dump_file
);
3552 if (global_reg_dump
)
3554 fprintf (global_reg_dump_file
, "\n;; Function %s\n\n",
3555 (*decl_printable_name
) (decl
, 2)));
3557 /* Save the last label number used so far, so reorg can tell
3558 when it's safe to kill spill regs. */
3559 max_label_num_after_reload
= max_label_num ();
3561 /* Unless we did stupid register allocation,
3562 allocate remaining pseudo-regs, then do the reload pass
3563 fixing up any insns that are invalid. */
3565 TIMEVAR (global_alloc_time
,
3568 failure
= global_alloc (global_reg_dump_file
);
3570 failure
= reload (insns
, 0, global_reg_dump_file
);
3573 if (global_reg_dump
)
3576 dump_global_regs (global_reg_dump_file
);
3577 print_rtl_with_bb (global_reg_dump_file
, insns
);
3578 fflush (global_reg_dump_file
);
3582 goto exit_rest_of_compilation
;
3584 reload_completed
= 1;
3586 /* Do a very simple CSE pass over just the hard registers. */
3588 reload_cse_regs (insns
);
3590 /* On some machines, the prologue and epilogue code, or parts thereof,
3591 can be represented as RTL. Doing so lets us schedule insns between
3592 it and the rest of the code and also allows delayed branch
3593 scheduling to operate in the epilogue. */
3595 thread_prologue_and_epilogue_insns (insns
);
3597 if (optimize
> 0 && flag_schedule_insns_after_reload
)
3602 fprintf (sched2_dump_file
, "\n;; Function %s\n\n",
3603 (*decl_printable_name
) (decl
, 2));
3606 /* Do control and data sched analysis again,
3607 and write some more of the results to dump file. */
3609 TIMEVAR (sched2_time
, schedule_insns (sched2_dump_file
));
3611 /* Dump rtl after post-reorder instruction scheduling. */
3616 print_rtl_with_bb (sched2_dump_file
, insns
);
3617 fflush (sched2_dump_file
);
3621 #ifdef LEAF_REGISTERS
3623 if (optimize
> 0 && only_leaf_regs_used () && leaf_function_p ())
3627 /* One more attempt to remove jumps to .+1
3628 left by dead-store-elimination.
3629 Also do cross-jumping this time
3630 and delete no-op move insns. */
3634 TIMEVAR (jump_time
, jump_optimize (insns
, 1, 1, 0));
3637 /* Dump rtl code after jump, if we are doing that. */
3642 fprintf (jump2_opt_dump_file
, "\n;; Function %s\n\n",
3643 (*decl_printable_name
) (decl
, 2));
3644 print_rtl_with_bb (jump2_opt_dump_file
, insns
);
3645 fflush (jump2_opt_dump_file
);
3648 /* If a machine dependent reorganization is needed, call it. */
3649 #ifdef MACHINE_DEPENDENT_REORG
3650 MACHINE_DEPENDENT_REORG (insns
);
3653 /* If a scheduling pass for delayed branches is to be done,
3654 call the scheduling code. */
3657 if (optimize
> 0 && flag_delayed_branch
)
3659 TIMEVAR (dbr_sched_time
, dbr_schedule (insns
, dbr_sched_dump_file
));
3664 fprintf (dbr_sched_dump_file
, "\n;; Function %s\n\n",
3665 (*decl_printable_name
) (decl
, 2));
3666 print_rtl_with_bb (dbr_sched_dump_file
, insns
);
3667 fflush (dbr_sched_dump_file
);
3673 /* Shorten branches. */
3674 TIMEVAR (shorten_branch_time
,
3676 shorten_branches (get_insns ());
3680 TIMEVAR (stack_reg_time
, reg_to_stack (insns
, stack_reg_dump_file
));
3685 fprintf (stack_reg_dump_file
, "\n;; Function %s\n\n",
3686 (*decl_printable_name
) (decl
, 2));
3687 print_rtl_with_bb (stack_reg_dump_file
, insns
);
3688 fflush (stack_reg_dump_file
);
3693 /* Now turn the rtl into assembler code. */
3695 TIMEVAR (final_time
,
3700 /* Get the function's name, as described by its RTL.
3701 This may be different from the DECL_NAME name used
3702 in the source file. */
3704 x
= DECL_RTL (decl
);
3705 if (GET_CODE (x
) != MEM
)
3708 if (GET_CODE (x
) != SYMBOL_REF
)
3710 fnname
= XSTR (x
, 0);
3712 assemble_start_function (decl
, fnname
);
3713 final_start_function (insns
, asm_out_file
, optimize
);
3714 final (insns
, asm_out_file
, optimize
, 0);
3715 final_end_function (insns
, asm_out_file
, optimize
);
3716 assemble_end_function (decl
, fnname
);
3717 fflush (asm_out_file
);
3719 /* Release all memory held by regsets now */
3720 regset_release_memory ();
3723 /* Write DBX symbols if requested */
3725 /* Note that for those inline functions where we don't initially
3726 know for certain that we will be generating an out-of-line copy,
3727 the first invocation of this routine (rest_of_compilation) will
3728 skip over this code by doing a `goto exit_rest_of_compilation;'.
3729 Later on, finish_compilation will call rest_of_compilation again
3730 for those inline functions that need to have out-of-line copies
3731 generated. During that call, we *will* be routed past here. */
3733 #ifdef DBX_DEBUGGING_INFO
3734 if (write_symbols
== DBX_DEBUG
)
3735 TIMEVAR (symout_time
, dbxout_function (decl
));
3738 #ifdef DWARF_DEBUGGING_INFO
3739 if (write_symbols
== DWARF_DEBUG
)
3740 TIMEVAR (symout_time
, dwarfout_file_scope_decl (decl
, 0));
3743 #ifdef DWARF2_DEBUGGING_INFO
3744 if (write_symbols
== DWARF2_DEBUG
)
3745 TIMEVAR (symout_time
, dwarf2out_decl (decl
));
3748 exit_rest_of_compilation
:
3750 /* In case the function was not output,
3751 don't leave any temporary anonymous types
3752 queued up for sdb output. */
3753 #ifdef SDB_DEBUGGING_INFO
3754 if (write_symbols
== SDB_DEBUG
)
3755 sdbout_types (NULL_TREE
);
3758 /* Put back the tree of subblocks and list of arguments
3759 from before we copied them.
3760 Code generation and the output of debugging info may have modified
3761 the copy, but the original is unchanged. */
3763 if (saved_block_tree
!= 0)
3765 DECL_INITIAL (decl
) = saved_block_tree
;
3766 DECL_ARGUMENTS (decl
) = saved_arguments
;
3767 DECL_ABSTRACT_ORIGIN (decl
) = NULL_TREE
;
3770 reload_completed
= 0;
3772 /* Clear out the insn_length contents now that they are no longer valid. */
3773 init_insn_lengths ();
3775 /* Clear out the real_constant_chain before some of the rtx's
3776 it runs through become garbage. */
3778 clear_const_double_mem ();
3780 /* Cancel the effect of rtl_in_current_obstack. */
3782 resume_temporary_allocation ();
3784 /* Show no temporary slots allocated. */
3788 /* The parsing time is all the time spent in yyparse
3789 *except* what is spent in this function. */
3791 parse_time
-= get_run_time () - start_time
;
3794 /* Entry point of cc1/c++. Decode command args, then call compile_file.
3795 Exit code is 35 if can't open files, 34 if fatal error,
3796 33 if had nonfatal errors, else success. */
3799 main (argc
, argv
, envp
)
3806 int flag_print_mem
= 0;
3807 int version_flag
= 0;
3810 /* save in case md file wants to emit args as a comment. */
3814 p
= argv
[0] + strlen (argv
[0]);
3815 while (p
!= argv
[0] && p
[-1] != '/'
3816 #ifdef DIR_SEPARATOR
3817 && p
[-1] != DIR_SEPARATOR
3824 /* Get rid of any avoidable limit on stack size. */
3828 /* Set the stack limit huge so that alloca does not fail. */
3829 getrlimit (RLIMIT_STACK
, &rlim
);
3830 rlim
.rlim_cur
= rlim
.rlim_max
;
3831 setrlimit (RLIMIT_STACK
, &rlim
);
3833 #endif /* RLIMIT_STACK */
3835 signal (SIGFPE
, float_signal
);
3838 signal (SIGPIPE
, pipe_closed
);
3841 decl_printable_name
= decl_name
;
3842 lang_expand_expr
= (struct rtx_def
*(*)()) do_abort
;
3844 /* Initialize whether `char' is signed. */
3845 flag_signed_char
= DEFAULT_SIGNED_CHAR
;
3846 #ifdef DEFAULT_SHORT_ENUMS
3847 /* Initialize how much space enums occupy, by default. */
3848 flag_short_enums
= DEFAULT_SHORT_ENUMS
;
3851 /* Scan to see what optimization level has been specified. That will
3852 determine the default value of many flags. */
3853 for (i
= 1; i
< argc
; i
++)
3855 if (!strcmp (argv
[i
], "-O"))
3859 else if (argv
[i
][0] == '-' && argv
[i
][1] == 'O')
3861 /* Handle -O2, -O3, -O69, ... */
3862 char *p
= &argv
[i
][2];
3866 if (! (c
>= '0' && c
<= '9'))
3869 optimize
= atoi (&argv
[i
][2]);
3873 obey_regdecls
= (optimize
== 0);
3878 flag_thread_jumps
= 1;
3880 flag_delayed_branch
= 1;
3882 #ifdef CAN_DEBUG_WITHOUT_FP
3883 flag_omit_frame_pointer
= 1;
3885 flag_alias_check
= 1;
3890 flag_cse_follow_jumps
= 1;
3891 flag_cse_skip_blocks
= 1;
3892 flag_expensive_optimizations
= 1;
3893 flag_strength_reduce
= 1;
3894 flag_rerun_cse_after_loop
= 1;
3895 flag_rerun_loop_opt
= 1;
3896 flag_caller_saves
= 1;
3898 #ifdef INSN_SCHEDULING
3899 flag_schedule_insns
= 1;
3900 flag_schedule_insns_after_reload
= 1;
3907 flag_inline_functions
= 1;
3910 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
3913 set_target_switch ("");
3915 #ifdef OPTIMIZATION_OPTIONS
3916 /* Allow default optimizations to be specified on a per-machine basis. */
3917 OPTIMIZATION_OPTIONS (optimize
);
3920 /* Initialize register usage now so switches may override. */
3923 for (i
= 1; i
< argc
; i
++)
3926 /* If this is a language-specific option,
3927 decode it in a language-specific way. */
3928 for (j
= 0; lang_options
[j
] != 0; j
++)
3929 if (!strncmp (argv
[i
], lang_options
[j
],
3930 strlen (lang_options
[j
])))
3932 if (lang_options
[j
] != 0)
3933 /* If the option is valid for *some* language,
3934 treat it as valid even if this language doesn't understand it. */
3935 lang_decode_option (argv
[i
]);
3936 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
3938 register char *str
= argv
[i
] + 1;
3943 set_target_switch (&str
[1]);
3944 else if (!strcmp (str
, "dumpbase"))
3946 dump_base_name
= argv
[++i
];
3948 else if (str
[0] == 'd')
3950 register char *p
= &str
[1];
3955 branch_prob_dump
= 1;
3959 global_reg_dump
= 1;
3967 cse_dump
= 1, cse2_dump
= 1;
3973 branch_prob_dump
= 1;
3988 global_reg_dump
= 1;
4009 flag_print_asm_name
= 1;
4033 rtl_dump_and_exit
= 1;
4040 else if (str
[0] == 'f')
4042 register char *p
= &str
[1];
4045 /* Some kind of -f option.
4046 P's value is the option sans `-f'.
4047 Search for it in the table of options. */
4050 !found
&& j
< sizeof (f_options
) / sizeof (f_options
[0]);
4053 if (!strcmp (p
, f_options
[j
].string
))
4055 *f_options
[j
].variable
= f_options
[j
].on_value
;
4056 /* A goto here would be cleaner,
4057 but breaks the vax pcc. */
4060 if (p
[0] == 'n' && p
[1] == 'o' && p
[2] == '-'
4061 && ! strcmp (p
+3, f_options
[j
].string
))
4063 *f_options
[j
].variable
= ! f_options
[j
].on_value
;
4071 #ifdef INSN_SCHEDULING
4072 else if (!strncmp (p
, "sched-verbose-",14))
4073 fix_sched_param("verbose",&p
[14]);
4074 else if (!strncmp (p
, "sched-max-",10))
4075 fix_sched_param("max",&p
[10]);
4076 else if (!strncmp (p
, "sched-inter-max-b-",18))
4077 fix_sched_param("interblock-max-blocks",&p
[18]);
4078 else if (!strncmp (p
, "sched-inter-max-i-",18))
4079 fix_sched_param("interblock-max-insns",&p
[18]);
4082 else if (!strncmp (p
, "fixed-", 6))
4083 fix_register (&p
[6], 1, 1);
4084 else if (!strncmp (p
, "call-used-", 10))
4085 fix_register (&p
[10], 0, 1);
4086 else if (!strncmp (p
, "call-saved-", 11))
4087 fix_register (&p
[11], 0, 0);
4089 error ("Invalid option `%s'", argv
[i
]);
4091 else if (str
[0] == 'O')
4093 register char *p
= str
+1;
4094 while (*p
&& *p
>= '0' && *p
<= '9')
4099 error ("Invalid option `%s'", argv
[i
]);
4101 else if (!strcmp (str
, "pedantic"))
4103 else if (!strcmp (str
, "pedantic-errors"))
4104 flag_pedantic_errors
= pedantic
= 1;
4105 else if (!strcmp (str
, "quiet"))
4107 else if (!strcmp (str
, "version"))
4109 else if (!strcmp (str
, "w"))
4110 inhibit_warnings
= 1;
4111 else if (!strcmp (str
, "W"))
4114 /* We save the value of warn_uninitialized, since if they put
4115 -Wuninitialized on the command line, we need to generate a
4116 warning about not using it without also specifying -O. */
4117 if (warn_uninitialized
!= 1)
4118 warn_uninitialized
= 2;
4120 else if (str
[0] == 'W')
4122 register char *p
= &str
[1];
4125 /* Some kind of -W option.
4126 P's value is the option sans `-W'.
4127 Search for it in the table of options. */
4130 !found
&& j
< sizeof (W_options
) / sizeof (W_options
[0]);
4133 if (!strcmp (p
, W_options
[j
].string
))
4135 *W_options
[j
].variable
= W_options
[j
].on_value
;
4136 /* A goto here would be cleaner,
4137 but breaks the vax pcc. */
4140 if (p
[0] == 'n' && p
[1] == 'o' && p
[2] == '-'
4141 && ! strcmp (p
+3, W_options
[j
].string
))
4143 *W_options
[j
].variable
= ! W_options
[j
].on_value
;
4150 else if (!strncmp (p
, "id-clash-", 9))
4156 if (*endp
>= '0' && *endp
<= '9')
4160 error ("Invalid option `%s'", argv
[i
]);
4165 id_clash_len
= atoi (str
+ 10);
4168 else if (!strncmp (p
, "larger-than-", 12))
4170 char *endp
= p
+ 12;
4174 if (*endp
>= '0' && *endp
<= '9')
4178 error ("Invalid option `%s'", argv
[i
]);
4179 goto larger_than_lose
;
4182 warn_larger_than
= 1;
4183 larger_than_size
= atoi (str
+ 13);
4187 error ("Invalid option `%s'", argv
[i
]);
4189 else if (!strcmp (str
, "p"))
4193 else if (!strcmp (str
, "a"))
4195 #if !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
4196 warning ("`-a' option (basic block profile) not supported");
4198 profile_block_flag
= (profile_block_flag
< 2) ? 1 : 3;
4201 else if (!strcmp (str
, "ax"))
4203 #if !defined (FUNCTION_BLOCK_PROFILER_EXIT) || !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
4204 warning ("`-ax' option (jump profiling) not supported");
4206 profile_block_flag
= (!profile_block_flag
4207 || profile_block_flag
== 2) ? 2 : 3;
4210 else if (str
[0] == 'g')
4214 /* A lot of code assumes write_symbols == NO_DEBUG if the
4215 debugging level is 0 (thus -gstabs1 -gstabs0 would lose track
4216 of what debugging type has been selected). This records the
4217 selected type. It is an error to specify more than one
4219 static enum debug_info_type selected_debug_type
= NO_DEBUG
;
4220 /* Non-zero if debugging format has been explicitly set.
4221 -g and -ggdb don't explicitly set the debugging format so
4222 -gdwarf -g3 is equivalent to -gdwarf3. */
4223 static int type_explicitly_set_p
= 0;
4224 /* Table of supported debugging formats. */
4227 /* Since PREFERRED_DEBUGGING_TYPE isn't necessarily a
4228 constant expression, we use NO_DEBUG in its place. */
4229 enum debug_info_type debug_type
;
4230 int use_extensions_p
;
4231 } *da
, debug_args
[] = {
4232 { "g", NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
},
4233 { "ggdb", NO_DEBUG
, 1 },
4234 #ifdef DBX_DEBUGGING_INFO
4235 { "gstabs", DBX_DEBUG
, 0 },
4236 { "gstabs+", DBX_DEBUG
, 1 },
4238 #ifdef DWARF_DEBUGGING_INFO
4239 { "gdwarf", DWARF_DEBUG
, 0 },
4240 { "gdwarf+", DWARF_DEBUG
, 1 },
4242 #ifdef DWARF2_DEBUGGING_INFO
4243 { "gdwarf-2", DWARF2_DEBUG
, 0 },
4245 #ifdef XCOFF_DEBUGGING_INFO
4246 { "gxcoff", XCOFF_DEBUG
, 0 },
4247 { "gxcoff+", XCOFF_DEBUG
, 1 },
4249 #ifdef SDB_DEBUGGING_INFO
4250 { "gcoff", SDB_DEBUG
, 0 },
4254 /* Indexed by enum debug_info_type. */
4255 static char *debug_type_names
[] = {
4256 "none", "stabs", "coff", "dwarf-1", "dwarf-2", "xcoff"
4259 /* Look up STR in the table. */
4260 for (da
= debug_args
; da
->arg
; da
++)
4262 if (! strncmp (str
, da
->arg
, strlen (da
->arg
)))
4264 enum debug_info_type type
= da
->debug_type
;
4267 p
= str
+ strlen (da
->arg
);
4268 if (*p
&& (*p
< '0' || *p
> '9'))
4272 while (*q
&& (*q
>= '0' && *q
<= '9'))
4277 level
= 2; /* default debugging info level */
4278 if (*q
|| level
> 3)
4280 warning ("invalid debug level specification in option: `-%s'",
4282 /* ??? This error message is incorrect in the case of
4284 warning ("no debugging information will be generated");
4288 if (type
== NO_DEBUG
)
4290 type
= PREFERRED_DEBUGGING_TYPE
;
4291 if (len
> 1 && strncmp (str
, "ggdb", len
) == 0)
4293 #ifdef DWARF2_DEBUGGING_INFO
4294 type
= DWARF2_DEBUG
;
4296 #ifdef DBX_DEBUGGING_INFO
4303 if (type
== NO_DEBUG
)
4304 warning ("`-%s' not supported by this configuration of GCC",
4307 /* Does it conflict with an already selected type? */
4308 if (type_explicitly_set_p
4309 /* -g/-ggdb don't conflict with anything */
4310 && da
->debug_type
!= NO_DEBUG
4311 && type
!= selected_debug_type
)
4312 warning ("`-%s' ignored, conflicts with `-g%s'",
4313 str
, debug_type_names
[(int) selected_debug_type
]);
4316 /* If the format has already been set, -g/-ggdb
4317 only change the debug level. */
4318 if (type_explicitly_set_p
4319 && da
->debug_type
== NO_DEBUG
)
4320 ; /* don't change debugging type */
4323 selected_debug_type
= type
;
4324 type_explicitly_set_p
= da
->debug_type
!= NO_DEBUG
;
4326 write_symbols
= (level
== 0
4328 : selected_debug_type
);
4329 use_gnu_debug_info_extensions
= da
->use_extensions_p
;
4330 debug_info_level
= (enum debug_info_level
) level
;
4336 warning ("`-%s' not supported by this configuration of GCC",
4339 else if (!strcmp (str
, "o"))
4341 asm_file_name
= argv
[++i
];
4343 else if (str
[0] == 'G')
4345 g_switch_set
= TRUE
;
4346 g_switch_value
= atoi ((str
[1] != '\0') ? str
+1 : argv
[++i
]);
4348 else if (!strncmp (str
, "aux-info", 8))
4350 flag_gen_aux_info
= 1;
4351 aux_info_file_name
= (str
[8] != '\0' ? str
+8 : argv
[++i
]);
4354 error ("Invalid option `%s'", argv
[i
]);
4356 else if (argv
[i
][0] == '+')
4357 error ("Invalid option `%s'", argv
[i
]);
4362 /* Checker uses the frame pointer. */
4363 if (flag_check_memory_usage
)
4364 flag_omit_frame_pointer
= 0;
4366 /* Initialize for bytecode output. A good idea to do this as soon as
4367 possible after the "-f" options have been parsed. */
4368 if (output_bytecode
)
4370 #ifndef TARGET_SUPPORTS_BYTECODE
4371 /* Just die with a fatal error if not supported */
4372 fatal ("-fbytecode not supported for this target");
4380 /* Inlining does not work if not optimizing,
4381 so force it not to be done. */
4385 /* The c_decode_option and lang_decode_option functions set
4386 this to `2' if -Wall is used, so we can avoid giving out
4387 lots of errors for people who don't realize what -Wall does. */
4388 if (warn_uninitialized
== 1)
4389 warning ("-Wuninitialized is not supported without -O");
4392 #ifdef OVERRIDE_OPTIONS
4393 /* Some machines may reject certain combinations of options. */
4397 if (exceptions_via_longjmp
== 2)
4399 #ifdef DWARF2_UNWIND_INFO
4400 exceptions_via_longjmp
= ! DWARF2_UNWIND_INFO
;
4402 exceptions_via_longjmp
= 1;
4406 if (profile_block_flag
== 3)
4408 warning ("`-ax' and `-a' are conflicting options. `-a' ignored.");
4409 profile_block_flag
= 2;
4412 /* Unrolling all loops implies that standard loop unrolling must also
4414 if (flag_unroll_all_loops
)
4415 flag_unroll_loops
= 1;
4416 /* Loop unrolling requires that strength_reduction be on also. Silently
4417 turn on strength reduction here if it isn't already on. Also, the loop
4418 unrolling code assumes that cse will be run after loop, so that must
4419 be turned on also. */
4420 if (flag_unroll_loops
)
4422 flag_strength_reduce
= 1;
4423 flag_rerun_cse_after_loop
= 1;
4426 /* Warn about options that are not supported on this machine. */
4427 #ifndef INSN_SCHEDULING
4428 if (flag_schedule_insns
|| flag_schedule_insns_after_reload
)
4429 warning ("instruction scheduling not supported on this target machine");
4432 if (flag_delayed_branch
)
4433 warning ("this target machine does not have delayed branches");
4436 /* If we are in verbose mode, write out the version and maybe all the
4437 option flags in use. */
4440 print_version (stderr
, "");
4442 print_switch_values (stderr
, 0, MAX_LINE
, "", " ", "\n");
4445 compile_file (filename
);
4447 #if !defined(OS2) && !defined(VMS) && (!defined(_WIN32) || defined (__CYGWIN32__))
4450 char *lim
= (char *) sbrk (0);
4452 fprintf (stderr
, "Data size %d.\n",
4453 lim
- (char *) &environ
);
4458 system ("ps -l 1>&2");
4461 #endif /* not USG */
4464 #endif /* ! OS2 && ! VMS && (! _WIN32 || CYGWIN32) */
4467 exit (FATAL_EXIT_CODE
);
4469 exit (FATAL_EXIT_CODE
);
4470 exit (SUCCESS_EXIT_CODE
);
4474 /* Decode -m switches. */
4476 /* Here is a table, controlled by the tm.h file, listing each -m switch
4477 and which bits in `target_switches' it should set or clear.
4478 If VALUE is positive, it is bits to set.
4479 If VALUE is negative, -VALUE is bits to clear.
4480 (The sign bit is not used so there is no confusion.) */
4482 struct {char *name
; int value
;} target_switches
[]
4485 /* This table is similar, but allows the switch to have a value. */
4487 #ifdef TARGET_OPTIONS
4488 struct {char *prefix
; char ** variable
;} target_options
[]
4492 /* Decode the switch -mNAME. */
4495 set_target_switch (name
)
4501 for (j
= 0; j
< sizeof target_switches
/ sizeof target_switches
[0]; j
++)
4502 if (!strcmp (target_switches
[j
].name
, name
))
4504 if (target_switches
[j
].value
< 0)
4505 target_flags
&= ~-target_switches
[j
].value
;
4507 target_flags
|= target_switches
[j
].value
;
4511 #ifdef TARGET_OPTIONS
4513 for (j
= 0; j
< sizeof target_options
/ sizeof target_options
[0]; j
++)
4515 int len
= strlen (target_options
[j
].prefix
);
4516 if (!strncmp (target_options
[j
].prefix
, name
, len
))
4518 *target_options
[j
].variable
= name
+ len
;
4525 error ("Invalid option `%s'", name
);
4528 /* Print version information to FILE.
4529 Each line begins with INDENT (for the case where FILE is the
4530 assembler output file). */
4533 print_version (file
, indent
)
4537 fprintf (file
, "%s%s%s version %s", indent
, *indent
!= 0 ? " " : "",
4538 language_string
, version_string
);
4539 fprintf (file
, " (%s)", TARGET_NAME
);
4542 #define __VERSION__ "[unknown]"
4544 fprintf (file
, " compiled by GNU C version %s.\n", __VERSION__
);
4546 fprintf (file
, " compiled by CC.\n");
4550 /* Print an option value and return the adjusted position in the line.
4551 ??? We don't handle error returns from fprintf (disk full); presumably
4552 other code will catch a disk full though. */
4555 print_single_switch (file
, pos
, max
, indent
, sep
, term
, type
, name
)
4558 char *indent
, *sep
, *term
, *type
, *name
;
4560 /* The ultrix fprintf returns 0 on success, so compute the result we want
4561 here since we need it for the following test. */
4562 int len
= strlen (sep
) + strlen (type
) + strlen (name
);
4567 fprintf (file
, "%s", term
);
4572 fprintf (file
, "%s", indent
);
4573 pos
= strlen (indent
);
4575 fprintf (file
, "%s%s%s", sep
, type
, name
);
4580 /* Print active target switches to FILE.
4581 POS is the current cursor position and MAX is the size of a "line".
4582 Each line begins with INDENT and ends with TERM.
4583 Each switch is separated from the next by SEP. */
4586 print_switch_values (file
, pos
, max
, indent
, sep
, term
)
4589 char *indent
, *sep
, *term
;
4594 /* Print the options as passed. */
4596 pos
= print_single_switch (file
, pos
, max
, indent
, *indent
? " " : "", term
,
4597 "options passed: ", "");
4599 for (p
= &save_argv
[1]; *p
!= NULL
; p
++)
4603 if (strcmp (*p
, "-o") == 0)
4609 if (strcmp (*p
, "-quiet") == 0)
4611 if (strcmp (*p
, "-version") == 0)
4616 pos
= print_single_switch (file
, pos
, max
, indent
, sep
, term
, *p
, "");
4619 fprintf (file
, "%s", term
);
4621 /* Print the -f and -m options that have been enabled.
4622 We don't handle language specific options but printing argv
4625 pos
= print_single_switch (file
, 0, max
, indent
, *indent
? " " : "", term
,
4626 "options enabled: ", "");
4628 for (j
= 0; j
< sizeof f_options
/ sizeof f_options
[0]; j
++)
4629 if (*f_options
[j
].variable
== f_options
[j
].on_value
)
4630 pos
= print_single_switch (file
, pos
, max
, indent
, sep
, term
,
4631 "-f", f_options
[j
].string
);
4633 /* Print target specific options. */
4635 flags
= target_flags
;
4636 for (j
= 0; j
< sizeof target_switches
/ sizeof target_switches
[0]; j
++)
4637 if (target_switches
[j
].name
[0] != '\0'
4638 && target_switches
[j
].value
> 0
4639 && ((target_switches
[j
].value
& target_flags
)
4640 == target_switches
[j
].value
))
4642 pos
= print_single_switch (file
, pos
, max
, indent
, sep
, term
,
4643 "-m", target_switches
[j
].name
);
4644 flags
&= ~ target_switches
[j
].value
;
4647 #ifdef TARGET_OPTIONS
4648 for (j
= 0; j
< sizeof target_options
/ sizeof target_options
[0]; j
++)
4649 if (*target_options
[j
].variable
!= NULL
)
4652 sprintf (prefix
, "-m%s", target_options
[j
].prefix
);
4653 pos
= print_single_switch (file
, pos
, max
, indent
, sep
, term
,
4654 prefix
, *target_options
[j
].variable
);
4658 fprintf (file
, "%s", term
);
4661 /* Record the beginning of a new source file, named FILENAME. */
4664 debug_start_source_file (filename
)
4665 register char *filename
;
4667 #ifdef DBX_DEBUGGING_INFO
4668 if (write_symbols
== DBX_DEBUG
)
4669 dbxout_start_new_source_file (filename
);
4671 #ifdef DWARF_DEBUGGING_INFO
4672 if (debug_info_level
== DINFO_LEVEL_VERBOSE
4673 && write_symbols
== DWARF_DEBUG
)
4674 dwarfout_start_new_source_file (filename
);
4675 #endif /* DWARF_DEBUGGING_INFO */
4676 #ifdef DWARF2_DEBUGGING_INFO
4677 if (debug_info_level
== DINFO_LEVEL_VERBOSE
4678 && write_symbols
== DWARF2_DEBUG
)
4679 dwarf2out_start_source_file (filename
);
4680 #endif /* DWARF2_DEBUGGING_INFO */
4681 #ifdef SDB_DEBUGGING_INFO
4682 if (write_symbols
== SDB_DEBUG
)
4683 sdbout_start_new_source_file (filename
);
4687 /* Record the resumption of a source file. LINENO is the line number in
4688 the source file we are returning to. */
4691 debug_end_source_file (lineno
)
4692 register unsigned lineno
;
4694 #ifdef DBX_DEBUGGING_INFO
4695 if (write_symbols
== DBX_DEBUG
)
4696 dbxout_resume_previous_source_file ();
4698 #ifdef DWARF_DEBUGGING_INFO
4699 if (debug_info_level
== DINFO_LEVEL_VERBOSE
4700 && write_symbols
== DWARF_DEBUG
)
4701 dwarfout_resume_previous_source_file (lineno
);
4702 #endif /* DWARF_DEBUGGING_INFO */
4703 #ifdef DWARF2_DEBUGGING_INFO
4704 if (debug_info_level
== DINFO_LEVEL_VERBOSE
4705 && write_symbols
== DWARF2_DEBUG
)
4706 dwarf2out_end_source_file ();
4707 #endif /* DWARF2_DEBUGGING_INFO */
4708 #ifdef SDB_DEBUGGING_INFO
4709 if (write_symbols
== SDB_DEBUG
)
4710 sdbout_resume_previous_source_file ();
4714 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
4715 the tail part of the directive line, i.e. the part which is past the
4716 initial whitespace, #, whitespace, directive-name, whitespace part. */
4719 debug_define (lineno
, buffer
)
4720 register unsigned lineno
;
4721 register char *buffer
;
4723 #ifdef DWARF_DEBUGGING_INFO
4724 if (debug_info_level
== DINFO_LEVEL_VERBOSE
4725 && write_symbols
== DWARF_DEBUG
)
4726 dwarfout_define (lineno
, buffer
);
4727 #endif /* DWARF_DEBUGGING_INFO */
4728 #ifdef DWARF2_DEBUGGING_INFO
4729 if (debug_info_level
== DINFO_LEVEL_VERBOSE
4730 && write_symbols
== DWARF2_DEBUG
)
4731 dwarf2out_define (lineno
, buffer
);
4732 #endif /* DWARF2_DEBUGGING_INFO */
4735 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
4736 the tail part of the directive line, i.e. the part which is past the
4737 initial whitespace, #, whitespace, directive-name, whitespace part. */
4740 debug_undef (lineno
, buffer
)
4741 register unsigned lineno
;
4742 register char *buffer
;
4744 #ifdef DWARF_DEBUGGING_INFO
4745 if (debug_info_level
== DINFO_LEVEL_VERBOSE
4746 && write_symbols
== DWARF_DEBUG
)
4747 dwarfout_undef (lineno
, buffer
);
4748 #endif /* DWARF_DEBUGGING_INFO */
4749 #ifdef DWARF2_DEBUGGING_INFO
4750 if (debug_info_level
== DINFO_LEVEL_VERBOSE
4751 && write_symbols
== DWARF2_DEBUG
)
4752 dwarf2out_undef (lineno
, buffer
);
4753 #endif /* DWARF2_DEBUGGING_INFO */