1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This is the top level of cc1/c++.
23 It parses command args, opens files, invokes the various passes
24 in the proper order, and counts the time used by each.
25 Error messages and low-level interface to malloc also handled here. */
28 #undef FLOAT /* This is for hpux. They should change hpux. */
29 #undef FFS /* Some systems define this in param.h. */
31 #include "coretypes.h"
35 #ifdef HAVE_SYS_RESOURCE_H
36 # include <sys/resource.h>
39 #ifdef HAVE_SYS_TIMES_H
40 # include <sys/times.h>
50 #include "insn-attr.h"
51 #include "insn-config.h"
52 #include "insn-flags.h"
53 #include "hard-reg-set.h"
60 #include "basic-block.h"
66 #include "diagnostic.h"
69 #include "dwarf2asm.h"
70 #include "integrate.h"
74 #include "langhooks.h"
75 #include "cfglayout.h"
77 #include "hosthooks.h"
81 #include "value-prof.h"
82 #include "alloc-pool.h"
83 #include "tree-mudflap.h"
85 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
86 #include "dwarf2out.h"
89 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
93 #ifdef SDB_DEBUGGING_INFO
97 #ifdef XCOFF_DEBUGGING_INFO
98 #include "xcoffout.h" /* Needed for external data
99 declarations for e.g. AIX 4.x. */
102 static void general_init (const char *);
103 static void do_compile (void);
104 static void process_options (void);
105 static void backend_init (void);
106 static int lang_dependent_init (const char *);
107 static void init_asm_output (const char *);
108 static void finalize (void);
110 static void crash_signal (int) ATTRIBUTE_NORETURN
;
111 static void setup_core_dumping (void);
112 static void compile_file (void);
114 static int print_single_switch (FILE *, int, int, const char *,
115 const char *, const char *,
116 const char *, const char *);
117 static void print_switch_values (FILE *, int, int, const char *,
118 const char *, const char *);
120 /* Nonzero to dump debug info whilst parsing (-dy option). */
121 static int set_yydebug
;
123 /* True if we don't need a backend (e.g. preprocessing only). */
124 static bool no_backend
;
126 /* Length of line when printing switch values. */
129 /* Name of program invoked, sans directories. */
131 const char *progname
;
133 /* Copy of argument vector to toplev_main. */
134 static const char **save_argv
;
136 /* Name of top-level original source file (what was input to cpp).
137 This comes from the #-command at the beginning of the actual input.
138 If there isn't any there, then this is the cc1 input file name. */
140 const char *main_input_filename
;
142 #ifndef USE_MAPPED_LOCATION
143 location_t unknown_location
= { NULL
, 0 };
146 /* Used to enable -fvar-tracking, -fweb and -frename-registers according
147 to optimize and default_debug_hooks in process_options (). */
148 #define AUTODETECT_FLAG_VAR_TRACKING 2
150 /* Current position in real source file. */
152 location_t input_location
;
154 struct line_maps line_table
;
156 /* Nonzero if it is unsafe to create any new pseudo registers. */
159 /* Stack of currently pending input files. */
161 struct file_stack
*input_file_stack
;
163 /* Incremented on each change to input_file_stack. */
164 int input_file_stack_tick
;
166 /* Name to use as base of names for dump output files. */
168 const char *dump_base_name
;
170 /* Name to use as a base for auxiliary output files. */
172 const char *aux_base_name
;
174 /* Bit flags that specify the machine subtype we are compiling for.
175 Bits are tested using macros TARGET_... defined in the tm.h file
176 and set by `-m...' switches. Must be defined in rtlanal.c. */
178 extern int target_flags
;
180 /* A mask of target_flags that includes bit X if X was set or cleared
181 on the command line. */
183 int target_flags_explicit
;
185 /* Debug hooks - dependent upon command line options. */
187 const struct gcc_debug_hooks
*debug_hooks
;
189 /* Debug hooks - target default. */
191 static const struct gcc_debug_hooks
*default_debug_hooks
;
193 /* Other flags saying which kinds of debugging dump have been requested. */
195 int rtl_dump_and_exit
;
196 int flag_print_asm_name
;
197 enum graph_dump_types graph_dump_format
;
199 /* Name for output file of assembly code, specified with -o. */
201 const char *asm_file_name
;
203 /* Nonzero means do optimizations. -O.
204 Particular numeric values stand for particular amounts of optimization;
205 thus, -O2 stores 2 here. However, the optimizations beyond the basic
206 ones are not controlled directly by this variable. Instead, they are
207 controlled by individual `flag_...' variables that are defaulted
208 based on this variable. */
212 /* Nonzero means optimize for size. -Os.
213 The only valid values are zero and nonzero. When optimize_size is
214 nonzero, optimize defaults to 2, but certain individual code
215 bloating optimizations are disabled. */
217 int optimize_size
= 0;
219 /* The FUNCTION_DECL for the function currently being compiled,
220 or 0 if between functions. */
221 tree current_function_decl
;
223 /* Set to the FUNC_BEGIN label of the current function, or NULL
225 const char * current_function_func_begin_label
;
227 /* Temporarily suppress certain warnings.
228 This is set while reading code from a system header file. */
230 int in_system_header
= 0;
232 /* Nonzero means to collect statistics which might be expensive
233 and to print them when we are done. */
234 int flag_detailed_statistics
= 0;
236 /* A random sequence of characters, unless overridden by user. */
237 const char *flag_random_seed
;
239 /* A local time stamp derived from the time of compilation. It will be
240 zero if the system cannot provide a time. It will be -1u, if the
241 user has specified a particular random seed. */
246 /* Nonzero means `char' should be signed. */
248 int flag_signed_char
;
250 /* Nonzero means give an enum type only as many bytes as it needs. A value
251 of 2 means it has not yet been initialized. */
253 int flag_short_enums
;
255 /* Nonzero if structures and unions should be returned in memory.
257 This should only be defined if compatibility with another compiler or
258 with an ABI is needed, because it results in slower code. */
260 #ifndef DEFAULT_PCC_STRUCT_RETURN
261 #define DEFAULT_PCC_STRUCT_RETURN 1
264 /* Nonzero for -fpcc-struct-return: return values the same way PCC does. */
266 int flag_pcc_struct_return
= DEFAULT_PCC_STRUCT_RETURN
;
268 /* 0 means straightforward implementation of complex divide acceptable.
269 1 means wide ranges of inputs must work for complex divide.
270 2 means C99-like requirements for complex multiply and divide. */
272 int flag_complex_method
= 1;
274 /* Nonzero means that we don't want inlining by virtue of -fno-inline,
275 not just because the tree inliner turned us off. */
277 int flag_really_no_inline
= 2;
279 /* Nonzero means we should be saving declaration info into a .X file. */
281 int flag_gen_aux_info
= 0;
283 /* Specified name of aux-info file. */
285 const char *aux_info_file_name
;
287 /* Nonzero if we are compiling code for a shared library, zero for
292 /* Set to the default thread-local storage (tls) model to use. */
294 enum tls_model flag_tls_default
= TLS_MODEL_GLOBAL_DYNAMIC
;
296 /* Nonzero means change certain warnings into errors.
297 Usually these are warnings about failure to conform to some standard. */
299 int flag_pedantic_errors
= 0;
301 /* -dA causes debug commentary information to be produced in
302 the generated assembly code (to make it more readable). This option
303 is generally only of use to those who actually need to read the
304 generated assembly code (perhaps while debugging the compiler itself).
305 Currently, this switch is only used by dwarfout.c; however, it is intended
306 to be a catchall for printing debug information in the assembler file. */
308 int flag_debug_asm
= 0;
310 /* -dP causes the rtl to be emitted as a comment in assembly. */
312 int flag_dump_rtl_in_asm
= 0;
314 /* When non-NULL, indicates that whenever space is allocated on the
315 stack, the resulting stack pointer must not pass this
316 address---that is, for stacks that grow downward, the stack pointer
317 must always be greater than or equal to this address; for stacks
318 that grow upward, the stack pointer must be less than this address.
319 At present, the rtx may be either a REG or a SYMBOL_REF, although
320 the support provided depends on the backend. */
323 /* If one, renumber instruction UIDs to reduce the number of
324 unused UIDs if there are a lot of instructions. If greater than
325 one, unconditionally renumber instruction UIDs. */
326 int flag_renumber_insns
= 1;
328 /* Nonzero if we should track variables. When
329 flag_var_tracking == AUTODETECT_FLAG_VAR_TRACKING it will be set according
330 to optimize, debug_info_level and debug_hooks in process_options (). */
331 int flag_var_tracking
= AUTODETECT_FLAG_VAR_TRACKING
;
333 /* True if the user has tagged the function with the 'section'
336 bool user_defined_section_attribute
= false;
338 /* Values of the -falign-* flags: how much to align labels in code.
339 0 means `use default', 1 means `don't align'.
340 For each variable, there is an _log variant which is the power
341 of two not less than the variable, for .align output. */
344 int align_loops_max_skip
;
346 int align_jumps_max_skip
;
347 int align_labels_log
;
348 int align_labels_max_skip
;
349 int align_functions_log
;
351 /* Like align_functions_log above, but used by front-ends to force the
352 minimum function alignment. Zero means no alignment is forced. */
353 int force_align_functions_log
;
357 const char *const string
;
361 lang_independent_options
;
363 /* Nonzero if subexpressions must be evaluated from left-to-right. */
364 int flag_evaluation_order
= 0;
366 /* The user symbol prefix after having resolved same. */
367 const char *user_label_prefix
;
369 static const param_info lang_independent_params
[] = {
370 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
371 { OPTION, DEFAULT, MIN, MAX, HELP },
372 #include "params.def"
374 { NULL
, 0, 0, 0, NULL
}
377 #ifdef TARGET_SWITCHES
378 /* Here is a table, controlled by the tm.h file, listing each -m switch
379 and which bits in `target_switches' it should set or clear.
380 If VALUE is positive, it is bits to set.
381 If VALUE is negative, -VALUE is bits to clear.
382 (The sign bit is not used so there is no confusion.) */
386 const char *const name
;
388 const char *const description
;
390 target_switches
[] = TARGET_SWITCHES
;
393 /* This table is similar, but allows the switch to have a value. */
395 #ifdef TARGET_OPTIONS
398 const char *const prefix
;
399 const char **const variable
;
400 const char *const description
;
401 const char *const value
;
403 target_options
[] = TARGET_OPTIONS
;
406 /* Output files for assembler code (real compiler output)
407 and debugging dumps. */
411 FILE *dump_file
= NULL
;
412 const char *dump_file_name
;
414 /* The current working directory of a translation. It's generally the
415 directory from which compilation was initiated, but a preprocessed
416 file may specify the original directory in which it was
419 static const char *src_pwd
;
421 /* Initialize src_pwd with the given string, and return true. If it
422 was already initialized, return false. As a special case, it may
423 be called with a NULL argument to test whether src_pwd has NOT been
427 set_src_pwd (const char *pwd
)
431 if (strcmp (src_pwd
, pwd
) == 0)
437 src_pwd
= xstrdup (pwd
);
441 /* Return the directory from which the translation unit was initiated,
442 in case set_src_pwd() was not called before to assign it a
458 /* Called when the start of a function definition is parsed,
459 this function prints on stderr the name of the function. */
461 announce_function (tree decl
)
465 if (rtl_dump_and_exit
)
466 verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl
)));
468 verbatim (" %s", lang_hooks
.decl_printable_name (decl
, 2));
470 pp_needs_newline (global_dc
->printer
) = true;
471 diagnostic_set_last_function (global_dc
);
475 /* Set up a default flag_random_seed and local_tick, unless the user
476 already specified one. */
481 if (!flag_random_seed
)
483 unsigned HOST_WIDE_INT value
;
484 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
486 /* Get some more or less random data. */
487 #ifdef HAVE_GETTIMEOFDAY
491 gettimeofday (&tv
, NULL
);
492 local_tick
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
496 time_t now
= time (NULL
);
498 if (now
!= (time_t)-1)
499 local_tick
= (unsigned) now
;
502 value
= local_tick
^ getpid ();
504 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
505 flag_random_seed
= random_seed
;
507 else if (!local_tick
)
512 /* Decode the string P as an integral parameter.
513 If the string is indeed an integer return its numeric value else
514 issue an Invalid Option error for the option PNAME and return DEFVAL.
515 If PNAME is zero just return DEFVAL, do not call error. */
518 read_integral_parameter (const char *p
, const char *pname
, const int defval
)
520 const char *endp
= p
;
533 error ("invalid option argument %qs", pname
);
540 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
541 If X is 0, return -1. */
544 floor_log2 (unsigned HOST_WIDE_INT x
)
552 t
= HOST_BITS_PER_WIDE_INT
- 1 - (int) CLZ_HWI (x
);
554 if (HOST_BITS_PER_WIDE_INT
> 64)
555 if (x
>= (unsigned HOST_WIDE_INT
) 1 << (t
+ 64))
557 if (HOST_BITS_PER_WIDE_INT
> 32)
558 if (x
>= ((unsigned HOST_WIDE_INT
) 1) << (t
+ 32))
560 if (x
>= ((unsigned HOST_WIDE_INT
) 1) << (t
+ 16))
562 if (x
>= ((unsigned HOST_WIDE_INT
) 1) << (t
+ 8))
564 if (x
>= ((unsigned HOST_WIDE_INT
) 1) << (t
+ 4))
566 if (x
>= ((unsigned HOST_WIDE_INT
) 1) << (t
+ 2))
568 if (x
>= ((unsigned HOST_WIDE_INT
) 1) << (t
+ 1))
575 /* Return the logarithm of X, base 2, considering X unsigned,
576 if X is a power of 2. Otherwise, returns -1. */
579 exact_log2 (unsigned HOST_WIDE_INT x
)
584 return x
? CTZ_HWI (x
) : -1;
586 return floor_log2 (x
);
590 /* Handler for fatal signals, such as SIGSEGV. These are transformed
591 into ICE messages, which is much more user friendly. In case the
592 error printer crashes, reset the signal to prevent infinite recursion. */
595 crash_signal (int signo
)
597 signal (signo
, SIG_DFL
);
599 /* If we crashed while processing an ASM statement, then be a little more
600 graceful. It's most likely the user's fault. */
601 if (this_is_asm_operands
)
603 output_operand_lossage ("unrecoverable error");
604 exit (FATAL_EXIT_CODE
);
607 internal_error ("%s", strsignal (signo
));
610 /* Arrange to dump core on error. (The regular error message is still
611 printed first, except in the case of abort().) */
614 setup_core_dumping (void)
617 signal (SIGABRT
, SIG_DFL
);
619 #if defined(HAVE_SETRLIMIT)
622 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
623 fatal_error ("getting core file size maximum limit: %m");
624 rlim
.rlim_cur
= rlim
.rlim_max
;
625 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
626 fatal_error ("setting core file size limit to maximum: %m");
629 diagnostic_abort_on_error (global_dc
);
633 /* Strip off a legitimate source ending from the input string NAME of
634 length LEN. Rather than having to know the names used by all of
635 our front ends, we strip off an ending of a period followed by
636 up to five characters. (Java uses ".class".) */
639 strip_off_ending (char *name
, int len
)
642 for (i
= 2; i
< 6 && len
> i
; i
++)
644 if (name
[len
- i
] == '.')
646 name
[len
- i
] = '\0';
652 /* Output a quoted string. */
655 output_quoted_string (FILE *asm_file
, const char *string
)
657 #ifdef OUTPUT_QUOTED_STRING
658 OUTPUT_QUOTED_STRING (asm_file
, string
);
662 putc ('\"', asm_file
);
663 while ((c
= *string
++) != 0)
667 if (c
== '\"' || c
== '\\')
668 putc ('\\', asm_file
);
672 fprintf (asm_file
, "\\%03o", (unsigned char) c
);
674 putc ('\"', asm_file
);
678 /* Output a file name in the form wanted by System V. */
681 output_file_directive (FILE *asm_file
, const char *input_name
)
686 if (input_name
== NULL
)
687 input_name
= "<stdin>";
689 len
= strlen (input_name
);
690 na
= input_name
+ len
;
692 /* NA gets INPUT_NAME sans directory names. */
693 while (na
> input_name
)
695 if (IS_DIR_SEPARATOR (na
[-1]))
700 #ifdef ASM_OUTPUT_SOURCE_FILENAME
701 ASM_OUTPUT_SOURCE_FILENAME (asm_file
, na
);
703 fprintf (asm_file
, "\t.file\t");
704 output_quoted_string (asm_file
, na
);
705 fputc ('\n', asm_file
);
709 /* Do any final processing required for the declarations in VEC, of
710 which there are LEN. We write out inline functions and variables
711 that have been deferred until this point, but which are required.
712 Returns nonzero if anything was put out. */
715 wrapup_global_declarations (tree
*vec
, int len
)
720 int output_something
= 0;
722 for (i
= 0; i
< len
; i
++)
726 /* We're not deferring this any longer. Assignment is
727 conditional to avoid needlessly dirtying PCH pages. */
728 if (DECL_DEFER_OUTPUT (decl
) != 0)
729 DECL_DEFER_OUTPUT (decl
) = 0;
731 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_SIZE (decl
) == 0)
732 lang_hooks
.finish_incomplete_decl (decl
);
735 /* Now emit any global variables or functions that we have been
736 putting off. We need to loop in case one of the things emitted
737 here references another one which comes earlier in the list. */
741 for (i
= 0; i
< len
; i
++)
745 if (TREE_ASM_WRITTEN (decl
) || DECL_EXTERNAL (decl
))
748 /* Don't write out static consts, unless we still need them.
750 We also keep static consts if not optimizing (for debugging),
751 unless the user specified -fno-keep-static-consts.
752 ??? They might be better written into the debug information.
753 This is possible when using DWARF.
755 A language processor that wants static constants to be always
756 written out (even if it is not used) is responsible for
757 calling rest_of_decl_compilation itself. E.g. the C front-end
758 calls rest_of_decl_compilation from finish_decl.
759 One motivation for this is that is conventional in some
760 environments to write things like:
761 static const char rcsid[] = "... version string ...";
762 intending to force the string to be in the executable.
764 A language processor that would prefer to have unneeded
765 static constants "optimized away" would just defer writing
766 them out until here. E.g. C++ does this, because static
767 constants are often defined in header files.
769 ??? A tempting alternative (for both C and C++) would be
770 to force a constant to be written if and only if it is
771 defined in a main file, as opposed to an include file. */
773 if (TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
775 struct cgraph_varpool_node
*node
;
777 node
= cgraph_varpool_node (decl
);
781 else if (node
->alias
)
783 else if (!cgraph_global_info_ready
785 || TREE_USED (DECL_ASSEMBLER_NAME (decl
))))
787 else if (node
->needed
)
789 else if (DECL_COMDAT (decl
))
791 else if (TREE_READONLY (decl
) && !TREE_PUBLIC (decl
)
792 && (optimize
|| !flag_keep_static_consts
793 || DECL_ARTIFICIAL (decl
)))
799 rest_of_decl_compilation (decl
, 1, 1);
805 output_something
= 1;
809 return output_something
;
812 /* Issue appropriate warnings for the global declarations in VEC (of
813 which there are LEN). Output debugging information for them. */
816 check_global_declarations (tree
*vec
, int len
)
821 for (i
= 0; i
< len
; i
++)
825 /* Do not emit debug information about variables that are in
826 static storage, but not defined. */
827 if (TREE_CODE (decl
) == VAR_DECL
828 && TREE_STATIC (decl
)
829 && !TREE_ASM_WRITTEN (decl
))
830 DECL_IGNORED_P (decl
) = 1;
832 /* Warn about any function
833 declared static but not defined.
834 We don't warn about variables,
835 because many programs have static variables
836 that exist only to get some text into the object file. */
837 if (TREE_CODE (decl
) == FUNCTION_DECL
838 && DECL_INITIAL (decl
) == 0
839 && DECL_EXTERNAL (decl
)
840 && ! DECL_ARTIFICIAL (decl
)
841 && ! TREE_NO_WARNING (decl
)
842 && ! TREE_PUBLIC (decl
)
843 && (warn_unused_function
844 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))))
846 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
847 pedwarn ("%J%qF used but never defined", decl
, decl
);
849 warning (0, "%J%qF declared %<static%> but never defined",
851 /* This symbol is effectively an "extern" declaration now. */
852 TREE_PUBLIC (decl
) = 1;
853 assemble_external (decl
);
856 /* Warn about static fns or vars defined but not used. */
857 if (((warn_unused_function
&& TREE_CODE (decl
) == FUNCTION_DECL
)
858 /* We don't warn about "static const" variables because the
859 "rcs_id" idiom uses that construction. */
860 || (warn_unused_variable
861 && TREE_CODE (decl
) == VAR_DECL
&& ! TREE_READONLY (decl
)))
862 && ! DECL_IN_SYSTEM_HEADER (decl
)
863 && ! TREE_USED (decl
)
864 /* The TREE_USED bit for file-scope decls is kept in the identifier,
865 to handle multiple external decls in different scopes. */
866 && ! TREE_USED (DECL_NAME (decl
))
867 && ! DECL_EXTERNAL (decl
)
868 && ! TREE_PUBLIC (decl
)
869 /* A volatile variable might be used in some non-obvious way. */
870 && ! TREE_THIS_VOLATILE (decl
)
871 /* Global register variables must be declared to reserve them. */
872 && ! (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
873 /* Otherwise, ask the language. */
874 && lang_hooks
.decls
.warn_unused_global (decl
))
875 warning (0, "%J%qD defined but not used", decl
, decl
);
877 /* Avoid confusing the debug information machinery when there are
879 if (errorcount
== 0 && sorrycount
== 0)
881 timevar_push (TV_SYMOUT
);
882 (*debug_hooks
->global_decl
) (decl
);
883 timevar_pop (TV_SYMOUT
);
888 /* Warn about a use of an identifier which was marked deprecated. */
890 warn_deprecated_use (tree node
)
892 if (node
== 0 || !warn_deprecated_decl
)
897 expanded_location xloc
= expand_location (DECL_SOURCE_LOCATION (node
));
898 warning (0, "%qs is deprecated (declared at %s:%d)",
899 IDENTIFIER_POINTER (DECL_NAME (node
)),
900 xloc
.file
, xloc
.line
);
902 else if (TYPE_P (node
))
904 const char *what
= NULL
;
905 tree decl
= TYPE_STUB_DECL (node
);
907 if (TYPE_NAME (node
))
909 if (TREE_CODE (TYPE_NAME (node
)) == IDENTIFIER_NODE
)
910 what
= IDENTIFIER_POINTER (TYPE_NAME (node
));
911 else if (TREE_CODE (TYPE_NAME (node
)) == TYPE_DECL
912 && DECL_NAME (TYPE_NAME (node
)))
913 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node
)));
918 expanded_location xloc
919 = expand_location (DECL_SOURCE_LOCATION (decl
));
921 warning (0, "%qs is deprecated (declared at %s:%d)", what
,
922 xloc
.file
, xloc
.line
);
924 warning (0, "type is deprecated (declared at %s:%d)",
925 xloc
.file
, xloc
.line
);
930 warning (0, "%qs is deprecated", what
);
932 warning (0, "type is deprecated");
937 /* Save the current INPUT_LOCATION on the top entry in the
938 INPUT_FILE_STACK. Push a new entry for FILE and LINE, and set the
939 INPUT_LOCATION accordingly. */
942 #ifdef USE_MAPPED_LOCATION
943 push_srcloc (location_t fline
)
945 push_srcloc (const char *file
, int line
)
948 struct file_stack
*fs
;
950 fs
= xmalloc (sizeof (struct file_stack
));
951 fs
->location
= input_location
;
952 fs
->next
= input_file_stack
;
953 #ifdef USE_MAPPED_LOCATION
954 input_location
= fline
;
956 input_filename
= file
;
959 input_file_stack
= fs
;
960 input_file_stack_tick
++;
963 /* Pop the top entry off the stack of presently open source files.
964 Restore the INPUT_LOCATION from the new topmost entry on the
970 struct file_stack
*fs
;
972 fs
= input_file_stack
;
973 input_location
= fs
->location
;
974 input_file_stack
= fs
->next
;
976 input_file_stack_tick
++;
979 /* Compile an entire translation unit. Write a file of assembly
980 output and various debugging dumps. */
985 /* Initialize yet another pass. */
988 init_final (main_input_filename
);
989 coverage_init (aux_base_name
);
991 timevar_push (TV_PARSE
);
993 /* Call the parser, which parses the entire file (calling
994 rest_of_compilation for each function). */
995 lang_hooks
.parse_file (set_yydebug
);
997 /* In case there were missing block closers,
998 get us back to the global binding level. */
999 lang_hooks
.clear_binding_stack ();
1001 /* Compilation is now finished except for writing
1002 what's left of the symbol table output. */
1003 timevar_pop (TV_PARSE
);
1005 if (flag_syntax_only
)
1008 lang_hooks
.decls
.final_write_globals ();
1009 cgraph_varpool_assemble_pending_decls ();
1010 finish_aliases_2 ();
1012 /* This must occur after the loop to output deferred functions.
1013 Else the coverage initializer would not be emitted if all the
1014 functions in this compilation unit were deferred. */
1017 /* Likewise for mudflap static object registrations. */
1019 mudflap_finish_file ();
1021 /* Write out any pending weak symbol declarations. */
1025 /* Do dbx symbols. */
1026 timevar_push (TV_SYMOUT
);
1028 #ifdef DWARF2_UNWIND_INFO
1029 if (dwarf2out_do_frame ())
1030 dwarf2out_frame_finish ();
1033 (*debug_hooks
->finish
) (main_input_filename
);
1034 timevar_pop (TV_SYMOUT
);
1036 /* Output some stuff at end of file if nec. */
1038 dw2_output_indirect_constants ();
1040 /* Flush any pending external directives. cgraph did this for
1041 assemble_external calls from the front end, but the RTL
1042 expander can also generate them. */
1043 process_pending_assemble_externals ();
1045 /* Attach a special .ident directive to the end of the file to identify
1046 the version of GCC which compiled this code. The format of the .ident
1047 string is patterned after the ones produced by native SVR4 compilers. */
1050 fprintf (asm_out_file
, "%s\"GCC: (GNU) %s\"\n",
1051 IDENT_ASM_OP
, version_string
);
1054 /* This must be at the end. Some target ports emit end of file directives
1055 into the assembly file here, and hence we can not output anything to the
1056 assembly file after this point. */
1057 targetm
.asm_out
.file_end ();
1060 /* Display help for target options. */
1062 display_target_options (void)
1065 #if defined (TARGET_SWITCHES) || defined (TARGET_OPTIONS)
1069 static bool displayed
= false;
1071 /* Avoid double printing for --help --target-help. */
1077 for (cli
= 0; cli
< cl_options_count
; cli
++)
1078 if ((cl_options
[cli
].flags
& (CL_TARGET
| CL_UNDOCUMENTED
)) == CL_TARGET
)
1081 if (cli
< cl_options_count
1082 #ifdef TARGET_SWITCHES
1083 || ARRAY_SIZE (target_switches
) > 1
1085 #ifdef TARGET_OPTIONS
1086 || ARRAY_SIZE (target_options
) > 1
1090 int doc
= cli
< cl_options_count
;
1094 printf (_("\nTarget specific options:\n"));
1096 #ifdef TARGET_SWITCHES
1097 for (i
= ARRAY_SIZE (target_switches
); i
--;)
1099 const char *option
= target_switches
[i
].name
;
1100 const char *description
= target_switches
[i
].description
;
1102 if (option
== NULL
|| *option
== 0)
1104 else if (description
== NULL
)
1109 printf (_(" -m%-23s [undocumented]\n"), option
);
1111 else if (*description
!= 0)
1112 doc
+= printf (" -m%-23s %s\n", option
, _(description
));
1116 #ifdef TARGET_OPTIONS
1117 for (i
= ARRAY_SIZE (target_options
); i
--;)
1119 const char *option
= target_options
[i
].prefix
;
1120 const char *description
= target_options
[i
].description
;
1122 if (option
== NULL
|| *option
== 0)
1124 else if (description
== NULL
)
1129 printf (_(" -m%-23s [undocumented]\n"), option
);
1131 else if (*description
!= 0)
1132 doc
+= printf (" -m%-23s %s\n", option
, _(description
));
1135 print_filtered_help (CL_TARGET
);
1139 printf (_("\nThere are undocumented target specific options as well.\n"));
1141 printf (_(" They exist, but they are not documented.\n"));
1146 /* Parse a -d... command line switch. */
1149 decode_d_option (const char *arg
)
1160 flag_print_asm_name
= 1;
1163 flag_dump_rtl_in_asm
= 1;
1164 flag_print_asm_name
= 1;
1167 graph_dump_format
= vcg
;
1170 rtl_dump_and_exit
= 1;
1175 case 'D': /* These are handled by the preprocessor. */
1179 setup_core_dumping();
1184 if (!enable_rtl_dump_file (c
))
1185 warning (0, "unrecognized gcc debugging option: %c", c
);
1190 /* Indexed by enum debug_info_type. */
1191 const char *const debug_type_names
[] =
1193 "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
1196 /* Decode -m switches. */
1197 /* Decode the switch -mNAME. */
1200 set_target_switch (const char *name
)
1202 #if defined (TARGET_SWITCHES) || defined (TARGET_OPTIONS)
1205 int valid_target_option
= 0;
1207 #ifdef TARGET_SWITCHES
1208 for (j
= 0; j
< ARRAY_SIZE (target_switches
); j
++)
1209 if (!strcmp (target_switches
[j
].name
, name
))
1211 if (target_switches
[j
].value
< 0)
1212 target_flags
&= ~-target_switches
[j
].value
;
1214 target_flags
|= target_switches
[j
].value
;
1217 if (target_switches
[j
].value
< 0)
1218 target_flags_explicit
|= -target_switches
[j
].value
;
1220 target_flags_explicit
|= target_switches
[j
].value
;
1222 valid_target_option
= 1;
1226 #ifdef TARGET_OPTIONS
1227 if (!valid_target_option
)
1228 for (j
= 0; j
< ARRAY_SIZE (target_options
); j
++)
1230 int len
= strlen (target_options
[j
].prefix
);
1231 if (target_options
[j
].value
)
1233 if (!strcmp (target_options
[j
].prefix
, name
))
1235 *target_options
[j
].variable
= target_options
[j
].value
;
1236 valid_target_option
= 1;
1241 if (!strncmp (target_options
[j
].prefix
, name
, len
))
1243 *target_options
[j
].variable
= name
+ len
;
1244 valid_target_option
= 1;
1250 if (name
[0] != 0 && !valid_target_option
)
1251 error ("invalid option %qs", name
);
1254 /* Print version information to FILE.
1255 Each line begins with INDENT (for the case where FILE is the
1256 assembler output file). */
1259 print_version (FILE *file
, const char *indent
)
1262 #define __VERSION__ "[?]"
1266 "%s%s%s version %s (%s)\n%s\tcompiled by GNU C version %s.\n"
1268 "%s%s%s version %s (%s) compiled by CC.\n"
1270 , indent
, *indent
!= 0 ? " " : "",
1271 lang_hooks
.name
, version_string
, TARGET_NAME
,
1272 indent
, __VERSION__
);
1273 fnotice (file
, "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n",
1274 indent
, *indent
!= 0 ? " " : "",
1275 PARAM_VALUE (GGC_MIN_EXPAND
), PARAM_VALUE (GGC_MIN_HEAPSIZE
));
1278 /* Print an option value and return the adjusted position in the line.
1279 ??? We don't handle error returns from fprintf (disk full); presumably
1280 other code will catch a disk full though. */
1283 print_single_switch (FILE *file
, int pos
, int max
,
1284 const char *indent
, const char *sep
, const char *term
,
1285 const char *type
, const char *name
)
1287 /* The ultrix fprintf returns 0 on success, so compute the result we want
1288 here since we need it for the following test. */
1289 int len
= strlen (sep
) + strlen (type
) + strlen (name
);
1294 fprintf (file
, "%s", term
);
1299 fprintf (file
, "%s", indent
);
1300 pos
= strlen (indent
);
1302 fprintf (file
, "%s%s%s", sep
, type
, name
);
1307 /* Print active target switches to FILE.
1308 POS is the current cursor position and MAX is the size of a "line".
1309 Each line begins with INDENT and ends with TERM.
1310 Each switch is separated from the next by SEP. */
1313 print_switch_values (FILE *file
, int pos
, int max
,
1314 const char *indent
, const char *sep
, const char *term
)
1319 /* Fill in the -frandom-seed option, if the user didn't pass it, so
1320 that it can be printed below. This helps reproducibility. */
1323 /* Print the options as passed. */
1324 pos
= print_single_switch (file
, pos
, max
, indent
, *indent
? " " : "", term
,
1325 _("options passed: "), "");
1327 for (p
= &save_argv
[1]; *p
!= NULL
; p
++)
1331 if (strcmp (*p
, "-o") == 0)
1337 if (strcmp (*p
, "-quiet") == 0)
1339 if (strcmp (*p
, "-version") == 0)
1344 pos
= print_single_switch (file
, pos
, max
, indent
, sep
, term
, *p
, "");
1347 fprintf (file
, "%s", term
);
1349 /* Print the -f and -m options that have been enabled.
1350 We don't handle language specific options but printing argv
1353 pos
= print_single_switch (file
, 0, max
, indent
, *indent
? " " : "", term
,
1354 _("options enabled: "), "");
1356 for (j
= 0; j
< cl_options_count
; j
++)
1357 if ((cl_options
[j
].flags
& CL_REPORT
)
1358 && option_enabled (j
) > 0)
1359 pos
= print_single_switch (file
, pos
, max
, indent
, sep
, term
,
1360 "", cl_options
[j
].opt_text
);
1362 /* Print target specific options. */
1364 #ifdef TARGET_SWITCHES
1365 for (j
= 0; j
< ARRAY_SIZE (target_switches
); j
++)
1366 if (target_switches
[j
].name
[0] != '\0'
1367 && target_switches
[j
].value
> 0
1368 && ((target_switches
[j
].value
& target_flags
)
1369 == target_switches
[j
].value
))
1371 pos
= print_single_switch (file
, pos
, max
, indent
, sep
, term
,
1372 "-m", target_switches
[j
].name
);
1376 #ifdef TARGET_OPTIONS
1377 for (j
= 0; j
< ARRAY_SIZE (target_options
); j
++)
1378 if (*target_options
[j
].variable
!= NULL
)
1381 sprintf (prefix
, "-m%s", target_options
[j
].prefix
);
1382 pos
= print_single_switch (file
, pos
, max
, indent
, sep
, term
,
1383 prefix
, *target_options
[j
].variable
);
1387 fprintf (file
, "%s", term
);
1390 /* Open assembly code output file. Do this even if -fsyntax-only is
1391 on, because then the driver will have provided the name of a
1392 temporary file or bit bucket for us. NAME is the file specified on
1393 the command line, possibly NULL. */
1395 init_asm_output (const char *name
)
1397 if (name
== NULL
&& asm_file_name
== 0)
1398 asm_out_file
= stdout
;
1401 if (asm_file_name
== 0)
1403 int len
= strlen (dump_base_name
);
1404 char *dumpname
= xmalloc (len
+ 6);
1405 memcpy (dumpname
, dump_base_name
, len
+ 1);
1406 strip_off_ending (dumpname
, len
);
1407 strcat (dumpname
, ".s");
1408 asm_file_name
= dumpname
;
1410 if (!strcmp (asm_file_name
, "-"))
1411 asm_out_file
= stdout
;
1413 asm_out_file
= fopen (asm_file_name
, "w+b");
1414 if (asm_out_file
== 0)
1415 fatal_error ("can%'t open %s for writing: %m", asm_file_name
);
1418 if (!flag_syntax_only
)
1420 targetm
.asm_out
.file_start ();
1422 #ifdef ASM_COMMENT_START
1423 if (flag_verbose_asm
)
1425 /* Print the list of options in effect. */
1426 print_version (asm_out_file
, ASM_COMMENT_START
);
1427 print_switch_values (asm_out_file
, 0, MAX_LINE
,
1428 ASM_COMMENT_START
, " ", "\n");
1429 /* Add a blank line here so it appears in assembler output but not
1431 fprintf (asm_out_file
, "\n");
1437 /* Default version of get_pch_validity.
1438 By default, every flag difference is fatal; that will be mostly right for
1439 most targets, but completely right for very few. */
1442 default_get_pch_validity (size_t *len
)
1444 #ifdef TARGET_OPTIONS
1449 *len
= sizeof (target_flags
) + 2;
1450 #ifdef TARGET_OPTIONS
1451 for (i
= 0; i
< ARRAY_SIZE (target_options
); i
++)
1454 if (*target_options
[i
].variable
)
1455 *len
+= strlen (*target_options
[i
].variable
);
1459 result
= r
= xmalloc (*len
);
1463 memcpy (r
, &target_flags
, sizeof (target_flags
));
1464 r
+= sizeof (target_flags
);
1466 #ifdef TARGET_OPTIONS
1467 for (i
= 0; i
< ARRAY_SIZE (target_options
); i
++)
1469 const char *str
= *target_options
[i
].variable
;
1473 l
= strlen (str
) + 1;
1482 /* Default version of pch_valid_p. */
1485 default_pch_valid_p (const void *data_p
, size_t len
)
1487 const char *data
= (const char *)data_p
;
1488 const char *flag_that_differs
= NULL
;
1491 /* -fpic and -fpie also usually make a PCH invalid. */
1492 if (data
[0] != flag_pic
)
1493 return _("created and used with different settings of -fpic");
1494 if (data
[1] != flag_pie
)
1495 return _("created and used with different settings of -fpie");
1498 /* Check target_flags. */
1499 if (memcmp (data
, &target_flags
, sizeof (target_flags
)) != 0)
1503 memcpy (&tf
, data
, sizeof (target_flags
));
1504 #ifdef TARGET_SWITCHES
1505 for (i
= 0; i
< ARRAY_SIZE (target_switches
); i
++)
1509 bits
= target_switches
[i
].value
;
1512 if ((target_flags
& bits
) != (tf
& bits
))
1514 flag_that_differs
= target_switches
[i
].name
;
1519 for (i
= 0; i
< cl_options_count
; i
++)
1520 if (cl_options
[i
].flag_var
== &target_flags
1521 && (cl_options
[i
].var_value
& (target_flags
^ tf
)) != 0)
1523 flag_that_differs
= cl_options
[i
].opt_text
+ 2;
1528 data
+= sizeof (target_flags
);
1529 len
-= sizeof (target_flags
);
1531 /* Check string options. */
1532 #ifdef TARGET_OPTIONS
1533 for (i
= 0; i
< ARRAY_SIZE (target_options
); i
++)
1535 const char *str
= *target_options
[i
].variable
;
1539 l
= strlen (str
) + 1;
1540 if (len
< l
|| memcmp (data
, str
, l
) != 0)
1542 flag_that_differs
= target_options
[i
].prefix
;
1555 asprintf (&r
, _("created and used with differing settings of '-m%s'"),
1558 return _("out of memory");
1563 /* Default tree printer. Handles declarations only. */
1565 default_tree_printer (pretty_printer
* pp
, text_info
*text
)
1569 switch (*text
->format_spec
)
1572 t
= va_arg (*text
->args_ptr
, tree
);
1573 if (DECL_DEBUG_EXPR (t
) && DECL_DEBUG_EXPR_IS_FROM (t
))
1574 t
= DECL_DEBUG_EXPR (t
);
1579 t
= va_arg (*text
->args_ptr
, tree
);
1588 const char *n
= DECL_NAME (t
)
1589 ? lang_hooks
.decl_printable_name (t
, 2)
1594 dump_generic_node (pp
, t
, 0, 0, 0);
1599 /* Initialization of the front end environment, before command line
1600 options are parsed. Signal handlers, internationalization etc.
1601 ARGV0 is main's argv[0]. */
1603 general_init (const char *argv0
)
1607 p
= argv0
+ strlen (argv0
);
1608 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
1612 xmalloc_set_program_name (progname
);
1616 /* Unlock the stdio streams. */
1617 unlock_std_streams ();
1619 gcc_init_libintl ();
1621 /* Initialize the diagnostics reporting machinery, so option parsing
1622 can give warnings and errors. */
1623 diagnostic_initialize (global_dc
);
1624 /* Set a default printer. Language specific initializations will
1625 override it later. */
1626 pp_format_decoder (global_dc
->printer
) = &default_tree_printer
;
1628 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
1630 signal (SIGSEGV
, crash_signal
);
1633 signal (SIGILL
, crash_signal
);
1636 signal (SIGBUS
, crash_signal
);
1639 signal (SIGABRT
, crash_signal
);
1641 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1642 signal (SIGIOT
, crash_signal
);
1645 signal (SIGFPE
, crash_signal
);
1648 /* Other host-specific signal setup. */
1649 (*host_hooks
.extra_signals
)();
1651 /* Initialize the garbage-collector, string pools and tree type hash
1655 linemap_init (&line_table
);
1658 /* Initialize register usage now so switches may override. */
1661 /* Register the language-independent parameters. */
1662 add_params (lang_independent_params
, LAST_PARAM
);
1664 /* This must be done after add_params but before argument processing. */
1665 init_ggc_heuristics();
1666 init_tree_optimization_passes ();
1669 /* Process the options that have been parsed. */
1671 process_options (void)
1673 /* Allow the front end to perform consistency checks and do further
1674 initialization based on the command line options. This hook also
1675 sets the original filename if appropriate (e.g. foo.i -> foo.c)
1676 so we can correctly initialize debug output. */
1677 no_backend
= lang_hooks
.post_options (&main_input_filename
);
1678 #ifndef USE_MAPPED_LOCATION
1679 input_filename
= main_input_filename
;
1682 #ifdef OVERRIDE_OPTIONS
1683 /* Some machines may reject certain combinations of options. */
1687 if (flag_short_enums
== 2)
1688 flag_short_enums
= targetm
.default_short_enums ();
1690 /* Set aux_base_name if not already set. */
1693 else if (main_input_filename
)
1695 char *name
= xstrdup (lbasename (main_input_filename
));
1697 strip_off_ending (name
, strlen (name
));
1698 aux_base_name
= name
;
1701 aux_base_name
= "gccaux";
1703 /* Set up the align_*_log variables, defaulting them to 1 if they
1704 were still unset. */
1705 if (align_loops
<= 0) align_loops
= 1;
1706 if (align_loops_max_skip
> align_loops
|| !align_loops
)
1707 align_loops_max_skip
= align_loops
- 1;
1708 align_loops_log
= floor_log2 (align_loops
* 2 - 1);
1709 if (align_jumps
<= 0) align_jumps
= 1;
1710 if (align_jumps_max_skip
> align_jumps
|| !align_jumps
)
1711 align_jumps_max_skip
= align_jumps
- 1;
1712 align_jumps_log
= floor_log2 (align_jumps
* 2 - 1);
1713 if (align_labels
<= 0) align_labels
= 1;
1714 align_labels_log
= floor_log2 (align_labels
* 2 - 1);
1715 if (align_labels_max_skip
> align_labels
|| !align_labels
)
1716 align_labels_max_skip
= align_labels
- 1;
1717 if (align_functions
<= 0) align_functions
= 1;
1718 align_functions_log
= floor_log2 (align_functions
* 2 - 1);
1720 /* Unrolling all loops implies that standard loop unrolling must also
1722 if (flag_unroll_all_loops
)
1723 flag_unroll_loops
= 1;
1725 /* The loop unrolling code assumes that cse will be run after loop. */
1726 if (flag_unroll_loops
|| flag_peel_loops
)
1727 flag_rerun_cse_after_loop
= 1;
1729 /* If explicitly asked to run new loop optimizer, switch off the old
1731 if (flag_loop_optimize2
)
1732 flag_loop_optimize
= 0;
1734 /* Enable new loop optimizer pass if any of its optimizations is called. */
1735 if (flag_move_loop_invariants
1736 || flag_unswitch_loops
1738 || flag_unroll_loops
1739 || flag_branch_on_count_reg
)
1740 flag_loop_optimize2
= 1;
1742 if (flag_non_call_exceptions
)
1743 flag_asynchronous_unwind_tables
= 1;
1744 if (flag_asynchronous_unwind_tables
)
1745 flag_unwind_tables
= 1;
1747 /* Disable unit-at-a-time mode for frontends not supporting callgraph
1749 if (flag_unit_at_a_time
&& ! lang_hooks
.callgraph
.expand_function
)
1750 flag_unit_at_a_time
= 0;
1752 if (flag_value_profile_transformations
)
1753 flag_profile_values
= 1;
1755 /* Speculative prefetching implies the value profiling. We also switch off
1756 the prefetching in the loop optimizer, so that we do not emit double
1757 prefetches. TODO -- we should teach these two to cooperate; the loop
1758 based prefetching may sometimes do a better job, especially in connection
1759 with reuse analysis. */
1760 if (flag_speculative_prefetching
)
1762 flag_profile_values
= 1;
1763 flag_prefetch_loop_arrays
= 0;
1766 /* Warn about options that are not supported on this machine. */
1767 #ifndef INSN_SCHEDULING
1768 if (flag_schedule_insns
|| flag_schedule_insns_after_reload
)
1769 warning (0, "instruction scheduling not supported on this target machine");
1772 if (flag_delayed_branch
)
1773 warning (0, "this target machine does not have delayed branches");
1776 user_label_prefix
= USER_LABEL_PREFIX
;
1777 if (flag_leading_underscore
!= -1)
1779 /* If the default prefix is more complicated than "" or "_",
1780 issue a warning and ignore this option. */
1781 if (user_label_prefix
[0] == 0 ||
1782 (user_label_prefix
[0] == '_' && user_label_prefix
[1] == 0))
1784 user_label_prefix
= flag_leading_underscore
? "_" : "";
1787 warning (0, "-f%sleading-underscore not supported on this target machine",
1788 flag_leading_underscore
? "" : "no-");
1791 /* If we are in verbose mode, write out the version and maybe all the
1792 option flags in use. */
1795 print_version (stderr
, "");
1797 print_switch_values (stderr
, 0, MAX_LINE
, "", " ", "\n");
1800 if (flag_syntax_only
)
1802 write_symbols
= NO_DEBUG
;
1806 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1808 if (debug_info_level
== DINFO_LEVEL_NONE
)
1809 write_symbols
= NO_DEBUG
;
1811 /* Now we know write_symbols, set up the debug hooks based on it.
1812 By default we do nothing for debug output. */
1813 if (PREFERRED_DEBUGGING_TYPE
== NO_DEBUG
)
1814 default_debug_hooks
= &do_nothing_debug_hooks
;
1815 #if defined(DBX_DEBUGGING_INFO)
1816 else if (PREFERRED_DEBUGGING_TYPE
== DBX_DEBUG
)
1817 default_debug_hooks
= &dbx_debug_hooks
;
1819 #if defined(XCOFF_DEBUGGING_INFO)
1820 else if (PREFERRED_DEBUGGING_TYPE
== XCOFF_DEBUG
)
1821 default_debug_hooks
= &xcoff_debug_hooks
;
1823 #ifdef SDB_DEBUGGING_INFO
1824 else if (PREFERRED_DEBUGGING_TYPE
== SDB_DEBUG
)
1825 default_debug_hooks
= &sdb_debug_hooks
;
1827 #ifdef DWARF2_DEBUGGING_INFO
1828 else if (PREFERRED_DEBUGGING_TYPE
== DWARF2_DEBUG
)
1829 default_debug_hooks
= &dwarf2_debug_hooks
;
1831 #ifdef VMS_DEBUGGING_INFO
1832 else if (PREFERRED_DEBUGGING_TYPE
== VMS_DEBUG
1833 || PREFERRED_DEBUGGING_TYPE
== VMS_AND_DWARF2_DEBUG
)
1834 default_debug_hooks
= &vmsdbg_debug_hooks
;
1837 debug_hooks
= &do_nothing_debug_hooks
;
1838 if (write_symbols
== NO_DEBUG
)
1840 #if defined(DBX_DEBUGGING_INFO)
1841 else if (write_symbols
== DBX_DEBUG
)
1842 debug_hooks
= &dbx_debug_hooks
;
1844 #if defined(XCOFF_DEBUGGING_INFO)
1845 else if (write_symbols
== XCOFF_DEBUG
)
1846 debug_hooks
= &xcoff_debug_hooks
;
1848 #ifdef SDB_DEBUGGING_INFO
1849 else if (write_symbols
== SDB_DEBUG
)
1850 debug_hooks
= &sdb_debug_hooks
;
1852 #ifdef DWARF2_DEBUGGING_INFO
1853 else if (write_symbols
== DWARF2_DEBUG
)
1854 debug_hooks
= &dwarf2_debug_hooks
;
1856 #ifdef VMS_DEBUGGING_INFO
1857 else if (write_symbols
== VMS_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
1858 debug_hooks
= &vmsdbg_debug_hooks
;
1861 error ("target system does not support the \"%s\" debug format",
1862 debug_type_names
[write_symbols
]);
1864 /* Now we know which debug output will be used so we can set
1865 flag_var_tracking, flag_rename_registers if the user has
1866 not specified them. */
1867 if (debug_info_level
< DINFO_LEVEL_NORMAL
1868 || debug_hooks
->var_location
== do_nothing_debug_hooks
.var_location
)
1870 if (flag_var_tracking
== 1)
1872 if (debug_info_level
< DINFO_LEVEL_NORMAL
)
1873 warning (0, "variable tracking requested, but useless unless "
1874 "producing debug info");
1876 warning (0, "variable tracking requested, but not supported "
1877 "by this debug format");
1879 flag_var_tracking
= 0;
1882 if (flag_rename_registers
== AUTODETECT_FLAG_VAR_TRACKING
)
1883 flag_rename_registers
= default_debug_hooks
->var_location
1884 != do_nothing_debug_hooks
.var_location
;
1886 if (flag_var_tracking
== AUTODETECT_FLAG_VAR_TRACKING
)
1887 flag_var_tracking
= optimize
>= 1;
1889 /* If auxiliary info generation is desired, open the output file.
1890 This goes in the same directory as the source file--unlike
1891 all the other output files. */
1892 if (flag_gen_aux_info
)
1894 aux_info_file
= fopen (aux_info_file_name
, "w");
1895 if (aux_info_file
== 0)
1896 fatal_error ("can%'t open %s: %m", aux_info_file_name
);
1899 if (! targetm
.have_named_sections
)
1901 if (flag_function_sections
)
1903 warning (0, "-ffunction-sections not supported for this target");
1904 flag_function_sections
= 0;
1906 if (flag_data_sections
)
1908 warning (0, "-fdata-sections not supported for this target");
1909 flag_data_sections
= 0;
1913 if (flag_function_sections
&& profile_flag
)
1915 warning (0, "-ffunction-sections disabled; it makes profiling impossible");
1916 flag_function_sections
= 0;
1919 #ifndef HAVE_prefetch
1920 if (flag_prefetch_loop_arrays
)
1922 warning (0, "-fprefetch-loop-arrays not supported for this target");
1923 flag_prefetch_loop_arrays
= 0;
1925 if (flag_speculative_prefetching
)
1927 if (flag_speculative_prefetching_set
)
1928 warning (0, "-fspeculative-prefetching not supported for this target");
1929 flag_speculative_prefetching
= 0;
1932 if (flag_prefetch_loop_arrays
&& !HAVE_prefetch
)
1934 warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
1935 flag_prefetch_loop_arrays
= 0;
1937 if (flag_speculative_prefetching
&& !HAVE_prefetch
)
1939 if (flag_speculative_prefetching_set
)
1940 warning (0, "-fspeculative-prefetching not supported for this target (try -march switches)");
1941 flag_speculative_prefetching
= 0;
1945 /* This combination of options isn't handled for i386 targets and doesn't
1946 make much sense anyway, so don't allow it. */
1947 if (flag_prefetch_loop_arrays
&& optimize_size
)
1949 warning (0, "-fprefetch-loop-arrays is not supported with -Os");
1950 flag_prefetch_loop_arrays
= 0;
1953 #ifndef OBJECT_FORMAT_ELF
1954 if (flag_function_sections
&& write_symbols
!= NO_DEBUG
)
1955 warning (0, "-ffunction-sections may affect debugging on some targets");
1958 /* The presence of IEEE signaling NaNs, implies all math can trap. */
1959 if (flag_signaling_nans
)
1960 flag_trapping_math
= 1;
1962 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1963 if (flag_cx_limited_range
)
1964 flag_complex_method
= 0;
1967 /* Initialize the compiler back end. */
1971 init_emit_once (debug_info_level
== DINFO_LEVEL_NORMAL
1972 || debug_info_level
== DINFO_LEVEL_VERBOSE
1973 #ifdef VMS_DEBUGGING_INFO
1974 /* Enable line number info for traceback. */
1975 || debug_info_level
> DINFO_LEVEL_NONE
1977 || flag_test_coverage
);
1981 init_fake_stack_mems ();
1985 init_function_once ();
1986 init_varasm_once ();
1988 /* The following initialization functions need to generate rtl, so
1989 provide a dummy function context for them. */
1990 init_dummy_function_start ();
1992 if (flag_caller_saves
)
1993 init_caller_save ();
1994 expand_dummy_function_end ();
1997 /* Language-dependent initialization. Returns nonzero on success. */
1999 lang_dependent_init (const char *name
)
2001 location_t save_loc
= input_location
;
2002 if (dump_base_name
== 0)
2003 dump_base_name
= name
&& name
[0] ? name
: "gccdump";
2005 /* Other front-end initialization. */
2006 #ifdef USE_MAPPED_LOCATION
2007 input_location
= BUILTINS_LOCATION
;
2009 input_filename
= "<built-in>";
2012 if (lang_hooks
.init () == 0)
2014 input_location
= save_loc
;
2016 init_asm_output (name
);
2018 /* These create various _DECL nodes, so need to be called after the
2019 front end is initialized. */
2023 /* The following initialization functions need to generate rtl, so
2024 provide a dummy function context for them. */
2025 init_dummy_function_start ();
2027 expand_dummy_function_end ();
2029 /* If dbx symbol table desired, initialize writing it and output the
2030 predefined types. */
2031 timevar_push (TV_SYMOUT
);
2033 #ifdef DWARF2_UNWIND_INFO
2034 if (dwarf2out_do_frame ())
2035 dwarf2out_frame_init ();
2038 /* Now we have the correct original filename, we can initialize
2040 (*debug_hooks
->init
) (name
);
2042 timevar_pop (TV_SYMOUT
);
2047 /* Clean up: close opened files, etc. */
2052 /* Close the dump files. */
2053 if (flag_gen_aux_info
)
2055 fclose (aux_info_file
);
2057 unlink (aux_info_file_name
);
2060 /* Close non-debugging input and output files. Take special care to note
2061 whether fclose returns an error, since the pages might still be on the
2062 buffer chain while the file is open. */
2066 if (ferror (asm_out_file
) != 0)
2067 fatal_error ("error writing to %s: %m", asm_file_name
);
2068 if (fclose (asm_out_file
) != 0)
2069 fatal_error ("error closing %s: %m", asm_file_name
);
2072 finish_optimization_passes ();
2076 ggc_print_statistics ();
2077 stringpool_statistics ();
2078 dump_tree_statistics ();
2079 dump_rtx_statistics ();
2080 dump_varray_statistics ();
2081 dump_alloc_pool_statistics ();
2082 dump_ggc_loc_statistics ();
2085 /* Free up memory for the benefit of leak detectors. */
2088 /* Language-specific end of compilation actions. */
2089 lang_hooks
.finish ();
2092 /* Initialize the compiler, and compile the input file. */
2096 /* Initialize timing first. The C front ends read the main file in
2097 the post_options hook, and C++ does file timings. */
2098 if (time_report
|| !quiet_flag
|| flag_detailed_statistics
)
2100 timevar_start (TV_TOTAL
);
2104 /* Don't do any more if an error has already occurred. */
2107 /* This must be run always, because it is needed to compute the FP
2108 predefined macros, such as __LDBL_MAX__, for targets using non
2109 default FP formats. */
2110 init_adjust_machine_modes ();
2112 /* Set up the back-end if requested. */
2116 /* Language-dependent initialization. Returns true on success. */
2117 if (lang_dependent_init (main_input_filename
))
2123 /* Stop timing and print the times. */
2124 timevar_stop (TV_TOTAL
);
2125 timevar_print (stderr
);
2128 /* Entry point of cc1, cc1plus, jc1, f771, etc.
2129 Exit code is FATAL_EXIT_CODE if can't open files or if there were
2130 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
2132 It is not safe to call this function more than once. */
2135 toplev_main (unsigned int argc
, const char **argv
)
2139 /* Initialization of GCC's environment, and diagnostics. */
2140 general_init (argv
[0]);
2142 /* Parse the options and do minimal processing; basically just
2143 enough to default flags appropriately. */
2144 decode_options (argc
, argv
);
2148 /* Exit early if we can (e.g. -help). */
2149 if (!exit_after_options
)
2152 if (errorcount
|| sorrycount
)
2153 return (FATAL_EXIT_CODE
);
2155 return (SUCCESS_EXIT_CODE
);