1 /* Top level of GNU C compiler
2 Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This is the top level of cc1/c++.
21 It parses command args, opens files, invokes the various passes
22 in the proper order, and counts the time used by each.
23 Error messages and low-level interface to malloc also handled here. */
34 #include <sys/types.h>
41 #include <sys/param.h>
42 /* This is for hpux. It is a real screw. They should change hpux. */
44 #include <sys/times.h>
45 #include <time.h> /* Correct for hpux at least. Is it good on other USG? */
46 #undef FFS /* Some systems define this in param.h. */
50 #include <sys/resource.h>
59 #include "insn-attr.h"
65 #ifdef XCOFF_DEBUGGING_INFO
70 /* The extra parameters substantially improve the I/O performance. */
72 vms_fopen (fname, type)
76 /* The <stdio.h> in the gcc-vms-1.42 distribution prototypes fopen with two
77 fixed arguments, which matches ANSI's specification but not VAXCRTL's
78 pre-ANSI implementation. This hack circumvents the mismatch problem. */
79 FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
82 return (*vmslib_fopen) (fname, type, "mbc=32",
83 "deq=64", "fop=tef", "shr=nil");
85 return (*vmslib_fopen) (fname, type, "mbc=32");
87 #define fopen vms_fopen
90 #ifndef DEFAULT_GDB_EXTENSIONS
91 #define DEFAULT_GDB_EXTENSIONS 1
94 extern int rtx_equal_function_value_matters;
96 #if ! (defined (VMS) || defined (OS2))
97 extern char **environ;
99 extern char *version_string, *language_string;
101 /* Carry information from ASM_DECLARE_OBJECT_NAME
102 to ASM_FINISH_DECLARE_OBJECT. */
104 extern int size_directive_output;
105 extern tree last_assemble_variable_decl;
107 extern void init_lex ();
108 extern void init_decl_processing ();
109 extern void init_obstacks ();
110 extern void init_tree_codes ();
111 extern void init_rtl ();
112 extern void init_regs ();
113 extern void init_optabs ();
114 extern void init_stmt ();
115 extern void init_reg_sets ();
116 extern void dump_flow_info ();
117 extern void dump_sched_info ();
118 extern void dump_local_alloc ();
120 void rest_of_decl_compilation ();
121 void error_with_file_and_line PVPROTO((char *file, int line, char *s, ...));
122 void error_with_decl PVPROTO((tree decl, char *s, ...));
123 void error_for_asm PVPROTO((rtx insn, char *s, ...));
124 void error PVPROTO((char *s, ...));
125 void fatal PVPROTO((char *s, ...));
126 void warning_with_file_and_line PVPROTO((char *file, int line, char *s, ...));
127 void warning_with_decl PVPROTO((tree decl, char *s, ...));
128 void warning_for_asm PVPROTO((rtx insn, char *s, ...));
129 void warning PVPROTO((char *s, ...));
130 void pedwarn PVPROTO((char *s, ...));
131 void pedwarn_with_decl PVPROTO((tree decl, char *s, ...));
132 void pedwarn_with_file_and_line PVPROTO((char *file, int line, char *s, ...));
133 void sorry PVPROTO((char *s, ...));
134 void really_sorry PVPROTO((char *s, ...));
139 void set_target_switch ();
140 static void print_switch_values ();
141 static char *decl_name ();
143 /* Name of program invoked, sans directories. */
147 /* Copy of arguments to main. */
151 /* Name of current original source file (what was input to cpp).
152 This comes from each #-command in the actual input. */
154 char *input_filename;
156 /* Name of top-level original source file (what was input to cpp).
157 This comes from the #-command at the beginning of the actual input.
158 If there isn't any there, then this is the cc1 input file name. */
160 char *main_input_filename;
162 /* Stream for reading from the input file. */
166 /* Current line number in real source file. */
170 /* Stack of currently pending input files. */
172 struct file_stack *input_file_stack;
174 /* Incremented on each change to input_file_stack. */
175 int input_file_stack_tick;
177 /* FUNCTION_DECL for function now being parsed or compiled. */
179 extern tree current_function_decl;
181 /* Name to use as base of names for dump output files. */
183 char *dump_base_name;
185 /* Bit flags that specify the machine subtype we are compiling for.
186 Bits are tested using macros TARGET_... defined in the tm.h file
187 and set by `-m...' switches. Must be defined in rtlanal.c. */
189 extern int target_flags;
191 /* Flags saying which kinds of debugging dump have been requested. */
194 int rtl_dump_and_exit = 0;
195 int jump_opt_dump = 0;
200 int combine_dump = 0;
202 int local_reg_dump = 0;
203 int global_reg_dump = 0;
205 int jump2_opt_dump = 0;
206 int dbr_sched_dump = 0;
207 int flag_print_asm_name = 0;
208 int stack_reg_dump = 0;
210 /* Name for output file of assembly code, specified with -o. */
214 /* Value of the -G xx switch, and whether it was passed or not. */
218 /* Type(s) of debugging information we are producing (if any).
219 See flags.h for the definitions of the different possible
220 types of debugging information. */
221 enum debug_info_type write_symbols = NO_DEBUG;
223 /* Level of debugging information we are producing. See flags.h
224 for the definitions of the different possible levels. */
225 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
227 /* Nonzero means use GNU-only extensions in the generated symbolic
228 debugging information. */
229 /* Currently, this only has an effect when write_symbols is set to
230 DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
231 int use_gnu_debug_info_extensions = 0;
233 /* Nonzero means do optimizations. -O.
234 Particular numeric values stand for particular amounts of optimization;
235 thus, -O2 stores 2 here. However, the optimizations beyond the basic
236 ones are not controlled directly by this variable. Instead, they are
237 controlled by individual `flag_...' variables that are defaulted
238 based on this variable. */
242 /* Number of error messages and warning messages so far. */
245 int warningcount = 0;
248 /* Flag to output bytecode instead of native assembler */
249 int output_bytecode = 0;
251 /* Pointer to function to compute the name to use to print a declaration. */
253 char *(*decl_printable_name) ();
255 /* Pointer to function to compute rtl for a language-specific tree code. */
257 struct rtx_def *(*lang_expand_expr) ();
259 /* Pointer to function to finish handling an incomplete decl at the
260 end of compilation. */
262 void (*incomplete_decl_finalize_hook) () = 0;
264 /* Pointer to function for interim exception handling implementation.
265 This interface will change, and it is only here until a better interface
268 void (*interim_eh_hook) PROTO((tree));
270 /* Nonzero if generating code to do profiling. */
272 int profile_flag = 0;
274 /* Nonzero if generating code to do profiling on a line-by-line basis. */
276 int profile_block_flag;
278 /* Nonzero for -pedantic switch: warn about anything
279 that standard spec forbids. */
283 /* Temporarily suppress certain warnings.
284 This is set while reading code from a system header file. */
286 int in_system_header = 0;
288 /* Nonzero means do stupid register allocation.
289 Currently, this is 1 if `optimize' is 0. */
291 int obey_regdecls = 0;
293 /* Don't print functions as they are compiled and don't print
294 times taken by the various passes. -quiet. */
300 /* Nonzero means `char' should be signed. */
302 int flag_signed_char;
304 /* Nonzero means give an enum type only as many bytes as it needs. */
306 int flag_short_enums;
308 /* Nonzero for -fcaller-saves: allocate values in regs that need to
309 be saved across function calls, if that produces overall better code.
310 Optional now, so people can test it. */
312 #ifdef DEFAULT_CALLER_SAVES
313 int flag_caller_saves = 1;
315 int flag_caller_saves = 0;
318 /* Nonzero if structures and unions should be returned in memory.
320 This should only be defined if compatibility with another compiler or
321 with an ABI is needed, because it results in slower code. */
323 #ifndef DEFAULT_PCC_STRUCT_RETURN
324 #define DEFAULT_PCC_STRUCT_RETURN 1
327 /* Nonzero for -fpcc-struct-return: return values the same way PCC does. */
329 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
331 /* Nonzero for -fforce-mem: load memory value into a register
332 before arithmetic on it. This makes better cse but slower compilation. */
334 int flag_force_mem = 0;
336 /* Nonzero for -fforce-addr: load memory address into a register before
337 reference to memory. This makes better cse but slower compilation. */
339 int flag_force_addr = 0;
341 /* Nonzero for -fdefer-pop: don't pop args after each function call;
342 instead save them up to pop many calls' args with one insns. */
344 int flag_defer_pop = 0;
346 /* Nonzero for -ffloat-store: don't allocate floats and doubles
347 in extended-precision registers. */
349 int flag_float_store = 0;
351 /* Nonzero for -fcse-follow-jumps:
352 have cse follow jumps to do a more extensive job. */
354 int flag_cse_follow_jumps;
356 /* Nonzero for -fcse-skip-blocks:
357 have cse follow a branch around a block. */
358 int flag_cse_skip_blocks;
360 /* Nonzero for -fexpensive-optimizations:
361 perform miscellaneous relatively-expensive optimizations. */
362 int flag_expensive_optimizations;
364 /* Nonzero for -fthread-jumps:
365 have jump optimize output of loop. */
367 int flag_thread_jumps;
369 /* Nonzero enables strength-reduction in loop.c. */
371 int flag_strength_reduce = 0;
373 /* Nonzero enables loop unrolling in unroll.c. Only loops for which the
374 number of iterations can be calculated at compile-time (UNROLL_COMPLETELY,
375 UNROLL_MODULO) or at run-time (preconditioned to be UNROLL_MODULO) are
378 int flag_unroll_loops;
380 /* Nonzero enables loop unrolling in unroll.c. All loops are unrolled.
381 This is generally not a win. */
383 int flag_unroll_all_loops;
385 /* Nonzero for -fwritable-strings:
386 store string constants in data segment and don't uniquize them. */
388 int flag_writable_strings = 0;
390 /* Nonzero means don't put addresses of constant functions in registers.
391 Used for compiling the Unix kernel, where strange substitutions are
392 done on the assembly output. */
394 int flag_no_function_cse = 0;
396 /* Nonzero for -fomit-frame-pointer:
397 don't make a frame pointer in simple functions that don't require one. */
399 int flag_omit_frame_pointer = 0;
401 /* Nonzero to inhibit use of define_optimization peephole opts. */
403 int flag_no_peephole = 0;
405 /* Nonzero allows GCC to violate some IEEE or ANSI rules regarding math
406 operations in the interest of optimization. For example it allows
407 GCC to assume arguments to sqrt are nonnegative numbers, allowing
408 faster code for sqrt to be generated. */
410 int flag_fast_math = 0;
412 /* Nonzero means all references through pointers are volatile. */
416 /* Nonzero means treat all global and extern variables as global. */
418 int flag_volatile_global;
420 /* Nonzero means just do syntax checking; don't output anything. */
422 int flag_syntax_only = 0;
424 /* Nonzero means to rerun cse after loop optimization. This increases
425 compilation time about 20% and picks up a few more common expressions. */
427 static int flag_rerun_cse_after_loop;
429 /* Nonzero for -finline-functions: ok to inline functions that look like
430 good inline candidates. */
432 int flag_inline_functions;
434 /* Nonzero for -fkeep-inline-functions: even if we make a function
435 go inline everywhere, keep its definition around for debugging
438 int flag_keep_inline_functions;
440 /* Nonzero means that functions will not be inlined. */
444 /* Nonzero means we should be saving declaration info into a .X file. */
446 int flag_gen_aux_info = 0;
448 /* Specified name of aux-info file. */
450 static char *aux_info_file_name;
452 /* Nonzero means make the text shared if supported. */
454 int flag_shared_data;
456 /* Nonzero means schedule into delayed branch slots if supported. */
458 int flag_delayed_branch;
460 /* Nonzero means to run cleanups after CALL_EXPRs. */
462 int flag_short_temps;
464 /* Nonzero if we are compiling pure (sharable) code.
465 Value is 1 if we are doing reasonable (i.e. simple
466 offset into offset table) pic. Value is 2 if we can
467 only perform register offsets. */
471 /* Nonzero means place uninitialized global data in the bss section. */
475 /* Nonzero means pretend it is OK to examine bits of target floats,
476 even if that isn't true. The resulting code will have incorrect constants,
477 but the same series of instructions that the native compiler would make. */
479 int flag_pretend_float;
481 /* Nonzero means change certain warnings into errors.
482 Usually these are warnings about failure to conform to some standard. */
484 int flag_pedantic_errors = 0;
486 /* flag_schedule_insns means schedule insns within basic blocks (before
488 flag_schedule_insns_after_reload means schedule insns after
491 int flag_schedule_insns = 0;
492 int flag_schedule_insns_after_reload = 0;
494 /* -finhibit-size-directive inhibits output of .size for ELF.
495 This is used only for compiling crtstuff.c,
496 and it may be extended to other effects
497 needed for crtstuff.c on other systems. */
498 int flag_inhibit_size_directive = 0;
500 /* -fverbose-asm causes extra commentary information to be produced in
501 the generated assembly code (to make it more readable). This option
502 is generally only of use to those who actually need to read the
503 generated assembly code (perhaps while debugging the compiler itself). */
505 int flag_verbose_asm = 0;
507 /* -fgnu-linker specifies use of the GNU linker for initializations.
508 (Or, more generally, a linker that handles initializations.)
509 -fno-gnu-linker says that collect2 will be used. */
511 int flag_gnu_linker = 0;
513 int flag_gnu_linker = 1;
516 /* Tag all structures with __attribute__(packed) */
517 int flag_pack_struct = 0;
519 /* Table of language-independent -f options.
520 STRING is the option name. VARIABLE is the address of the variable.
521 ON_VALUE is the value to store in VARIABLE
522 if `-fSTRING' is seen as an option.
523 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */
525 struct { char *string; int *variable; int on_value;} f_options[] =
527 {"float-store", &flag_float_store, 1},
528 {"volatile", &flag_volatile, 1},
529 {"volatile-global", &flag_volatile_global, 1},
530 {"defer-pop", &flag_defer_pop, 1},
531 {"omit-frame-pointer", &flag_omit_frame_pointer, 1},
532 {"cse-follow-jumps", &flag_cse_follow_jumps, 1},
533 {"cse-skip-blocks", &flag_cse_skip_blocks, 1},
534 {"expensive-optimizations", &flag_expensive_optimizations, 1},
535 {"thread-jumps", &flag_thread_jumps, 1},
536 {"strength-reduce", &flag_strength_reduce, 1},
537 {"unroll-loops", &flag_unroll_loops, 1},
538 {"unroll-all-loops", &flag_unroll_all_loops, 1},
539 {"writable-strings", &flag_writable_strings, 1},
540 {"peephole", &flag_no_peephole, 0},
541 {"force-mem", &flag_force_mem, 1},
542 {"force-addr", &flag_force_addr, 1},
543 {"function-cse", &flag_no_function_cse, 0},
544 {"inline-functions", &flag_inline_functions, 1},
545 {"keep-inline-functions", &flag_keep_inline_functions, 1},
546 {"inline", &flag_no_inline, 0},
547 {"syntax-only", &flag_syntax_only, 1},
548 {"shared-data", &flag_shared_data, 1},
549 {"caller-saves", &flag_caller_saves, 1},
550 {"pcc-struct-return", &flag_pcc_struct_return, 1},
551 {"reg-struct-return", &flag_pcc_struct_return, 0},
552 {"delayed-branch", &flag_delayed_branch, 1},
553 {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1},
554 {"pretend-float", &flag_pretend_float, 1},
555 {"schedule-insns", &flag_schedule_insns, 1},
556 {"schedule-insns2", &flag_schedule_insns_after_reload, 1},
557 {"pic", &flag_pic, 1},
558 {"PIC", &flag_pic, 2},
559 {"fast-math", &flag_fast_math, 1},
560 {"common", &flag_no_common, 0},
561 {"inhibit-size-directive", &flag_inhibit_size_directive, 1},
562 {"verbose-asm", &flag_verbose_asm, 1},
563 {"gnu-linker", &flag_gnu_linker, 1},
564 {"pack-struct", &flag_pack_struct, 1},
565 {"bytecode", &output_bytecode, 1}
568 /* Table of language-specific options. */
570 char *lang_options[] =
573 "-fallow-single-precision",
575 "-fsigned-bitfields",
576 "-funsigned-bitfields",
577 "-fno-signed-bitfields",
578 "-fno-unsigned-bitfields",
582 "-fno-unsigned-char",
594 "-fno-cond-mismatch",
595 "-fdollars-in-identifiers",
596 "-fno-dollars-in-identifiers",
605 "-Wbad-function-cast",
606 "-Wno-bad-function-cast",
610 "-Wno-char-subscripts",
624 "-Wno-missing-braces",
625 "-Wmissing-declarations",
626 "-Wno-missing-declarations",
627 "-Wmissing-prototypes",
628 "-Wno-missing-prototypes",
630 "-Wno-nested-externs",
634 "-Wno-pointer-arith",
636 "-Wno-redundant-decls",
637 "-Wstrict-prototypes",
638 "-Wno-strict-prototypes",
644 "-Wno-write-strings",
646 /* these are for obj c */
662 /* Options controlling warnings */
664 /* Don't print warning messages. -w. */
666 int inhibit_warnings = 0;
668 /* Print various extra warnings. -W. */
670 int extra_warnings = 0;
672 /* Treat warnings as errors. -Werror. */
674 int warnings_are_errors = 0;
676 /* Nonzero to warn about unused local variables. */
680 /* Nonzero to warn about variables used before they are initialized. */
682 int warn_uninitialized;
684 /* Nonzero means warn about all declarations which shadow others. */
688 /* Warn if a switch on an enum fails to have a case for every enum value. */
692 /* Nonzero means warn about function definitions that default the return type
693 or that use a null return and have a return-type other than void. */
695 int warn_return_type;
697 /* Nonzero means warn about pointer casts that increase the required
698 alignment of the target type (and might therefore lead to a crash
699 due to a misaligned access). */
703 /* Nonzero means warn about any identifiers that match in the first N
704 characters. The value N is in `id_clash_len'. */
707 unsigned id_clash_len;
709 /* Nonzero means warn about any objects definitions whose size is larger
710 than N bytes. Also want about function definitions whose returned
711 values are larger than N bytes. The value N is in `larger_than_size'. */
713 int warn_larger_than;
714 unsigned larger_than_size;
716 /* Nonzero means warn if inline function is too large. */
720 /* Warn if a function returns an aggregate,
721 since there are often incompatible calling conventions for doing this. */
723 int warn_aggregate_return;
725 /* Likewise for -W. */
727 struct { char *string; int *variable; int on_value;} W_options[] =
729 {"unused", &warn_unused, 1},
730 {"error", &warnings_are_errors, 1},
731 {"shadow", &warn_shadow, 1},
732 {"switch", &warn_switch, 1},
733 {"aggregate-return", &warn_aggregate_return, 1},
734 {"cast-align", &warn_cast_align, 1},
735 {"uninitialized", &warn_uninitialized, 1},
736 {"inline", &warn_inline, 1}
739 /* Output files for assembler code (real compiler output)
740 and debugging dumps. */
745 FILE *jump_opt_dump_file;
747 FILE *loop_dump_file;
748 FILE *cse2_dump_file;
749 FILE *flow_dump_file;
750 FILE *combine_dump_file;
751 FILE *sched_dump_file;
752 FILE *local_reg_dump_file;
753 FILE *global_reg_dump_file;
754 FILE *sched2_dump_file;
755 FILE *jump2_opt_dump_file;
756 FILE *dbr_sched_dump_file;
757 FILE *stack_reg_dump_file;
759 /* Time accumulators, to count the total time spent in various passes. */
763 int integration_time;
771 int local_alloc_time;
772 int global_alloc_time;
775 int shorten_branch_time;
781 /* Return time used so far, in microseconds. */
791 struct rusage rusage;
796 int proc_system_time;
798 int child_system_time;
810 return (clock() * 1000);
811 #else /* not WINNT */
814 return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
817 getrusage (0, &rusage);
818 return (rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec
819 + rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec);
822 return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
828 #define TIMEVAR(VAR, BODY) \
829 do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
832 print_time (str, total)
837 "time in %s: %d.%06d\n",
838 str, total / 1000000, total % 1000000);
841 /* Count an error or warning. Return 1 if the message should be printed. */
844 count_error (warningp)
847 if (warningp && inhibit_warnings)
850 if (warningp && !warnings_are_errors)
854 static int warning_message = 0;
856 if (warningp && !warning_message)
858 fprintf (stderr, "%s: warnings being treated as errors\n", progname);
867 /* Print a fatal error message. NAME is the text.
868 Also include a system error message based on `errno'. */
871 pfatal_with_name (name)
874 fprintf (stderr, "%s: ", progname);
880 fatal_io_error (name)
883 fprintf (stderr, "%s: %s: I/O error\n", progname, name);
887 /* Called to give a better error message for a bad insn rather than
888 just calling abort(). */
891 fatal_insn (message, insn)
895 if (!output_bytecode)
901 fflush (asm_out_file);
903 fflush (aux_info_file);
905 fflush (rtl_dump_file);
906 if (jump_opt_dump_file)
907 fflush (jump_opt_dump_file);
909 fflush (cse_dump_file);
911 fflush (loop_dump_file);
913 fflush (cse2_dump_file);
915 fflush (flow_dump_file);
916 if (combine_dump_file)
917 fflush (combine_dump_file);
919 fflush (sched_dump_file);
920 if (local_reg_dump_file)
921 fflush (local_reg_dump_file);
922 if (global_reg_dump_file)
923 fflush (global_reg_dump_file);
924 if (sched2_dump_file)
925 fflush (sched2_dump_file);
926 if (jump2_opt_dump_file)
927 fflush (jump2_opt_dump_file);
928 if (dbr_sched_dump_file)
929 fflush (dbr_sched_dump_file);
930 if (stack_reg_dump_file)
931 fflush (stack_reg_dump_file);
935 /* Called to give a better error message when we don't have an insn to match
936 what we are looking for or if the insn's constraints aren't satisfied,
937 rather than just calling abort(). */
940 fatal_insn_not_found (insn)
943 if (INSN_CODE (insn) < 0)
944 fatal_insn ("internal error--unrecognizable insn:", insn);
946 fatal_insn ("internal error--insn does not satisfy its constraints:", insn);
949 /* This is the default decl_printable_name function. */
952 decl_name (decl, kind)
956 return IDENTIFIER_POINTER (DECL_NAME (decl));
959 /* This is the default interim_eh_hook function. */
962 interim_eh (finalization)
965 /* Don't do anything by default. */
968 static int need_error_newline;
970 /* Function of last error message;
971 more generally, function such that if next error message is in it
972 then we don't have to mention the function name. */
973 static tree last_error_function = NULL;
975 /* Used to detect when input_file_stack has changed since last described. */
976 static int last_error_tick;
978 /* Called when the start of a function definition is parsed,
979 this function prints on stderr the name of the function. */
982 announce_function (decl)
988 if (rtl_dump_and_exit)
989 fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
991 fprintf (stderr, " %s", (*decl_printable_name) (decl, &junk));
993 need_error_newline = 1;
994 last_error_function = current_function_decl;
998 /* The default function to print out name of current function that caused
1002 default_print_error_function (file)
1005 if (last_error_function != current_function_decl)
1007 char *kind = "function";
1008 if (current_function_decl != 0
1009 && TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
1013 fprintf (stderr, "%s: ", file);
1015 if (current_function_decl == NULL)
1016 fprintf (stderr, "At top level:\n");
1019 char *name = (*decl_printable_name) (current_function_decl, &kind);
1020 fprintf (stderr, "In %s `%s':\n", kind, name);
1023 last_error_function = current_function_decl;
1027 /* Called by report_error_function to print out function name.
1028 * Default may be overridden by language front-ends. */
1030 void (*print_error_function) PROTO((char*)) = default_print_error_function;
1032 /* Prints out, if necessary, the name of the current function
1033 that caused an error. Called from all error and warning functions. */
1036 report_error_function (file)
1039 struct file_stack *p;
1041 if (need_error_newline)
1043 fprintf (stderr, "\n");
1044 need_error_newline = 0;
1047 (*print_error_function) (file);
1049 if (input_file_stack && input_file_stack->next != 0
1050 && input_file_stack_tick != last_error_tick)
1052 fprintf (stderr, "In file included");
1053 for (p = input_file_stack->next; p; p = p->next)
1055 fprintf (stderr, " from %s:%d", p->name, p->line);
1057 fprintf (stderr, ",\n ");
1059 fprintf (stderr, ":\n");
1060 last_error_tick = input_file_stack_tick;
1064 /* Print a message. */
1067 vmessage (prefix, s, ap)
1073 fprintf (stderr, "%s: ", prefix);
1076 vfprintf (stderr, s, ap);
1079 HOST_WIDE_INT v1 = va_arg(ap, HOST_WIDE_INT);
1080 HOST_WIDE_INT v2 = va_arg(ap, HOST_WIDE_INT);
1081 HOST_WIDE_INT v3 = va_arg(ap, HOST_WIDE_INT);
1082 fprintf (stderr, s, v1, v2, v3);
1087 /* Print a message relevant to line LINE of file FILE. */
1090 v_message_with_file_and_line (file, line, prefix, s, ap)
1098 fprintf (stderr, "%s:%d: ", file, line);
1100 fprintf (stderr, "%s: ", progname);
1102 vmessage (prefix, s, ap);
1103 fputc ('\n', stderr);
1106 /* Print a message relevant to the given DECL. */
1109 v_message_with_decl (decl, prefix, s, ap)
1117 fprintf (stderr, "%s:%d: ",
1118 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
1121 fprintf (stderr, "%s: ", prefix);
1123 /* Do magic to get around lack of varargs support for insertion
1124 of arguments into existing list. We know that the decl is first;
1125 we ass_u_me that it will be printed with "%s". */
1127 for (p = s; *p; ++p)
1131 if (*(p + 1) == '%')
1138 if (p > s) /* Print the left-hand substring. */
1140 char fmt[sizeof "%.255s"];
1143 if (width > 255L) width = 255L; /* arbitrary */
1144 sprintf (fmt, "%%.%lds", width);
1145 fprintf (stderr, fmt, s);
1148 if (*p == '%') /* Print the name. */
1150 char *n = (DECL_NAME (decl)
1151 ? (*decl_printable_name) (decl, &junk)
1157 if (isalpha (*(p - 1) & 0xFF))
1162 if (*p) /* Print the rest of the message. */
1163 vmessage ((char *)NULL, p, ap);
1165 fputc ('\n', stderr);
1168 /* Figure file and line of the given INSN. */
1171 file_and_line_for_asm (insn, pfile, pline)
1176 rtx body = PATTERN (insn);
1179 /* Find the (or one of the) ASM_OPERANDS in the insn. */
1180 if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
1181 asmop = SET_SRC (body);
1182 else if (GET_CODE (body) == ASM_OPERANDS)
1184 else if (GET_CODE (body) == PARALLEL
1185 && GET_CODE (XVECEXP (body, 0, 0)) == SET)
1186 asmop = SET_SRC (XVECEXP (body, 0, 0));
1187 else if (GET_CODE (body) == PARALLEL
1188 && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
1189 asmop = XVECEXP (body, 0, 0);
1195 *pfile = ASM_OPERANDS_SOURCE_FILE (asmop);
1196 *pline = ASM_OPERANDS_SOURCE_LINE (asmop);
1200 *pfile = input_filename;
1205 /* Report an error at line LINE of file FILE. */
1208 v_error_with_file_and_line (file, line, s, ap)
1215 report_error_function (file);
1216 v_message_with_file_and_line (file, line, (char *)NULL, s, ap);
1220 error_with_file_and_line VPROTO((char *file, int line, char *s, ...))
1232 file = va_arg (ap, char *);
1233 line = va_arg (ap, int);
1234 s = va_arg (ap, char *);
1237 v_error_with_file_and_line (file, line, s, ap);
1241 /* Report an error at the declaration DECL.
1242 S is a format string which uses %s to substitute the declaration
1243 name; subsequent substitutions are a la printf. */
1246 v_error_with_decl (decl, s, ap)
1252 report_error_function (DECL_SOURCE_FILE (decl));
1253 v_message_with_decl (decl, (char *)NULL, s, ap);
1257 error_with_decl VPROTO((tree decl, char *s, ...))
1268 decl = va_arg (ap, tree);
1269 s = va_arg (ap, char *);
1272 v_error_with_decl (decl, s, ap);
1276 /* Report an error at the line number of the insn INSN.
1277 This is used only when INSN is an `asm' with operands,
1278 and each ASM_OPERANDS records its own source file and line. */
1281 v_error_for_asm (insn, s, ap)
1290 file_and_line_for_asm (insn, &file, &line);
1291 report_error_function (file);
1292 v_message_with_file_and_line (file, line, (char *)NULL, s, ap);
1296 error_for_asm VPROTO((rtx insn, char *s, ...))
1307 insn = va_arg (ap, rtx);
1308 s = va_arg (ap, char *);
1311 v_error_for_asm (insn, s, ap);
1315 /* Report an error at the current line number. */
1322 v_error_with_file_and_line (input_filename, lineno, s, ap);
1326 error VPROTO((char *s, ...))
1336 s = va_arg (ap, char *);
1343 /* Report a fatal error at the current line number. */
1355 fatal VPROTO((char *s, ...))
1365 s = va_arg (ap, char *);
1372 /* Report a warning at line LINE of file FILE. */
1375 v_warning_with_file_and_line (file, line, s, ap)
1381 if (count_error (1))
1383 report_error_function (file);
1384 v_message_with_file_and_line (file, line, "warning", s, ap);
1389 warning_with_file_and_line VPROTO((char *file, int line, char *s, ...))
1401 file = va_arg (ap, char *);
1402 line = va_arg (ap, int);
1403 s = va_arg (ap, char *);
1406 v_warning_with_file_and_line (file, line, s, ap);
1410 /* Report a warning at the declaration DECL.
1411 S is a format string which uses %s to substitute the declaration
1412 name; subsequent substitutions are a la printf. */
1415 v_warning_with_decl (decl, s, ap)
1420 if (count_error (1))
1422 report_error_function (DECL_SOURCE_FILE (decl));
1423 v_message_with_decl (decl, "warning", s, ap);
1428 warning_with_decl VPROTO((tree decl, char *s, ...))
1439 decl = va_arg (ap, tree);
1440 s = va_arg (ap, char *);
1443 v_warning_with_decl (decl, s, ap);
1447 /* Report a warning at the line number of the insn INSN.
1448 This is used only when INSN is an `asm' with operands,
1449 and each ASM_OPERANDS records its own source file and line. */
1452 v_warning_for_asm (insn, s, ap)
1457 if (count_error (1))
1462 file_and_line_for_asm (insn, &file, &line);
1463 report_error_function (file);
1464 v_message_with_file_and_line (file, line, "warning", s, ap);
1469 warning_for_asm VPROTO((rtx insn, char *s, ...))
1480 insn = va_arg (ap, rtx);
1481 s = va_arg (ap, char *);
1484 v_warning_for_asm (insn, s, ap);
1488 /* Report a warning at the current line number. */
1495 v_warning_with_file_and_line (input_filename, lineno, s, ap);
1499 warning VPROTO((char *s, ...))
1509 s = va_arg (ap, char *);
1516 /* These functions issue either warnings or errors depending on
1517 -pedantic-errors. */
1524 if (flag_pedantic_errors)
1531 pedwarn VPROTO((char *s, ...))
1541 s = va_arg (ap, char *);
1549 v_pedwarn_with_decl (decl, s, ap)
1554 /* We don't want -pedantic-errors to cause the compilation to fail from
1555 "errors" in system header files. Sometimes fixincludes can't fix what's
1556 broken (eg: unsigned char bitfields - fixing it may change the alignment
1557 which will cause programs to mysteriously fail because the C library
1558 or kernel uses the original layout). There's no point in issuing a
1559 warning either, it's just unnecessary noise. */
1561 if (! DECL_IN_SYSTEM_HEADER (decl))
1563 if (flag_pedantic_errors)
1564 v_error_with_decl (decl, s, ap);
1566 v_warning_with_decl (decl, s, ap);
1571 pedwarn_with_decl VPROTO((tree decl, char *s, ...))
1582 decl = va_arg (ap, tree);
1583 s = va_arg (ap, char *);
1586 v_pedwarn_with_decl (decl, s, ap);
1591 v_pedwarn_with_file_and_line (file, line, s, ap)
1597 if (flag_pedantic_errors)
1598 v_error_with_file_and_line (file, line, s, ap);
1600 v_warning_with_file_and_line (file, line, s, ap);
1604 pedwarn_with_file_and_line VPROTO((char *file, int line, char *s, ...))
1616 file = va_arg (ap, char *);
1617 line = va_arg (ap, int);
1618 s = va_arg (ap, char *);
1621 v_pedwarn_with_file_and_line (file, line, s, ap);
1625 /* Apologize for not implementing some feature. */
1634 fprintf (stderr, "%s:%d: ", input_filename, lineno);
1636 fprintf (stderr, "%s: ", progname);
1637 vmessage ("sorry, not implemented", s, ap);
1638 fputc ('\n', stderr);
1642 sorry VPROTO((char *s, ...))
1652 s = va_arg (ap, char *);
1659 /* Apologize for not implementing some feature, then quit. */
1662 v_really_sorry (s, ap)
1668 fprintf (stderr, "%s:%d: ", input_filename, lineno);
1670 fprintf (stderr, "%s: ", progname);
1671 vmessage ("sorry, not implemented", s, ap);
1672 fatal (" (fatal)\n");
1676 really_sorry VPROTO((char *s, ...))
1686 s = va_arg (ap, char *);
1689 v_really_sorry (s, ap);
1693 /* More 'friendly' abort that prints the line and file.
1694 config.h can #define abort fancy_abort if you like that sort of thing.
1696 I don't think this is actually a good idea.
1697 Other sorts of crashes will look a certain way.
1698 It is a good thing if crashes from calling abort look the same way.
1704 fatal ("internal gcc abort");
1707 /* This calls abort and is used to avoid problems when abort if a macro.
1708 It is used when we need to pass the address of abort. */
1716 /* When `malloc.c' is compiled with `rcheck' defined,
1717 it calls this function to report clobberage. */
1725 /* Same as `malloc' but report error if no memory available. */
1731 register char *value = (char *) malloc (size);
1733 fatal ("virtual memory exhausted");
1737 /* Same as `realloc' but report error if no memory available. */
1740 xrealloc (ptr, size)
1744 char *result = (char *) realloc (ptr, size);
1746 fatal ("virtual memory exhausted");
1750 /* Return the logarithm of X, base 2, considering X unsigned,
1751 if X is a power of 2. Otherwise, returns -1.
1753 This should be used via the `exact_log2' macro. */
1757 register unsigned HOST_WIDE_INT x;
1759 register int log = 0;
1760 /* Test for 0 or a power of 2. */
1761 if (x == 0 || x != (x & -x))
1763 while ((x >>= 1) != 0)
1768 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
1769 If X is 0, return -1.
1771 This should be used via the floor_log2 macro. */
1775 register unsigned HOST_WIDE_INT x;
1777 register int log = -1;
1785 jmp_buf float_handler;
1787 /* Specify where to longjmp to when a floating arithmetic error happens.
1788 If HANDLER is 0, it means don't handle the errors any more. */
1791 set_float_handler (handler)
1794 float_handled = (handler != 0);
1796 bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
1799 /* Specify, in HANDLER, where to longjmp to when a floating arithmetic
1800 error happens, pushing the previous specification into OLD_HANDLER.
1801 Return an indication of whether there was a previous handler in effect. */
1804 push_float_handler (handler, old_handler)
1805 jmp_buf handler, old_handler;
1807 int was_handled = float_handled;
1811 bcopy ((char *) float_handler, (char *) old_handler,
1812 sizeof (float_handler));
1814 bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
1818 /* Restore the previous specification of whether and where to longjmp to
1819 when a floating arithmetic error happens. */
1822 pop_float_handler (handled, handler)
1826 float_handled = handled;
1828 bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
1831 /* Signals actually come here. */
1834 float_signal (signo)
1835 /* If this is missing, some compilers complain. */
1838 if (float_handled == 0)
1840 #if defined (USG) || defined (hpux)
1841 signal (SIGFPE, float_signal); /* re-enable the signal catcher */
1844 signal (SIGFPE, float_signal);
1845 longjmp (float_handler, 1);
1848 /* Handler for SIGPIPE. */
1852 /* If this is missing, some compilers complain. */
1855 fatal ("output pipe has been closed");
1858 /* Strip off a legitimate source ending from the input string NAME of
1862 strip_off_ending (name, len)
1866 if (len > 2 && ! strcmp (".c", name + len - 2))
1868 else if (len > 2 && ! strcmp (".m", name + len - 2))
1870 else if (len > 2 && ! strcmp (".i", name + len - 2))
1872 else if (len > 3 && ! strcmp (".ii", name + len - 3))
1874 else if (len > 3 && ! strcmp (".co", name + len - 3))
1876 else if (len > 3 && ! strcmp (".cc", name + len - 3))
1878 else if (len > 2 && ! strcmp (".C", name + len - 2))
1880 else if (len > 4 && ! strcmp (".cxx", name + len - 4))
1882 else if (len > 4 && ! strcmp (".cpp", name + len - 4))
1884 else if (len > 2 && ! strcmp (".f", name + len - 2))
1886 /* Ada will use extensions like .ada, .adb, and .ads, so just test
1888 else if (len > 4 && ! strncmp (".ad", name + len - 4, 3))
1890 else if (len > 4 && ! strcmp (".atr", name + len - 4))
1894 /* Output a quoted string. */
1896 output_quoted_string (asm_file, string)
1902 putc ('\"', asm_file);
1903 while ((c = *string++) != 0)
1905 if (c == '\"' || c == '\\')
1906 putc ('\\', asm_file);
1909 putc ('\"', asm_file);
1912 /* Output a file name in the form wanted by System V. */
1915 output_file_directive (asm_file, input_name)
1919 int len = strlen (input_name);
1920 char *na = input_name + len;
1922 /* NA gets INPUT_NAME sans directory names. */
1923 while (na > input_name)
1930 #ifdef ASM_OUTPUT_MAIN_SOURCE_FILENAME
1931 ASM_OUTPUT_MAIN_SOURCE_FILENAME (asm_file, na);
1933 #ifdef ASM_OUTPUT_SOURCE_FILENAME
1934 ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
1936 fprintf (asm_file, "\t.file\t");
1937 output_quoted_string (asm_file, na);
1938 fputc ('\n', asm_file);
1943 /* Routine to build language identifier for object file. */
1945 output_lang_identify (asm_out_file)
1948 int len = strlen (lang_identify ()) + sizeof ("__gnu_compiled_") + 1;
1949 char *s = (char *) alloca (len);
1950 sprintf (s, "__gnu_compiled_%s", lang_identify ());
1951 ASM_OUTPUT_LABEL (asm_out_file, s);
1954 /* Routine to open a dump file. */
1956 open_dump_file (base_name, suffix)
1961 char *dumpname = (char *) alloca (strlen (base_name) + strlen (suffix) + 1);
1963 strcpy (dumpname, base_name);
1964 strcat (dumpname, suffix);
1965 f = fopen (dumpname, "w");
1967 pfatal_with_name (dumpname);
1971 /* Compile an entire file of output from cpp, named NAME.
1972 Write a file of assembly output and various debugging dumps. */
1981 int name_specified = name != 0;
1983 if (dump_base_name == 0)
1984 dump_base_name = name ? name : "gccdump";
1988 integration_time = 0;
1996 local_alloc_time = 0;
1997 global_alloc_time = 0;
2000 shorten_branch_time = 0;
2006 /* Open input file. */
2008 if (name == 0 || !strcmp (name, "-"))
2014 finput = fopen (name, "r");
2016 pfatal_with_name (name);
2018 #ifdef IO_BUFFER_SIZE
2019 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
2022 /* Initialize data in various passes. */
2027 /* Some of these really don't need to be called when generating bytecode,
2028 but the options would have to be parsed first to know that. -bson */
2030 init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
2031 || debug_info_level == DINFO_LEVEL_VERBOSE);
2033 init_decl_processing ();
2041 if (flag_caller_saves)
2042 init_caller_save ();
2044 /* If auxiliary info generation is desired, open the output file.
2045 This goes in the same directory as the source file--unlike
2046 all the other output files. */
2047 if (flag_gen_aux_info)
2049 aux_info_file = fopen (aux_info_file_name, "w");
2050 if (aux_info_file == 0)
2051 pfatal_with_name (aux_info_file_name);
2054 /* If rtl dump desired, open the output file. */
2056 rtl_dump_file = open_dump_file (dump_base_name, ".rtl");
2058 /* If jump_opt dump desired, open the output file. */
2060 jump_opt_dump_file = open_dump_file (dump_base_name, ".jump");
2062 /* If cse dump desired, open the output file. */
2064 cse_dump_file = open_dump_file (dump_base_name, ".cse");
2066 /* If loop dump desired, open the output file. */
2068 loop_dump_file = open_dump_file (dump_base_name, ".loop");
2070 /* If cse2 dump desired, open the output file. */
2072 cse2_dump_file = open_dump_file (dump_base_name, ".cse2");
2074 /* If flow dump desired, open the output file. */
2076 flow_dump_file = open_dump_file (dump_base_name, ".flow");
2078 /* If combine dump desired, open the output file. */
2080 combine_dump_file = open_dump_file (dump_base_name, ".combine");
2082 /* If scheduling dump desired, open the output file. */
2084 sched_dump_file = open_dump_file (dump_base_name, ".sched");
2086 /* If local_reg dump desired, open the output file. */
2088 local_reg_dump_file = open_dump_file (dump_base_name, ".lreg");
2090 /* If global_reg dump desired, open the output file. */
2091 if (global_reg_dump)
2092 global_reg_dump_file = open_dump_file (dump_base_name, ".greg");
2094 /* If 2nd scheduling dump desired, open the output file. */
2096 sched2_dump_file = open_dump_file (dump_base_name, ".sched2");
2098 /* If jump2_opt dump desired, open the output file. */
2100 jump2_opt_dump_file = open_dump_file (dump_base_name, ".jump2");
2102 /* If dbr_sched dump desired, open the output file. */
2104 dbr_sched_dump_file = open_dump_file (dump_base_name, ".dbr");
2108 /* If stack_reg dump desired, open the output file. */
2110 stack_reg_dump_file = open_dump_file (dump_base_name, ".stack");
2114 /* Open assembler code output file. */
2116 if (! name_specified && asm_file_name == 0)
2117 asm_out_file = stdout;
2120 int len = strlen (dump_base_name);
2121 register char *dumpname = (char *) xmalloc (len + 6);
2122 strcpy (dumpname, dump_base_name);
2123 strip_off_ending (dumpname, len);
2124 strcat (dumpname, ".s");
2125 if (asm_file_name == 0)
2127 asm_file_name = (char *) xmalloc (strlen (dumpname) + 1);
2128 strcpy (asm_file_name, dumpname);
2130 if (!strcmp (asm_file_name, "-"))
2131 asm_out_file = stdout;
2133 asm_out_file = fopen (asm_file_name, "w");
2134 if (asm_out_file == 0)
2135 pfatal_with_name (asm_file_name);
2138 #ifdef IO_BUFFER_SIZE
2139 setvbuf (asm_out_file, (char *) xmalloc (IO_BUFFER_SIZE),
2140 _IOFBF, IO_BUFFER_SIZE);
2143 input_filename = name;
2145 /* Put an entry on the input file stack for the main input file. */
2147 = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2148 input_file_stack->next = 0;
2149 input_file_stack->name = input_filename;
2151 /* Perform language-specific initialization.
2152 This may set main_input_filename. */
2155 /* If the input doesn't start with a #line, use the input name
2156 as the official input file name. */
2157 if (main_input_filename == 0)
2158 main_input_filename = name;
2160 if (!output_bytecode)
2162 ASM_FILE_START (asm_out_file);
2165 /* Output something to inform GDB that this compilation was by GCC. Also
2166 serves to tell GDB file consists of bytecodes. */
2167 if (output_bytecode)
2168 fprintf (asm_out_file, "bc_gcc2_compiled.:\n");
2171 #ifndef ASM_IDENTIFY_GCC
2172 fprintf (asm_out_file, "gcc2_compiled.:\n");
2174 ASM_IDENTIFY_GCC (asm_out_file);
2178 /* Output something to identify which front-end produced this file. */
2179 #ifdef ASM_IDENTIFY_LANGUAGE
2180 ASM_IDENTIFY_LANGUAGE (asm_out_file);
2183 if (output_bytecode)
2185 if (profile_flag || profile_block_flag)
2186 error ("profiling not supported in bytecode compilation");
2190 /* ??? Note: There used to be a conditional here
2191 to call assemble_zeros without fail if DBX_DEBUGGING_INFO is defined.
2192 This was to guarantee separation between gcc_compiled. and
2193 the first function, for the sake of dbx on Suns.
2194 However, having the extra zero here confused the Emacs
2195 code for unexec, and might confuse other programs too.
2196 Therefore, I took out that change.
2197 In future versions we should find another way to solve
2198 that dbx problem. -- rms, 23 May 93. */
2200 /* Don't let the first function fall at the same address
2201 as gcc_compiled., if profiling. */
2202 if (profile_flag || profile_block_flag)
2203 assemble_zeros (UNITS_PER_WORD);
2206 /* If dbx symbol table desired, initialize writing it
2207 and output the predefined types. */
2208 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2209 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2210 TIMEVAR (symout_time, dbxout_init (asm_out_file, main_input_filename,
2213 #ifdef SDB_DEBUGGING_INFO
2214 if (write_symbols == SDB_DEBUG)
2215 TIMEVAR (symout_time, sdbout_init (asm_out_file, main_input_filename,
2218 #ifdef DWARF_DEBUGGING_INFO
2219 if (write_symbols == DWARF_DEBUG)
2220 TIMEVAR (symout_time, dwarfout_init (asm_out_file, main_input_filename));
2223 /* Initialize yet another pass. */
2225 if (!output_bytecode)
2226 init_final (main_input_filename);
2228 start_time = get_run_time ();
2230 /* Call the parser, which parses the entire file
2231 (calling rest_of_compilation for each function). */
2233 if (yyparse () != 0)
2235 if (errorcount == 0)
2236 fprintf (stderr, "Errors detected in input file (your bison.simple is out of date)");
2238 /* In case there were missing closebraces,
2239 get us back to the global binding level. */
2240 while (! global_bindings_p ())
2244 /* Compilation is now finished except for writing
2245 what's left of the symbol table output. */
2247 parse_time += get_run_time () - start_time;
2249 parse_time -= integration_time;
2250 parse_time -= varconst_time;
2252 globals = getdecls ();
2254 /* Really define vars that have had only a tentative definition.
2255 Really output inline functions that must actually be callable
2256 and have not been output so far. */
2259 int len = list_length (globals);
2260 tree *vec = (tree *) alloca (sizeof (tree) * len);
2265 /* Process the decls in reverse order--earliest first.
2266 Put them into VEC from back to front, then take out from front. */
2268 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
2269 vec[len - i - 1] = decl;
2271 for (i = 0; i < len; i++)
2275 /* We're not deferring this any longer. */
2276 DECL_DEFER_OUTPUT (decl) = 0;
2278 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0
2279 && incomplete_decl_finalize_hook != 0)
2280 (*incomplete_decl_finalize_hook) (decl);
2283 /* Now emit any global variables or functions that we have been putting
2284 off. We need to loop in case one of the things emitted here
2285 references another one which comes earlier in the list. */
2289 for (i = 0; i < len; i++)
2293 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
2296 /* Don't write out static consts, unless we still need them.
2298 We also keep static consts if not optimizing (for debugging).
2299 ??? They might be better written into the debug information.
2300 This is possible when using DWARF.
2302 A language processor that wants static constants to be always
2303 written out (even if it is not used) is responsible for
2304 calling rest_of_decl_compilation itself. E.g. the C front-end
2305 calls rest_of_decl_compilation from finish_decl.
2306 One motivation for this is that is conventional in some
2307 environments to write things like:
2308 static const char rcsid[] = "... version string ...";
2309 intending to force the string to be in the executable.
2311 A language processor that would prefer to have unneeded
2312 static constants "optimized away" would just defer writing
2313 them out until here. E.g. C++ does this, because static
2314 constants are often defined in header files.
2316 ??? A tempting alternative (for both C and C++) would be
2317 to force a constant to be written if and only if it is
2318 defined in a main file, as opposed to an include file. */
2320 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
2321 && (! TREE_READONLY (decl)
2322 || TREE_PUBLIC (decl)
2324 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
2327 rest_of_decl_compilation (decl, NULL_PTR, 1, 1);
2330 if (TREE_CODE (decl) == FUNCTION_DECL
2331 && DECL_INITIAL (decl) != 0
2332 && DECL_SAVED_INSNS (decl) != 0
2333 && (flag_keep_inline_functions
2334 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
2337 temporary_allocation ();
2338 output_inline_function (decl);
2339 permanent_allocation (1);
2344 for (i = 0; i < len; i++)
2348 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
2349 && ! TREE_ASM_WRITTEN (decl))
2350 /* Cancel the RTL for this decl so that, if debugging info
2351 output for global variables is still to come,
2352 this one will be omitted. */
2353 DECL_RTL (decl) = NULL;
2355 /* Warn about any function
2356 declared static but not defined.
2357 We don't warn about variables,
2358 because many programs have static variables
2359 that exist only to get some text into the object file. */
2360 if (TREE_CODE (decl) == FUNCTION_DECL
2362 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
2363 && DECL_INITIAL (decl) == 0
2364 && DECL_EXTERNAL (decl)
2365 && ! TREE_PUBLIC (decl))
2367 pedwarn_with_decl (decl,
2368 "`%s' declared `static' but never defined");
2369 /* This symbol is effectively an "extern" declaration now. */
2370 TREE_PUBLIC (decl) = 1;
2371 assemble_external (decl);
2374 /* Warn about static fns or vars defined but not used,
2375 but not about inline functions or static consts
2376 since defining those in header files is normal practice. */
2378 && ((TREE_CODE (decl) == FUNCTION_DECL && ! DECL_INLINE (decl))
2379 || (TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
2380 && ! DECL_IN_SYSTEM_HEADER (decl)
2381 && ! DECL_EXTERNAL (decl)
2382 && ! TREE_PUBLIC (decl)
2383 && ! TREE_USED (decl)
2384 && ! DECL_REGISTER (decl)
2385 /* The TREE_USED bit for file-scope decls
2386 is kept in the identifier, to handle multiple
2387 external decls in different scopes. */
2388 && ! TREE_USED (DECL_NAME (decl)))
2389 warning_with_decl (decl, "`%s' defined but not used");
2391 #ifdef SDB_DEBUGGING_INFO
2392 /* The COFF linker can move initialized global vars to the end.
2393 And that can screw up the symbol ordering.
2394 By putting the symbols in that order to begin with,
2395 we avoid a problem. mcsun!unido!fauern!tumuc!pes@uunet.uu.net. */
2396 if (write_symbols == SDB_DEBUG && TREE_CODE (decl) == VAR_DECL
2397 && TREE_PUBLIC (decl) && DECL_INITIAL (decl)
2398 && ! DECL_EXTERNAL (decl)
2399 && DECL_RTL (decl) != 0)
2400 TIMEVAR (symout_time, sdbout_symbol (decl, 0));
2402 /* Output COFF information for non-global
2403 file-scope initialized variables. */
2404 if (write_symbols == SDB_DEBUG
2405 && TREE_CODE (decl) == VAR_DECL
2406 && DECL_INITIAL (decl)
2407 && ! DECL_EXTERNAL (decl)
2408 && DECL_RTL (decl) != 0
2409 && GET_CODE (DECL_RTL (decl)) == MEM)
2410 TIMEVAR (symout_time, sdbout_toplevel_data (decl));
2411 #endif /* SDB_DEBUGGING_INFO */
2412 #ifdef DWARF_DEBUGGING_INFO
2413 /* Output DWARF information for file-scope tentative data object
2414 declarations, file-scope (extern) function declarations (which
2415 had no corresponding body) and file-scope tagged type declarations
2416 and definitions which have not yet been forced out. */
2418 if (write_symbols == DWARF_DEBUG
2419 && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)))
2420 TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 1));
2425 /* Write out any pending weak symbol declarations. */
2429 /* Do dbx symbols */
2430 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2431 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2432 TIMEVAR (symout_time,
2434 dbxout_finish (asm_out_file, main_input_filename);
2438 #ifdef DWARF_DEBUGGING_INFO
2439 if (write_symbols == DWARF_DEBUG)
2440 TIMEVAR (symout_time,
2446 /* Output some stuff at end of file if nec. */
2448 if (!output_bytecode)
2450 end_final (main_input_filename);
2453 ASM_FILE_END (asm_out_file);
2457 /* Language-specific end of compilation actions. */
2461 if (output_bytecode)
2462 bc_write_file (asm_out_file);
2464 /* Close the dump files. */
2466 if (flag_gen_aux_info)
2468 fclose (aux_info_file);
2470 unlink (aux_info_file_name);
2474 fclose (rtl_dump_file);
2477 fclose (jump_opt_dump_file);
2480 fclose (cse_dump_file);
2483 fclose (loop_dump_file);
2486 fclose (cse2_dump_file);
2489 fclose (flow_dump_file);
2493 dump_combine_total_stats (combine_dump_file);
2494 fclose (combine_dump_file);
2498 fclose (sched_dump_file);
2501 fclose (local_reg_dump_file);
2503 if (global_reg_dump)
2504 fclose (global_reg_dump_file);
2507 fclose (sched2_dump_file);
2510 fclose (jump2_opt_dump_file);
2513 fclose (dbr_sched_dump_file);
2517 fclose (stack_reg_dump_file);
2520 /* Close non-debugging input and output files. Take special care to note
2521 whether fclose returns an error, since the pages might still be on the
2522 buffer chain while the file is open. */
2525 if (ferror (asm_out_file) != 0 || fclose (asm_out_file) != 0)
2526 fatal_io_error (asm_file_name);
2528 /* Print the times. */
2532 fprintf (stderr,"\n");
2533 print_time ("parse", parse_time);
2535 if (!output_bytecode)
2537 print_time ("integration", integration_time);
2538 print_time ("jump", jump_time);
2539 print_time ("cse", cse_time);
2540 print_time ("loop", loop_time);
2541 print_time ("cse2", cse2_time);
2542 print_time ("flow", flow_time);
2543 print_time ("combine", combine_time);
2544 print_time ("sched", sched_time);
2545 print_time ("local-alloc", local_alloc_time);
2546 print_time ("global-alloc", global_alloc_time);
2547 print_time ("sched2", sched2_time);
2548 print_time ("dbranch", dbr_sched_time);
2549 print_time ("shorten-branch", shorten_branch_time);
2550 print_time ("stack-reg", stack_reg_time);
2551 print_time ("final", final_time);
2552 print_time ("varconst", varconst_time);
2553 print_time ("symout", symout_time);
2554 print_time ("dump", dump_time);
2559 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
2560 and TYPE_DECL nodes.
2562 This does nothing for local (non-static) variables.
2563 Otherwise, it sets up the RTL and outputs any assembler code
2564 (label definition, storage allocation and initialization).
2566 DECL is the declaration. If ASMSPEC is nonzero, it specifies
2567 the assembler symbol name to be used. TOP_LEVEL is nonzero
2568 if this declaration is not within a function. */
2571 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
2577 /* Declarations of variables, and of functions defined elsewhere. */
2579 /* The most obvious approach, to put an #ifndef around where
2580 this macro is used, doesn't work since it's inside a macro call. */
2581 #ifndef ASM_FINISH_DECLARE_OBJECT
2582 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP, END)
2585 /* Forward declarations for nested functions are not "external",
2586 but we need to treat them as if they were. */
2587 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
2588 || TREE_CODE (decl) == FUNCTION_DECL)
2589 TIMEVAR (varconst_time,
2591 make_decl_rtl (decl, asmspec, top_level);
2592 /* Initialized extern variable exists to be replaced
2593 with its value, or represents something that will be
2594 output in another file. */
2595 if (! (TREE_CODE (decl) == VAR_DECL
2596 && DECL_EXTERNAL (decl) && TREE_READONLY (decl)
2597 && DECL_INITIAL (decl) != 0
2598 && DECL_INITIAL (decl) != error_mark_node))
2599 /* Don't output anything
2600 when a tentative file-scope definition is seen.
2601 But at end of compilation, do output code for them. */
2602 if (! (! at_end && top_level
2603 && (DECL_INITIAL (decl) == 0
2604 || DECL_INITIAL (decl) == error_mark_node)))
2605 assemble_variable (decl, top_level, at_end, 0);
2606 if (decl == last_assemble_variable_decl)
2608 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
2612 else if (DECL_REGISTER (decl) && asmspec != 0)
2614 if (decode_reg_name (asmspec) >= 0)
2616 DECL_RTL (decl) = 0;
2617 make_decl_rtl (decl, asmspec, top_level);
2620 error ("invalid register name `%s' for register variable", asmspec);
2622 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2623 else if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2624 && TREE_CODE (decl) == TYPE_DECL)
2625 TIMEVAR (symout_time, dbxout_symbol (decl, 0));
2627 #ifdef SDB_DEBUGGING_INFO
2628 else if (write_symbols == SDB_DEBUG && top_level
2629 && TREE_CODE (decl) == TYPE_DECL)
2630 TIMEVAR (symout_time, sdbout_symbol (decl, 0));
2634 /* Called after finishing a record, union or enumeral type. */
2637 rest_of_type_compilation (type, toplev)
2641 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2642 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2643 TIMEVAR (symout_time, dbxout_symbol (TYPE_STUB_DECL (type), !toplev));
2645 #ifdef SDB_DEBUGGING_INFO
2646 if (write_symbols == SDB_DEBUG)
2647 TIMEVAR (symout_time, sdbout_symbol (TYPE_STUB_DECL (type), !toplev));
2651 /* This is called from finish_function (within yyparse)
2652 after each top-level definition is parsed.
2653 It is supposed to compile that function or variable
2654 and output the assembler code for it.
2655 After we return, the tree storage is freed. */
2658 rest_of_compilation (decl)
2662 int start_time = get_run_time ();
2664 /* Nonzero if we have saved the original DECL_INITIAL of the function,
2665 to be restored after we finish compiling the function
2666 (for use when compiling inline calls to this function). */
2667 tree saved_block_tree = 0;
2668 /* Likewise, for DECL_ARGUMENTS. */
2669 tree saved_arguments = 0;
2672 if (output_bytecode)
2675 /* If we are reconsidering an inline function
2676 at the end of compilation, skip the stuff for making it inline. */
2678 if (DECL_SAVED_INSNS (decl) == 0)
2680 int specd = DECL_INLINE (decl);
2683 /* If requested, consider whether to make this function inline. */
2684 if (specd || flag_inline_functions)
2685 TIMEVAR (integration_time,
2687 lose = function_cannot_inline_p (decl);
2688 /* If not optimizing, then make sure the DECL_INLINE
2690 if (lose || ! optimize)
2692 if (warn_inline && specd)
2693 warning_with_decl (decl, lose);
2694 DECL_INLINE (decl) = 0;
2695 DECL_ABSTRACT_ORIGIN (decl) = 0;
2696 /* Don't really compile an extern inline function.
2697 If we can't make it inline, pretend
2698 it was only declared. */
2699 if (DECL_EXTERNAL (decl))
2701 DECL_INITIAL (decl) = 0;
2702 goto exit_rest_of_compilation;
2706 DECL_INLINE (decl) = 1;
2709 insns = get_insns ();
2711 /* Dump the rtl code if we are dumping rtl. */
2716 fprintf (rtl_dump_file, "\n;; Function %s\n\n",
2717 IDENTIFIER_POINTER (DECL_NAME (decl)));
2718 if (DECL_SAVED_INSNS (decl))
2719 fprintf (rtl_dump_file, ";; (integrable)\n\n");
2720 print_rtl (rtl_dump_file, insns);
2721 fflush (rtl_dump_file);
2724 /* If function is inline, and we don't yet know whether to
2725 compile it by itself, defer decision till end of compilation.
2726 finish_compilation will call rest_of_compilation again
2727 for those functions that need to be output. Also defer those
2728 functions that we are supposed to defer. */
2730 if (DECL_DEFER_OUTPUT (decl)
2731 || ((specd || DECL_INLINE (decl))
2732 && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
2733 && ! flag_keep_inline_functions)
2734 || DECL_EXTERNAL (decl))))
2736 DECL_DEFER_OUTPUT (decl) = 1;
2738 /* If -Wreturn-type, we have to do a bit of compilation. */
2739 if (! warn_return_type)
2741 #ifdef DWARF_DEBUGGING_INFO
2742 /* Generate the DWARF info for the "abstract" instance
2743 of a function which we may later generate inlined and/or
2744 out-of-line instances of. */
2745 if (write_symbols == DWARF_DEBUG)
2747 set_decl_abstract_flags (decl, 1);
2748 TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
2749 set_decl_abstract_flags (decl, 0);
2752 TIMEVAR (integration_time, save_for_inline_nocopy (decl));
2753 goto exit_rest_of_compilation;
2757 /* If we have to compile the function now, save its rtl and subdecls
2758 so that its compilation will not affect what others get. */
2759 if (DECL_INLINE (decl) || DECL_DEFER_OUTPUT (decl))
2761 #ifdef DWARF_DEBUGGING_INFO
2762 /* Generate the DWARF info for the "abstract" instance of
2763 a function which we will generate an out-of-line instance
2764 of almost immediately (and which we may also later generate
2765 various inlined instances of). */
2766 if (write_symbols == DWARF_DEBUG)
2768 set_decl_abstract_flags (decl, 1);
2769 TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
2770 set_decl_abstract_flags (decl, 0);
2773 saved_block_tree = DECL_INITIAL (decl);
2774 saved_arguments = DECL_ARGUMENTS (decl);
2775 TIMEVAR (integration_time, save_for_inline_copying (decl));
2778 /* If specified extern inline but we aren't inlining it, we are
2780 if (specd && DECL_EXTERNAL (decl))
2781 goto exit_rest_of_compilation;
2784 if (! DECL_DEFER_OUTPUT (decl))
2785 TREE_ASM_WRITTEN (decl) = 1;
2787 /* Now that integrate will no longer see our rtl, we need not distinguish
2788 between the return value of this function and the return value of called
2790 rtx_equal_function_value_matters = 0;
2792 /* Don't return yet if -Wreturn-type; we need to do jump_optimize. */
2793 if ((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
2795 goto exit_rest_of_compilation;
2798 /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
2799 Note that that may have been done above, in save_for_inline_copying.
2800 The call to resume_temporary_allocation near the end of this function
2801 goes back to the usual state of affairs. */
2803 rtl_in_current_obstack ();
2806 /* If we are doing position-independent code generation, now
2807 is the time to output special prologues and epilogues.
2808 We do not want to do this earlier, because it just clutters
2809 up inline functions with meaningless insns. */
2814 insns = get_insns ();
2816 /* Copy any shared structure that should not be shared. */
2818 unshare_all_rtl (insns);
2820 /* Instantiate all virtual registers. */
2822 instantiate_virtual_regs (current_function_decl, get_insns ());
2824 /* See if we have allocated stack slots that are not directly addressable.
2825 If so, scan all the insns and create explicit address computation
2826 for all references to such slots. */
2827 /* fixup_stack_slots (); */
2829 /* Do jump optimization the first time, if -opt.
2830 Also do it if -W, but in that case it doesn't change the rtl code,
2831 it only computes whether control can drop off the end of the function. */
2833 if (optimize > 0 || extra_warnings || warn_return_type
2834 /* If function is `noreturn', we should warn if it tries to return. */
2835 || TREE_THIS_VOLATILE (decl))
2837 TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
2838 TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1));
2841 /* Now is when we stop if -fsyntax-only and -Wreturn-type. */
2842 if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
2843 goto exit_rest_of_compilation;
2845 /* Dump rtl code after jump, if we are doing that. */
2850 fprintf (jump_opt_dump_file, "\n;; Function %s\n\n",
2851 IDENTIFIER_POINTER (DECL_NAME (decl)));
2852 print_rtl (jump_opt_dump_file, insns);
2853 fflush (jump_opt_dump_file);
2856 /* Perform common subexpression elimination.
2857 Nonzero value from `cse_main' means that jumps were simplified
2858 and some code may now be unreachable, so do
2859 jump optimization again. */
2864 fprintf (cse_dump_file, "\n;; Function %s\n\n",
2865 IDENTIFIER_POINTER (DECL_NAME (decl)));
2870 TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 1));
2872 if (flag_thread_jumps)
2873 /* Hacks by tiemann & kenner. */
2874 TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 1));
2876 TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (),
2878 TIMEVAR (cse_time, delete_dead_from_cse (insns, max_reg_num ()));
2880 if (tem || optimize > 1)
2881 TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
2884 /* Dump rtl code after cse, if we are doing that. */
2889 print_rtl (cse_dump_file, insns);
2890 fflush (cse_dump_file);
2896 fprintf (loop_dump_file, "\n;; Function %s\n\n",
2897 IDENTIFIER_POINTER (DECL_NAME (decl)));
2900 /* Move constant computations out of loops. */
2906 loop_optimize (insns, loop_dump_file);
2910 /* Dump rtl code after loop opt, if we are doing that. */
2915 print_rtl (loop_dump_file, insns);
2916 fflush (loop_dump_file);
2922 fprintf (cse2_dump_file, "\n;; Function %s\n\n",
2923 IDENTIFIER_POINTER (DECL_NAME (decl)));
2926 if (optimize > 0 && flag_rerun_cse_after_loop)
2928 /* Running another jump optimization pass before the second
2929 cse pass sometimes simplifies the RTL enough to allow
2930 the second CSE pass to do a better job. Jump_optimize can change
2931 max_reg_num so we must rerun reg_scan afterwards.
2932 ??? Rework to not call reg_scan so often. */
2933 TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0));
2934 TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1));
2936 TIMEVAR (cse2_time, reg_scan (insns, max_reg_num (), 0));
2937 TIMEVAR (cse2_time, tem = cse_main (insns, max_reg_num (),
2938 1, cse2_dump_file));
2940 TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0));
2943 if (optimize > 0 && flag_thread_jumps)
2944 /* This pass of jump threading straightens out code
2945 that was kinked by loop optimization. */
2946 TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0));
2948 /* Dump rtl code after cse, if we are doing that. */
2953 print_rtl (cse2_dump_file, insns);
2954 fflush (cse2_dump_file);
2957 /* We are no longer anticipating cse in this function, at least. */
2959 cse_not_expected = 1;
2961 /* Now we choose between stupid (pcc-like) register allocation
2962 (if we got the -noreg switch and not -opt)
2963 and smart register allocation. */
2965 if (optimize > 0) /* Stupid allocation probably won't work */
2966 obey_regdecls = 0; /* if optimizations being done. */
2970 /* Print function header into flow dump now
2971 because doing the flow analysis makes some of the dump. */
2976 fprintf (flow_dump_file, "\n;; Function %s\n\n",
2977 IDENTIFIER_POINTER (DECL_NAME (decl)));
2984 regclass (insns, max_reg_num ());
2985 stupid_life_analysis (insns, max_reg_num (),
2991 /* Do control and data flow analysis,
2992 and write some of the results to dump file. */
2994 TIMEVAR (flow_time, flow_analysis (insns, max_reg_num (),
2996 if (warn_uninitialized)
2998 uninitialized_vars_warning (DECL_INITIAL (decl));
2999 setjmp_args_warning ();
3003 /* Dump rtl after flow analysis. */
3008 print_rtl (flow_dump_file, insns);
3009 fflush (flow_dump_file);
3012 /* If -opt, try combining insns through substitution. */
3015 TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ()));
3017 /* Dump rtl code after insn combination. */
3022 fprintf (combine_dump_file, "\n;; Function %s\n\n",
3023 IDENTIFIER_POINTER (DECL_NAME (decl)));
3024 dump_combine_stats (combine_dump_file);
3025 print_rtl (combine_dump_file, insns);
3026 fflush (combine_dump_file);
3029 /* Print function header into sched dump now
3030 because doing the sched analysis makes some of the dump. */
3035 fprintf (sched_dump_file, "\n;; Function %s\n\n",
3036 IDENTIFIER_POINTER (DECL_NAME (decl)));
3039 if (optimize > 0 && flag_schedule_insns)
3041 /* Do control and data sched analysis,
3042 and write some of the results to dump file. */
3044 TIMEVAR (sched_time, schedule_insns (sched_dump_file));
3047 /* Dump rtl after instruction scheduling. */
3052 print_rtl (sched_dump_file, insns);
3053 fflush (sched_dump_file);
3056 /* Unless we did stupid register allocation,
3057 allocate pseudo-regs that are used only within 1 basic block. */
3060 TIMEVAR (local_alloc_time,
3062 regclass (insns, max_reg_num ());
3066 /* Dump rtl code after allocating regs within basic blocks. */
3071 fprintf (local_reg_dump_file, "\n;; Function %s\n\n",
3072 IDENTIFIER_POINTER (DECL_NAME (decl)));
3073 dump_flow_info (local_reg_dump_file);
3074 dump_local_alloc (local_reg_dump_file);
3075 print_rtl (local_reg_dump_file, insns);
3076 fflush (local_reg_dump_file);
3079 if (global_reg_dump)
3081 fprintf (global_reg_dump_file, "\n;; Function %s\n\n",
3082 IDENTIFIER_POINTER (DECL_NAME (decl))));
3084 /* Unless we did stupid register allocation,
3085 allocate remaining pseudo-regs, then do the reload pass
3086 fixing up any insns that are invalid. */
3088 TIMEVAR (global_alloc_time,
3091 failure = global_alloc (global_reg_dump_file);
3093 failure = reload (insns, 0, global_reg_dump_file);
3096 if (global_reg_dump)
3099 dump_global_regs (global_reg_dump_file);
3100 print_rtl (global_reg_dump_file, insns);
3101 fflush (global_reg_dump_file);
3105 goto exit_rest_of_compilation;
3107 reload_completed = 1;
3109 /* On some machines, the prologue and epilogue code, or parts thereof,
3110 can be represented as RTL. Doing so lets us schedule insns between
3111 it and the rest of the code and also allows delayed branch
3112 scheduling to operate in the epilogue. */
3114 thread_prologue_and_epilogue_insns (insns);
3116 if (optimize > 0 && flag_schedule_insns_after_reload)
3121 fprintf (sched2_dump_file, "\n;; Function %s\n\n",
3122 IDENTIFIER_POINTER (DECL_NAME (decl)));
3125 /* Do control and data sched analysis again,
3126 and write some more of the results to dump file. */
3128 TIMEVAR (sched2_time, schedule_insns (sched2_dump_file));
3130 /* Dump rtl after post-reorder instruction scheduling. */
3135 print_rtl (sched2_dump_file, insns);
3136 fflush (sched2_dump_file);
3140 #ifdef LEAF_REGISTERS
3142 if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
3146 /* One more attempt to remove jumps to .+1
3147 left by dead-store-elimination.
3148 Also do cross-jumping this time
3149 and delete no-op move insns. */
3153 TIMEVAR (jump_time, jump_optimize (insns, 1, 1, 0));
3156 /* Dump rtl code after jump, if we are doing that. */
3161 fprintf (jump2_opt_dump_file, "\n;; Function %s\n\n",
3162 IDENTIFIER_POINTER (DECL_NAME (decl)));
3163 print_rtl (jump2_opt_dump_file, insns);
3164 fflush (jump2_opt_dump_file);
3167 /* If a machine dependent reorganization is needed, call it. */
3168 #ifdef MACHINE_DEPENDENT_REORG
3169 MACHINE_DEPENDENT_REORG (insns);
3172 /* If a scheduling pass for delayed branches is to be done,
3173 call the scheduling code. */
3176 if (optimize > 0 && flag_delayed_branch)
3178 TIMEVAR (dbr_sched_time, dbr_schedule (insns, dbr_sched_dump_file));
3183 fprintf (dbr_sched_dump_file, "\n;; Function %s\n\n",
3184 IDENTIFIER_POINTER (DECL_NAME (decl)));
3185 print_rtl (dbr_sched_dump_file, insns);
3186 fflush (dbr_sched_dump_file);
3192 /* Shorten branches. */
3193 TIMEVAR (shorten_branch_time,
3195 shorten_branches (get_insns ());
3199 TIMEVAR (stack_reg_time, reg_to_stack (insns, stack_reg_dump_file));
3204 fprintf (stack_reg_dump_file, "\n;; Function %s\n\n",
3205 IDENTIFIER_POINTER (DECL_NAME (decl)));
3206 print_rtl (stack_reg_dump_file, insns);
3207 fflush (stack_reg_dump_file);
3212 /* Now turn the rtl into assembler code. */
3214 TIMEVAR (final_time,
3219 /* Get the function's name, as described by its RTL.
3220 This may be different from the DECL_NAME name used
3221 in the source file. */
3223 x = DECL_RTL (decl);
3224 if (GET_CODE (x) != MEM)
3227 if (GET_CODE (x) != SYMBOL_REF)
3229 fnname = XSTR (x, 0);
3231 assemble_start_function (decl, fnname);
3232 final_start_function (insns, asm_out_file, optimize);
3233 final (insns, asm_out_file, optimize, 0);
3234 final_end_function (insns, asm_out_file, optimize);
3235 assemble_end_function (decl, fnname);
3236 fflush (asm_out_file);
3239 /* Write DBX symbols if requested */
3241 /* Note that for those inline functions where we don't initially
3242 know for certain that we will be generating an out-of-line copy,
3243 the first invocation of this routine (rest_of_compilation) will
3244 skip over this code by doing a `goto exit_rest_of_compilation;'.
3245 Later on, finish_compilation will call rest_of_compilation again
3246 for those inline functions that need to have out-of-line copies
3247 generated. During that call, we *will* be routed past here. */
3249 #ifdef DBX_DEBUGGING_INFO
3250 if (write_symbols == DBX_DEBUG)
3251 TIMEVAR (symout_time, dbxout_function (decl));
3254 #ifdef DWARF_DEBUGGING_INFO
3255 if (write_symbols == DWARF_DEBUG)
3256 TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
3259 exit_rest_of_compilation:
3261 /* In case the function was not output,
3262 don't leave any temporary anonymous types
3263 queued up for sdb output. */
3264 #ifdef SDB_DEBUGGING_INFO
3265 if (write_symbols == SDB_DEBUG)
3266 sdbout_types (NULL_TREE);
3269 /* Put back the tree of subblocks and list of arguments
3270 from before we copied them.
3271 Code generation and the output of debugging info may have modified
3272 the copy, but the original is unchanged. */
3274 if (saved_block_tree != 0)
3275 DECL_INITIAL (decl) = saved_block_tree;
3276 if (saved_arguments != 0)
3277 DECL_ARGUMENTS (decl) = saved_arguments;
3279 reload_completed = 0;
3281 /* Clear out the real_constant_chain before some of the rtx's
3282 it runs through become garbage. */
3284 clear_const_double_mem ();
3286 /* Cancel the effect of rtl_in_current_obstack. */
3288 resume_temporary_allocation ();
3290 /* The parsing time is all the time spent in yyparse
3291 *except* what is spent in this function. */
3293 parse_time -= get_run_time () - start_time;
3296 /* Entry point of cc1/c++. Decode command args, then call compile_file.
3297 Exit code is 35 if can't open files, 34 if fatal error,
3298 33 if had nonfatal errors, else success. */
3301 main (argc, argv, envp)
3308 int flag_print_mem = 0;
3309 int version_flag = 0;
3312 /* save in case md file wants to emit args as a comment. */
3316 p = argv[0] + strlen (argv[0]);
3317 while (p != argv[0] && p[-1] != '/'
3318 #ifdef DIR_SEPARATOR
3319 && p[-1] != DIR_SEPARATOR
3326 /* Get rid of any avoidable limit on stack size. */
3330 /* Set the stack limit huge so that alloca does not fail. */
3331 getrlimit (RLIMIT_STACK, &rlim);
3332 rlim.rlim_cur = rlim.rlim_max;
3333 setrlimit (RLIMIT_STACK, &rlim);
3335 #endif /* RLIMIT_STACK */
3337 signal (SIGFPE, float_signal);
3340 signal (SIGPIPE, pipe_closed);
3343 decl_printable_name = decl_name;
3344 lang_expand_expr = (struct rtx_def *(*)()) do_abort;
3345 interim_eh_hook = interim_eh;
3347 /* Initialize whether `char' is signed. */
3348 flag_signed_char = DEFAULT_SIGNED_CHAR;
3349 #ifdef DEFAULT_SHORT_ENUMS
3350 /* Initialize how much space enums occupy, by default. */
3351 flag_short_enums = DEFAULT_SHORT_ENUMS;
3354 /* Scan to see what optimization level has been specified. That will
3355 determine the default value of many flags. */
3356 for (i = 1; i < argc; i++)
3358 if (!strcmp (argv[i], "-O"))
3362 else if (argv[i][0] == '-' && argv[i][1] == 'O')
3364 /* Handle -O2, -O3, -O69, ... */
3365 char *p = &argv[i][2];
3369 if (! (c >= '0' && c <= '9'))
3372 optimize = atoi (&argv[i][2]);
3376 obey_regdecls = (optimize == 0);
3386 flag_thread_jumps = 1;
3388 flag_delayed_branch = 1;
3390 #ifdef CAN_DEBUG_WITHOUT_FP
3391 flag_omit_frame_pointer = 1;
3397 flag_cse_follow_jumps = 1;
3398 flag_cse_skip_blocks = 1;
3399 flag_expensive_optimizations = 1;
3400 flag_strength_reduce = 1;
3401 flag_rerun_cse_after_loop = 1;
3402 flag_caller_saves = 1;
3404 #ifdef INSN_SCHEDULING
3405 flag_schedule_insns = 1;
3406 flag_schedule_insns_after_reload = 1;
3412 flag_inline_functions = 1;
3415 #ifdef OPTIMIZATION_OPTIONS
3416 /* Allow default optimizations to be specified on a per-machine basis. */
3417 OPTIMIZATION_OPTIONS (optimize);
3420 /* Initialize register usage now so switches may override. */
3424 set_target_switch ("");
3426 for (i = 1; i < argc; i++)
3429 /* If this is a language-specific option,
3430 decode it in a language-specific way. */
3431 for (j = 0; lang_options[j] != 0; j++)
3432 if (!strncmp (argv[i], lang_options[j],
3433 strlen (lang_options[j])))
3435 if (lang_options[j] != 0)
3436 /* If the option is valid for *some* language,
3437 treat it as valid even if this language doesn't understand it. */
3438 lang_decode_option (argv[i]);
3439 else if (argv[i][0] == '-' && argv[i][1] != 0)
3441 register char *str = argv[i] + 1;
3446 set_target_switch (&str[1]);
3447 else if (!strcmp (str, "dumpbase"))
3449 dump_base_name = argv[++i];
3451 else if (str[0] == 'd')
3453 register char *p = &str[1];
3461 global_reg_dump = 1;
3467 cse_dump = 1, cse2_dump = 1;
3485 global_reg_dump = 1;
3503 flag_print_asm_name = 1;
3525 rtl_dump_and_exit = 1;
3529 else if (str[0] == 'f')
3531 register char *p = &str[1];
3534 /* Some kind of -f option.
3535 P's value is the option sans `-f'.
3536 Search for it in the table of options. */
3539 !found && j < sizeof (f_options) / sizeof (f_options[0]);
3542 if (!strcmp (p, f_options[j].string))
3544 *f_options[j].variable = f_options[j].on_value;
3545 /* A goto here would be cleaner,
3546 but breaks the vax pcc. */
3549 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
3550 && ! strcmp (p+3, f_options[j].string))
3552 *f_options[j].variable = ! f_options[j].on_value;
3559 else if (!strncmp (p, "fixed-", 6))
3560 fix_register (&p[6], 1, 1);
3561 else if (!strncmp (p, "call-used-", 10))
3562 fix_register (&p[10], 0, 1);
3563 else if (!strncmp (p, "call-saved-", 11))
3564 fix_register (&p[11], 0, 0);
3566 error ("Invalid option `%s'", argv[i]);
3568 else if (str[0] == 'O')
3570 register char *p = str+1;
3571 while (*p && *p >= '0' && *p <= '9')
3576 error ("Invalid option `%s'", argv[i]);
3578 else if (!strcmp (str, "pedantic"))
3580 else if (!strcmp (str, "pedantic-errors"))
3581 flag_pedantic_errors = pedantic = 1;
3582 else if (!strcmp (str, "quiet"))
3584 else if (!strcmp (str, "version"))
3586 else if (!strcmp (str, "w"))
3587 inhibit_warnings = 1;
3588 else if (!strcmp (str, "W"))
3591 /* We save the value of warn_uninitialized, since if they put
3592 -Wuninitialized on the command line, we need to generate a
3593 warning about not using it without also specifying -O. */
3594 if (warn_uninitialized != 1)
3595 warn_uninitialized = 2;
3597 else if (str[0] == 'W')
3599 register char *p = &str[1];
3602 /* Some kind of -W option.
3603 P's value is the option sans `-W'.
3604 Search for it in the table of options. */
3607 !found && j < sizeof (W_options) / sizeof (W_options[0]);
3610 if (!strcmp (p, W_options[j].string))
3612 *W_options[j].variable = W_options[j].on_value;
3613 /* A goto here would be cleaner,
3614 but breaks the vax pcc. */
3617 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
3618 && ! strcmp (p+3, W_options[j].string))
3620 *W_options[j].variable = ! W_options[j].on_value;
3627 else if (!strncmp (p, "id-clash-", 9))
3633 if (*endp >= '0' && *endp <= '9')
3637 error ("Invalid option `%s'", argv[i]);
3642 id_clash_len = atoi (str + 10);
3645 else if (!strncmp (p, "larger-than-", 12))
3647 char *endp = p + 12;
3651 if (*endp >= '0' && *endp <= '9')
3655 error ("Invalid option `%s'", argv[i]);
3656 goto larger_than_lose;
3659 warn_larger_than = 1;
3660 larger_than_size = atoi (str + 13);
3664 error ("Invalid option `%s'", argv[i]);
3666 else if (!strcmp (str, "p"))
3668 if (!output_bytecode)
3671 error ("profiling not supported in bytecode compilation");
3673 else if (!strcmp (str, "a"))
3675 #if !defined (BLOCK_PROFILER) || !defined (FUNCTION_BLOCK_PROFILER)
3676 warning ("`-a' option (basic block profile) not supported");
3678 profile_block_flag = 1;
3681 else if (str[0] == 'g')
3688 while (*p && (*p < '0' || *p > '9'))
3692 while (*q && (*q >= '0' && *q <= '9'))
3697 level = 2; /* default debugging info level */
3698 if (*q || level > 3)
3700 warning ("invalid debug level specification in option: `-%s'",
3702 warning ("no debugging information will be generated");
3706 /* If more than one debugging type is supported,
3707 you must define PREFERRED_DEBUGGING_TYPE
3708 to choose a format in a system-dependent way. */
3709 /* This is one long line cause VAXC can't handle a \-newline. */
3710 #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) + defined (DWARF_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO))
3711 #ifdef PREFERRED_DEBUGGING_TYPE
3712 if (!strncmp (str, "ggdb", len))
3713 write_symbols = PREFERRED_DEBUGGING_TYPE;
3714 #else /* no PREFERRED_DEBUGGING_TYPE */
3715 You Lose! You must define PREFERRED_DEBUGGING_TYPE!
3716 #endif /* no PREFERRED_DEBUGGING_TYPE */
3717 #endif /* More than one debugger format enabled. */
3718 #ifdef DBX_DEBUGGING_INFO
3719 if (write_symbols != NO_DEBUG)
3721 else if (!strncmp (str, "ggdb", len))
3722 write_symbols = DBX_DEBUG;
3723 else if (!strncmp (str, "gstabs", len))
3724 write_symbols = DBX_DEBUG;
3725 else if (!strncmp (str, "gstabs+", len))
3726 write_symbols = DBX_DEBUG;
3728 /* Always enable extensions for -ggdb or -gstabs+,
3729 always disable for -gstabs.
3730 For plain -g, use system-specific default. */
3731 if (write_symbols == DBX_DEBUG && !strncmp (str, "ggdb", len)
3733 use_gnu_debug_info_extensions = 1;
3734 else if (write_symbols == DBX_DEBUG && !strncmp (str, "gstabs+", len)
3736 use_gnu_debug_info_extensions = 1;
3737 else if (write_symbols == DBX_DEBUG
3738 && !strncmp (str, "gstabs", len) && len >= 2)
3739 use_gnu_debug_info_extensions = 0;
3741 use_gnu_debug_info_extensions = DEFAULT_GDB_EXTENSIONS;
3742 #endif /* DBX_DEBUGGING_INFO */
3743 #ifdef DWARF_DEBUGGING_INFO
3744 if (write_symbols != NO_DEBUG)
3746 else if (!strncmp (str, "g", len))
3747 write_symbols = DWARF_DEBUG;
3748 else if (!strncmp (str, "ggdb", len))
3749 write_symbols = DWARF_DEBUG;
3750 else if (!strncmp (str, "gdwarf", len))
3751 write_symbols = DWARF_DEBUG;
3753 /* Always enable extensions for -ggdb or -gdwarf+,
3754 always disable for -gdwarf.
3755 For plain -g, use system-specific default. */
3756 if (write_symbols == DWARF_DEBUG && !strncmp (str, "ggdb", len)
3758 use_gnu_debug_info_extensions = 1;
3759 else if (write_symbols == DWARF_DEBUG && !strcmp (str, "gdwarf+"))
3760 use_gnu_debug_info_extensions = 1;
3761 else if (write_symbols == DWARF_DEBUG
3762 && !strncmp (str, "gdwarf", len) && len >= 2)
3763 use_gnu_debug_info_extensions = 0;
3765 use_gnu_debug_info_extensions = DEFAULT_GDB_EXTENSIONS;
3767 #ifdef SDB_DEBUGGING_INFO
3768 if (write_symbols != NO_DEBUG)
3770 else if (!strncmp (str, "g", len))
3771 write_symbols = SDB_DEBUG;
3772 else if (!strncmp (str, "gdb", len))
3773 write_symbols = SDB_DEBUG;
3774 else if (!strncmp (str, "gcoff", len))
3775 write_symbols = SDB_DEBUG;
3776 #endif /* SDB_DEBUGGING_INFO */
3777 #ifdef XCOFF_DEBUGGING_INFO
3778 if (write_symbols != NO_DEBUG)
3780 else if (!strncmp (str, "g", len))
3781 write_symbols = XCOFF_DEBUG;
3782 else if (!strncmp (str, "ggdb", len))
3783 write_symbols = XCOFF_DEBUG;
3784 else if (!strncmp (str, "gxcoff", len))
3785 write_symbols = XCOFF_DEBUG;
3787 /* Always enable extensions for -ggdb or -gxcoff+,
3788 always disable for -gxcoff.
3789 For plain -g, use system-specific default. */
3790 if (write_symbols == XCOFF_DEBUG && !strncmp (str, "ggdb", len)
3792 use_gnu_debug_info_extensions = 1;
3793 else if (write_symbols == XCOFF_DEBUG && !strcmp (str, "gxcoff+"))
3794 use_gnu_debug_info_extensions = 1;
3795 else if (write_symbols == XCOFF_DEBUG
3796 && !strncmp (str, "gxcoff", len) && len >= 2)
3797 use_gnu_debug_info_extensions = 0;
3799 use_gnu_debug_info_extensions = DEFAULT_GDB_EXTENSIONS;
3801 if (write_symbols == NO_DEBUG)
3802 warning ("`-%s' option not supported on this version of GCC", str);
3803 else if (level == 0)
3804 write_symbols = NO_DEBUG;
3806 debug_info_level = (enum debug_info_level) level;
3808 else if (!strcmp (str, "o"))
3810 asm_file_name = argv[++i];
3812 else if (str[0] == 'G')
3814 g_switch_set = TRUE;
3815 g_switch_value = atoi ((str[1] != '\0') ? str+1 : argv[++i]);
3817 else if (!strncmp (str, "aux-info", 8))
3819 flag_gen_aux_info = 1;
3820 aux_info_file_name = (str[8] != '\0' ? str+8 : argv[++i]);
3823 error ("Invalid option `%s'", argv[i]);
3825 else if (argv[i][0] == '+')
3826 error ("Invalid option `%s'", argv[i]);
3831 /* Initialize for bytecode output. A good idea to do this as soon as
3832 possible after the "-f" options have been parsed. */
3833 if (output_bytecode)
3835 #ifndef TARGET_SUPPORTS_BYTECODE
3836 /* Just die with a fatal error if not supported */
3837 fatal ("-fbytecode not supporter for this target");
3845 /* Inlining does not work if not optimizing,
3846 so force it not to be done. */
3850 /* The c_decode_option and lang_decode_option functions set
3851 this to `2' if -Wall is used, so we can avoid giving out
3852 lots of errors for people who don't realize what -Wall does. */
3853 if (warn_uninitialized == 1)
3854 warning ("-Wuninitialized is not supported without -O");
3857 #if defined(DWARF_DEBUGGING_INFO)
3858 if (write_symbols == DWARF_DEBUG
3859 && strcmp (language_string, "GNU C++") == 0)
3861 warning ("-g option not supported for C++ on SVR4 systems");
3862 write_symbols = NO_DEBUG;
3864 #endif /* defined(DWARF_DEBUGGING_INFO) */
3866 #ifdef OVERRIDE_OPTIONS
3867 /* Some machines may reject certain combinations of options. */
3871 /* Unrolling all loops implies that standard loop unrolling must also
3873 if (flag_unroll_all_loops)
3874 flag_unroll_loops = 1;
3875 /* Loop unrolling requires that strength_reduction be on also. Silently
3876 turn on strength reduction here if it isn't already on. Also, the loop
3877 unrolling code assumes that cse will be run after loop, so that must
3878 be turned on also. */
3879 if (flag_unroll_loops)
3881 flag_strength_reduce = 1;
3882 flag_rerun_cse_after_loop = 1;
3885 /* Warn about options that are not supported on this machine. */
3886 #ifndef INSN_SCHEDULING
3887 if (flag_schedule_insns || flag_schedule_insns_after_reload)
3888 warning ("instruction scheduling not supported on this target machine");
3891 if (flag_delayed_branch)
3892 warning ("this target machine does not have delayed branches");
3895 /* If we are in verbose mode, write out the version and maybe all the
3896 option flags in use. */
3899 fprintf (stderr, "%s version %s", language_string, version_string);
3900 #ifdef TARGET_VERSION
3905 #define __VERSION__ "[unknown]"
3907 fprintf (stderr, " compiled by GNU C version %s.\n", __VERSION__);
3909 fprintf (stderr, " compiled by CC.\n");
3912 print_switch_values ();
3915 compile_file (filename);
3917 #if !defined(OS2) && !defined(VMS) && !defined(WINNT)
3923 char *lim = (char *) sbrk (0);
3925 fprintf (stderr, "Data size %d.\n",
3926 lim - (char *) &environ);
3930 system ("ps -l 1>&2");
3933 #endif /* not USG */
3935 #endif /* not OS2 and not VMS and not WINNT */
3938 exit (FATAL_EXIT_CODE);
3940 exit (FATAL_EXIT_CODE);
3941 exit (SUCCESS_EXIT_CODE);
3945 /* Decode -m switches. */
3947 /* Here is a table, controlled by the tm.h file, listing each -m switch
3948 and which bits in `target_switches' it should set or clear.
3949 If VALUE is positive, it is bits to set.
3950 If VALUE is negative, -VALUE is bits to clear.
3951 (The sign bit is not used so there is no confusion.) */
3953 struct {char *name; int value;} target_switches []
3956 /* This table is similar, but allows the switch to have a value. */
3958 #ifdef TARGET_OPTIONS
3959 struct {char *prefix; char ** variable;} target_options []
3963 /* Decode the switch -mNAME. */
3966 set_target_switch (name)
3972 for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
3973 if (!strcmp (target_switches[j].name, name))
3975 if (target_switches[j].value < 0)
3976 target_flags &= ~-target_switches[j].value;
3978 target_flags |= target_switches[j].value;
3982 #ifdef TARGET_OPTIONS
3984 for (j = 0; j < sizeof target_options / sizeof target_options[0]; j++)
3986 int len = strlen (target_options[j].prefix);
3987 if (!strncmp (target_options[j].prefix, name, len))
3989 *target_options[j].variable = name + len;
3996 error ("Invalid option `%s'", name);
3999 /* Variable used for communication between the following two routines. */
4001 static int line_position;
4003 /* Print an option value and adjust the position in the line. */
4006 print_single_switch (type, name)
4009 fprintf (stderr, " %s%s", type, name);
4011 line_position += strlen (type) + strlen (name) + 1;
4013 if (line_position > 65)
4015 fprintf (stderr, "\n\t");
4020 /* Print default target switches for -version. */
4023 print_switch_values ()
4027 fprintf (stderr, "enabled:");
4030 for (j = 0; j < sizeof f_options / sizeof f_options[0]; j++)
4031 if (*f_options[j].variable == f_options[j].on_value)
4032 print_single_switch ("-f", f_options[j].string);
4034 for (j = 0; j < sizeof W_options / sizeof W_options[0]; j++)
4035 if (*W_options[j].variable == W_options[j].on_value)
4036 print_single_switch ("-W", W_options[j].string);
4038 for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
4039 if (target_switches[j].name[0] != '\0'
4040 && target_switches[j].value > 0
4041 && ((target_switches[j].value & target_flags)
4042 == target_switches[j].value))
4043 print_single_switch ("-m", target_switches[j].name);
4045 fprintf (stderr, "\n");