|
0
|
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, 2006, 2007, 2008
|
|
|
4 Free Software Foundation, Inc.
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
8 GCC is free software; you can redistribute it and/or modify it under
|
|
|
9 the terms of the GNU General Public License as published by the Free
|
|
|
10 Software Foundation; either version 3, or (at your option) any later
|
|
|
11 version.
|
|
|
12
|
|
|
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with GCC; see the file COPYING3. If not see
|
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
|
21
|
|
|
22 /* This is the top level of cc1/c++.
|
|
|
23 It parses command args, opens files, invokes the various passes
|
|
|
24 in the proper order, and counts the time used by each.
|
|
|
25 Error messages and low-level interface to malloc also handled here. */
|
|
|
26
|
|
|
27 #include "config.h"
|
|
|
28 #undef FLOAT /* This is for hpux. They should change hpux. */
|
|
|
29 #undef FFS /* Some systems define this in param.h. */
|
|
|
30 #include "system.h"
|
|
|
31 #include "coretypes.h"
|
|
|
32 #include "tm.h"
|
|
|
33 #include <signal.h>
|
|
|
34
|
|
|
35 #ifdef HAVE_SYS_RESOURCE_H
|
|
|
36 # include <sys/resource.h>
|
|
|
37 #endif
|
|
|
38
|
|
|
39 #ifdef HAVE_SYS_TIMES_H
|
|
|
40 # include <sys/times.h>
|
|
|
41 #endif
|
|
|
42
|
|
|
43 #include "line-map.h"
|
|
|
44 #include "input.h"
|
|
|
45 #include "tree.h"
|
|
|
46 #include "version.h"
|
|
|
47 #include "rtl.h"
|
|
|
48 #include "tm_p.h"
|
|
|
49 #include "flags.h"
|
|
|
50 #include "insn-attr.h"
|
|
|
51 #include "insn-config.h"
|
|
|
52 #include "insn-flags.h"
|
|
|
53 #include "hard-reg-set.h"
|
|
|
54 #include "recog.h"
|
|
|
55 #include "output.h"
|
|
|
56 #include "except.h"
|
|
|
57 #include "function.h"
|
|
|
58 #include "toplev.h"
|
|
|
59 #include "expr.h"
|
|
|
60 #include "basic-block.h"
|
|
|
61 #include "intl.h"
|
|
|
62 #include "ggc.h"
|
|
|
63 #include "graph.h"
|
|
|
64 #include "regs.h"
|
|
|
65 #include "timevar.h"
|
|
|
66 #include "diagnostic.h"
|
|
|
67 #include "params.h"
|
|
|
68 #include "reload.h"
|
|
|
69 #include "ira.h"
|
|
|
70 #include "dwarf2asm.h"
|
|
|
71 #include "integrate.h"
|
|
|
72 #include "real.h"
|
|
|
73 #include "debug.h"
|
|
|
74 #include "target.h"
|
|
|
75 #include "langhooks.h"
|
|
|
76 #include "cfglayout.h"
|
|
|
77 #include "cfgloop.h"
|
|
|
78 #include "hosthooks.h"
|
|
|
79 #include "cgraph.h"
|
|
|
80 #include "opts.h"
|
|
|
81 #include "coverage.h"
|
|
|
82 #include "value-prof.h"
|
|
|
83 #include "alloc-pool.h"
|
|
|
84 #include "tree-mudflap.h"
|
|
|
85 #include "tree-pass.h"
|
|
|
86 #include "gimple.h"
|
|
|
87
|
|
|
88 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
|
|
|
89 #include "dwarf2out.h"
|
|
|
90 #endif
|
|
|
91
|
|
|
92 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
|
|
|
93 #include "dbxout.h"
|
|
|
94 #endif
|
|
|
95
|
|
|
96 #ifdef SDB_DEBUGGING_INFO
|
|
|
97 #include "sdbout.h"
|
|
|
98 #endif
|
|
|
99
|
|
|
100 #ifdef XCOFF_DEBUGGING_INFO
|
|
|
101 #include "xcoffout.h" /* Needed for external data
|
|
|
102 declarations for e.g. AIX 4.x. */
|
|
|
103 #endif
|
|
|
104
|
|
|
105 static void general_init (const char *);
|
|
|
106 static void do_compile (void);
|
|
|
107 static void process_options (void);
|
|
|
108 static void backend_init (void);
|
|
|
109 static int lang_dependent_init (const char *);
|
|
|
110 static void init_asm_output (const char *);
|
|
|
111 static void finalize (void);
|
|
|
112
|
|
|
113 static void crash_signal (int) ATTRIBUTE_NORETURN;
|
|
|
114 static void setup_core_dumping (void);
|
|
|
115 static void compile_file (void);
|
|
|
116
|
|
|
117 /* Nonzero to dump debug info whilst parsing (-dy option). */
|
|
|
118 static int set_yydebug;
|
|
|
119
|
|
|
120 /* True if we don't need a backend (e.g. preprocessing only). */
|
|
|
121 static bool no_backend;
|
|
|
122
|
|
|
123 /* Length of line when printing switch values. */
|
|
|
124 #define MAX_LINE 75
|
|
|
125
|
|
|
126 /* Name of program invoked, sans directories. */
|
|
|
127
|
|
|
128 const char *progname;
|
|
|
129
|
|
|
130 /* Copy of argument vector to toplev_main. */
|
|
|
131 static const char **save_argv;
|
|
|
132
|
|
|
133 /* Name of top-level original source file (what was input to cpp).
|
|
|
134 This comes from the #-command at the beginning of the actual input.
|
|
|
135 If there isn't any there, then this is the cc1 input file name. */
|
|
|
136
|
|
|
137 const char *main_input_filename;
|
|
|
138
|
|
|
139 /* Used to enable -fvar-tracking, -fweb and -frename-registers according
|
|
|
140 to optimize and default_debug_hooks in process_options (). */
|
|
|
141 #define AUTODETECT_VALUE 2
|
|
|
142
|
|
|
143 /* Current position in real source file. */
|
|
|
144
|
|
|
145 location_t input_location;
|
|
|
146
|
|
|
147 struct line_maps *line_table;
|
|
|
148
|
|
|
149 /* Name to use as base of names for dump output files. */
|
|
|
150
|
|
|
151 const char *dump_base_name;
|
|
|
152
|
|
|
153 /* Name to use as a base for auxiliary output files. */
|
|
|
154
|
|
|
155 const char *aux_base_name;
|
|
|
156
|
|
|
157 /* Prefix for profile data files */
|
|
|
158 const char *profile_data_prefix;
|
|
|
159
|
|
|
160 /* A mask of target_flags that includes bit X if X was set or cleared
|
|
|
161 on the command line. */
|
|
|
162
|
|
|
163 int target_flags_explicit;
|
|
|
164
|
|
|
165 /* Debug hooks - dependent upon command line options. */
|
|
|
166
|
|
|
167 const struct gcc_debug_hooks *debug_hooks;
|
|
|
168
|
|
|
169 /* Debug hooks - target default. */
|
|
|
170
|
|
|
171 static const struct gcc_debug_hooks *default_debug_hooks;
|
|
|
172
|
|
|
173 /* Other flags saying which kinds of debugging dump have been requested. */
|
|
|
174
|
|
|
175 int rtl_dump_and_exit;
|
|
|
176 int flag_print_asm_name;
|
|
|
177 enum graph_dump_types graph_dump_format;
|
|
|
178
|
|
|
179 /* Name for output file of assembly code, specified with -o. */
|
|
|
180
|
|
|
181 const char *asm_file_name;
|
|
|
182
|
|
|
183 /* Nonzero means do optimizations. -O.
|
|
|
184 Particular numeric values stand for particular amounts of optimization;
|
|
|
185 thus, -O2 stores 2 here. However, the optimizations beyond the basic
|
|
|
186 ones are not controlled directly by this variable. Instead, they are
|
|
|
187 controlled by individual `flag_...' variables that are defaulted
|
|
|
188 based on this variable. */
|
|
|
189
|
|
|
190 int optimize = 0;
|
|
|
191
|
|
|
192 /* Nonzero means optimize for size. -Os.
|
|
|
193 The only valid values are zero and nonzero. When optimize_size is
|
|
|
194 nonzero, optimize defaults to 2, but certain individual code
|
|
|
195 bloating optimizations are disabled. */
|
|
|
196
|
|
|
197 int optimize_size = 0;
|
|
|
198
|
|
|
199 /* The FUNCTION_DECL for the function currently being compiled,
|
|
|
200 or 0 if between functions. */
|
|
|
201 tree current_function_decl;
|
|
|
202
|
|
|
203 /* Set to the FUNC_BEGIN label of the current function, or NULL
|
|
|
204 if none. */
|
|
|
205 const char * current_function_func_begin_label;
|
|
|
206
|
|
|
207 /* Nonzero means to collect statistics which might be expensive
|
|
|
208 and to print them when we are done. */
|
|
|
209 int flag_detailed_statistics = 0;
|
|
|
210
|
|
|
211 /* A random sequence of characters, unless overridden by user. */
|
|
|
212 static const char *flag_random_seed;
|
|
|
213
|
|
|
214 /* A local time stamp derived from the time of compilation. It will be
|
|
|
215 zero if the system cannot provide a time. It will be -1u, if the
|
|
|
216 user has specified a particular random seed. */
|
|
|
217 unsigned local_tick;
|
|
|
218
|
|
|
219 /* -f flags. */
|
|
|
220
|
|
|
221 /* Nonzero means `char' should be signed. */
|
|
|
222
|
|
|
223 int flag_signed_char;
|
|
|
224
|
|
|
225 /* Nonzero means give an enum type only as many bytes as it needs. A value
|
|
|
226 of 2 means it has not yet been initialized. */
|
|
|
227
|
|
|
228 int flag_short_enums;
|
|
|
229
|
|
|
230 /* Nonzero if structures and unions should be returned in memory.
|
|
|
231
|
|
|
232 This should only be defined if compatibility with another compiler or
|
|
|
233 with an ABI is needed, because it results in slower code. */
|
|
|
234
|
|
|
235 #ifndef DEFAULT_PCC_STRUCT_RETURN
|
|
|
236 #define DEFAULT_PCC_STRUCT_RETURN 1
|
|
|
237 #endif
|
|
|
238
|
|
|
239 /* Nonzero for -fpcc-struct-return: return values the same way PCC does. */
|
|
|
240
|
|
|
241 int flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
|
|
|
242
|
|
|
243 /* 0 means straightforward implementation of complex divide acceptable.
|
|
|
244 1 means wide ranges of inputs must work for complex divide.
|
|
|
245 2 means C99-like requirements for complex multiply and divide. */
|
|
|
246
|
|
|
247 int flag_complex_method = 1;
|
|
|
248
|
|
|
249 /* Nonzero means we should be saving declaration info into a .X file. */
|
|
|
250
|
|
|
251 int flag_gen_aux_info = 0;
|
|
|
252
|
|
|
253 /* Specified name of aux-info file. */
|
|
|
254
|
|
|
255 const char *aux_info_file_name;
|
|
|
256
|
|
|
257 /* Nonzero if we are compiling code for a shared library, zero for
|
|
|
258 executable. */
|
|
|
259
|
|
|
260 int flag_shlib;
|
|
|
261
|
|
|
262 /* Generate code for GNU or NeXT Objective-C runtime environment. */
|
|
|
263
|
|
|
264 #ifdef NEXT_OBJC_RUNTIME
|
|
|
265 int flag_next_runtime = 1;
|
|
|
266 #else
|
|
|
267 int flag_next_runtime = 0;
|
|
|
268 #endif
|
|
|
269
|
|
|
270 /* Set to the default thread-local storage (tls) model to use. */
|
|
|
271
|
|
|
272 enum tls_model flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
|
|
|
273
|
|
|
274 /* Set the default region and algorithm for the integrated register
|
|
|
275 allocator. */
|
|
|
276
|
|
|
277 enum ira_algorithm flag_ira_algorithm = IRA_ALGORITHM_CB;
|
|
|
278 enum ira_region flag_ira_region = IRA_REGION_MIXED;
|
|
|
279
|
|
|
280 /* Set the default value for -fira-verbose. */
|
|
|
281
|
|
|
282 unsigned int flag_ira_verbose = 5;
|
|
|
283
|
|
|
284 /* Nonzero means change certain warnings into errors.
|
|
|
285 Usually these are warnings about failure to conform to some standard. */
|
|
|
286
|
|
|
287 int flag_pedantic_errors = 0;
|
|
|
288
|
|
|
289 /* Nonzero means make permerror produce warnings instead of errors. */
|
|
|
290
|
|
|
291 int flag_permissive = 0;
|
|
|
292
|
|
|
293 /* -dA causes debug commentary information to be produced in
|
|
|
294 the generated assembly code (to make it more readable). This option
|
|
|
295 is generally only of use to those who actually need to read the
|
|
|
296 generated assembly code (perhaps while debugging the compiler itself).
|
|
|
297 Currently, this switch is only used by dwarfout.c; however, it is intended
|
|
|
298 to be a catchall for printing debug information in the assembler file. */
|
|
|
299
|
|
|
300 int flag_debug_asm = 0;
|
|
|
301
|
|
|
302 /* -dP causes the rtl to be emitted as a comment in assembly. */
|
|
|
303
|
|
|
304 int flag_dump_rtl_in_asm = 0;
|
|
|
305
|
|
|
306 /* When non-NULL, indicates that whenever space is allocated on the
|
|
|
307 stack, the resulting stack pointer must not pass this
|
|
|
308 address---that is, for stacks that grow downward, the stack pointer
|
|
|
309 must always be greater than or equal to this address; for stacks
|
|
|
310 that grow upward, the stack pointer must be less than this address.
|
|
|
311 At present, the rtx may be either a REG or a SYMBOL_REF, although
|
|
|
312 the support provided depends on the backend. */
|
|
|
313 rtx stack_limit_rtx;
|
|
|
314
|
|
|
315 /* Nonzero if we should track variables. When
|
|
|
316 flag_var_tracking == AUTODETECT_VALUE it will be set according
|
|
|
317 to optimize, debug_info_level and debug_hooks in process_options (). */
|
|
|
318 int flag_var_tracking = AUTODETECT_VALUE;
|
|
|
319
|
|
|
320 /* Type of stack check. */
|
|
|
321 enum stack_check_type flag_stack_check = NO_STACK_CHECK;
|
|
|
322
|
|
|
323 /* True if the user has tagged the function with the 'section'
|
|
|
324 attribute. */
|
|
|
325
|
|
|
326 bool user_defined_section_attribute = false;
|
|
|
327
|
|
|
328 /* Values of the -falign-* flags: how much to align labels in code.
|
|
|
329 0 means `use default', 1 means `don't align'.
|
|
|
330 For each variable, there is an _log variant which is the power
|
|
|
331 of two not less than the variable, for .align output. */
|
|
|
332
|
|
|
333 int align_loops_log;
|
|
|
334 int align_loops_max_skip;
|
|
|
335 int align_jumps_log;
|
|
|
336 int align_jumps_max_skip;
|
|
|
337 int align_labels_log;
|
|
|
338 int align_labels_max_skip;
|
|
|
339 int align_functions_log;
|
|
|
340
|
|
|
341 typedef struct
|
|
|
342 {
|
|
|
343 const char *const string;
|
|
|
344 int *const variable;
|
|
|
345 const int on_value;
|
|
|
346 }
|
|
|
347 lang_independent_options;
|
|
|
348
|
|
|
349 /* Nonzero if subexpressions must be evaluated from left-to-right. */
|
|
|
350 int flag_evaluation_order = 0;
|
|
|
351
|
|
|
352 /* The user symbol prefix after having resolved same. */
|
|
|
353 const char *user_label_prefix;
|
|
|
354
|
|
|
355 static const param_info lang_independent_params[] = {
|
|
|
356 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
|
|
|
357 { OPTION, DEFAULT, false, MIN, MAX, HELP },
|
|
|
358 #include "params.def"
|
|
|
359 #undef DEFPARAM
|
|
|
360 { NULL, 0, false, 0, 0, NULL }
|
|
|
361 };
|
|
|
362
|
|
|
363 /* Output files for assembler code (real compiler output)
|
|
|
364 and debugging dumps. */
|
|
|
365
|
|
|
366 FILE *asm_out_file;
|
|
|
367 FILE *aux_info_file;
|
|
|
368 FILE *dump_file = NULL;
|
|
|
369 const char *dump_file_name;
|
|
|
370
|
|
|
371 /* The current working directory of a translation. It's generally the
|
|
|
372 directory from which compilation was initiated, but a preprocessed
|
|
|
373 file may specify the original directory in which it was
|
|
|
374 created. */
|
|
|
375
|
|
|
376 static const char *src_pwd;
|
|
|
377
|
|
|
378 /* Initialize src_pwd with the given string, and return true. If it
|
|
|
379 was already initialized, return false. As a special case, it may
|
|
|
380 be called with a NULL argument to test whether src_pwd has NOT been
|
|
|
381 initialized yet. */
|
|
|
382
|
|
|
383 bool
|
|
|
384 set_src_pwd (const char *pwd)
|
|
|
385 {
|
|
|
386 if (src_pwd)
|
|
|
387 {
|
|
|
388 if (strcmp (src_pwd, pwd) == 0)
|
|
|
389 return true;
|
|
|
390 else
|
|
|
391 return false;
|
|
|
392 }
|
|
|
393
|
|
|
394 src_pwd = xstrdup (pwd);
|
|
|
395 return true;
|
|
|
396 }
|
|
|
397
|
|
|
398 /* Return the directory from which the translation unit was initiated,
|
|
|
399 in case set_src_pwd() was not called before to assign it a
|
|
|
400 different value. */
|
|
|
401
|
|
|
402 const char *
|
|
|
403 get_src_pwd (void)
|
|
|
404 {
|
|
|
405 if (! src_pwd)
|
|
|
406 {
|
|
|
407 src_pwd = getpwd ();
|
|
|
408 if (!src_pwd)
|
|
|
409 src_pwd = ".";
|
|
|
410 }
|
|
|
411
|
|
|
412 return src_pwd;
|
|
|
413 }
|
|
|
414
|
|
|
415 /* Called when the start of a function definition is parsed,
|
|
|
416 this function prints on stderr the name of the function. */
|
|
|
417 void
|
|
|
418 announce_function (tree decl)
|
|
|
419 {
|
|
|
420 if (!quiet_flag)
|
|
|
421 {
|
|
|
422 if (rtl_dump_and_exit)
|
|
|
423 fprintf (stderr, "%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
|
|
|
424 else
|
|
|
425 fprintf (stderr, " %s", lang_hooks.decl_printable_name (decl, 2));
|
|
|
426 fflush (stderr);
|
|
|
427 pp_needs_newline (global_dc->printer) = true;
|
|
|
428 diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
|
|
|
429 }
|
|
|
430 }
|
|
|
431
|
|
|
432 /* Initialize local_tick with the time of day, or -1 if
|
|
|
433 flag_random_seed is set. */
|
|
|
434
|
|
|
435 static void
|
|
|
436 init_local_tick (void)
|
|
|
437 {
|
|
|
438 if (!flag_random_seed)
|
|
|
439 {
|
|
|
440 /* Get some more or less random data. */
|
|
|
441 #ifdef HAVE_GETTIMEOFDAY
|
|
|
442 {
|
|
|
443 struct timeval tv;
|
|
|
444
|
|
|
445 gettimeofday (&tv, NULL);
|
|
|
446 local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000;
|
|
|
447 }
|
|
|
448 #else
|
|
|
449 {
|
|
|
450 time_t now = time (NULL);
|
|
|
451
|
|
|
452 if (now != (time_t)-1)
|
|
|
453 local_tick = (unsigned) now;
|
|
|
454 }
|
|
|
455 #endif
|
|
|
456 }
|
|
|
457 else
|
|
|
458 local_tick = -1;
|
|
|
459 }
|
|
|
460
|
|
|
461 /* Set up a default flag_random_seed and local_tick, unless the user
|
|
|
462 already specified one. Must be called after init_local_tick. */
|
|
|
463
|
|
|
464 static void
|
|
|
465 init_random_seed (void)
|
|
|
466 {
|
|
|
467 unsigned HOST_WIDE_INT value;
|
|
|
468 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
|
|
|
469
|
|
|
470 value = local_tick ^ getpid ();
|
|
|
471
|
|
|
472 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
|
|
|
473 flag_random_seed = random_seed;
|
|
|
474 }
|
|
|
475
|
|
|
476 /* Obtain the random_seed string. Unless NOINIT, initialize it if
|
|
|
477 it's not provided in the command line. */
|
|
|
478
|
|
|
479 const char *
|
|
|
480 get_random_seed (bool noinit)
|
|
|
481 {
|
|
|
482 if (!flag_random_seed && !noinit)
|
|
|
483 init_random_seed ();
|
|
|
484 return flag_random_seed;
|
|
|
485 }
|
|
|
486
|
|
|
487 /* Modify the random_seed string to VAL. Return its previous
|
|
|
488 value. */
|
|
|
489
|
|
|
490 const char *
|
|
|
491 set_random_seed (const char *val)
|
|
|
492 {
|
|
|
493 const char *old = flag_random_seed;
|
|
|
494 flag_random_seed = val;
|
|
|
495 return old;
|
|
|
496 }
|
|
|
497
|
|
|
498 /* Decode the string P as an integral parameter.
|
|
|
499 If the string is indeed an integer return its numeric value else
|
|
|
500 issue an Invalid Option error for the option PNAME and return DEFVAL.
|
|
|
501 If PNAME is zero just return DEFVAL, do not call error. */
|
|
|
502
|
|
|
503 int
|
|
|
504 read_integral_parameter (const char *p, const char *pname, const int defval)
|
|
|
505 {
|
|
|
506 const char *endp = p;
|
|
|
507
|
|
|
508 while (*endp)
|
|
|
509 {
|
|
|
510 if (ISDIGIT (*endp))
|
|
|
511 endp++;
|
|
|
512 else
|
|
|
513 break;
|
|
|
514 }
|
|
|
515
|
|
|
516 if (*endp != 0)
|
|
|
517 {
|
|
|
518 if (pname != 0)
|
|
|
519 error ("invalid option argument %qs", pname);
|
|
|
520 return defval;
|
|
|
521 }
|
|
|
522
|
|
|
523 return atoi (p);
|
|
|
524 }
|
|
|
525
|
|
|
526 /* When compiling with a recent enough GCC, we use the GNU C "extern inline"
|
|
|
527 for floor_log2 and exact_log2; see toplev.h. That construct, however,
|
|
|
528 conflicts with the ISO C++ One Definition Rule. */
|
|
|
529
|
|
|
530 #if GCC_VERSION < 3004 || !defined (__cplusplus)
|
|
|
531
|
|
|
532 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
|
|
|
533 If X is 0, return -1. */
|
|
|
534
|
|
|
535 int
|
|
|
536 floor_log2 (unsigned HOST_WIDE_INT x)
|
|
|
537 {
|
|
|
538 int t = 0;
|
|
|
539
|
|
|
540 if (x == 0)
|
|
|
541 return -1;
|
|
|
542
|
|
|
543 #ifdef CLZ_HWI
|
|
|
544 t = HOST_BITS_PER_WIDE_INT - 1 - (int) CLZ_HWI (x);
|
|
|
545 #else
|
|
|
546 if (HOST_BITS_PER_WIDE_INT > 64)
|
|
|
547 if (x >= (unsigned HOST_WIDE_INT) 1 << (t + 64))
|
|
|
548 t += 64;
|
|
|
549 if (HOST_BITS_PER_WIDE_INT > 32)
|
|
|
550 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 32))
|
|
|
551 t += 32;
|
|
|
552 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 16))
|
|
|
553 t += 16;
|
|
|
554 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 8))
|
|
|
555 t += 8;
|
|
|
556 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 4))
|
|
|
557 t += 4;
|
|
|
558 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 2))
|
|
|
559 t += 2;
|
|
|
560 if (x >= ((unsigned HOST_WIDE_INT) 1) << (t + 1))
|
|
|
561 t += 1;
|
|
|
562 #endif
|
|
|
563
|
|
|
564 return t;
|
|
|
565 }
|
|
|
566
|
|
|
567 /* Return the logarithm of X, base 2, considering X unsigned,
|
|
|
568 if X is a power of 2. Otherwise, returns -1. */
|
|
|
569
|
|
|
570 int
|
|
|
571 exact_log2 (unsigned HOST_WIDE_INT x)
|
|
|
572 {
|
|
|
573 if (x != (x & -x))
|
|
|
574 return -1;
|
|
|
575 #ifdef CTZ_HWI
|
|
|
576 return x ? CTZ_HWI (x) : -1;
|
|
|
577 #else
|
|
|
578 return floor_log2 (x);
|
|
|
579 #endif
|
|
|
580 }
|
|
|
581
|
|
|
582 #endif /* GCC_VERSION < 3004 || !defined (__cplusplus) */
|
|
|
583
|
|
|
584 /* Handler for fatal signals, such as SIGSEGV. These are transformed
|
|
|
585 into ICE messages, which is much more user friendly. In case the
|
|
|
586 error printer crashes, reset the signal to prevent infinite recursion. */
|
|
|
587
|
|
|
588 static void
|
|
|
589 crash_signal (int signo)
|
|
|
590 {
|
|
|
591 signal (signo, SIG_DFL);
|
|
|
592
|
|
|
593 /* If we crashed while processing an ASM statement, then be a little more
|
|
|
594 graceful. It's most likely the user's fault. */
|
|
|
595 if (this_is_asm_operands)
|
|
|
596 {
|
|
|
597 output_operand_lossage ("unrecoverable error");
|
|
|
598 exit (FATAL_EXIT_CODE);
|
|
|
599 }
|
|
|
600
|
|
|
601 internal_error ("%s", strsignal (signo));
|
|
|
602 }
|
|
|
603
|
|
|
604 /* Arrange to dump core on error. (The regular error message is still
|
|
|
605 printed first, except in the case of abort().) */
|
|
|
606
|
|
|
607 static void
|
|
|
608 setup_core_dumping (void)
|
|
|
609 {
|
|
|
610 #ifdef SIGABRT
|
|
|
611 signal (SIGABRT, SIG_DFL);
|
|
|
612 #endif
|
|
|
613 #if defined(HAVE_SETRLIMIT)
|
|
|
614 {
|
|
|
615 struct rlimit rlim;
|
|
|
616 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
|
|
|
617 fatal_error ("getting core file size maximum limit: %m");
|
|
|
618 rlim.rlim_cur = rlim.rlim_max;
|
|
|
619 if (setrlimit (RLIMIT_CORE, &rlim) != 0)
|
|
|
620 fatal_error ("setting core file size limit to maximum: %m");
|
|
|
621 }
|
|
|
622 #endif
|
|
|
623 diagnostic_abort_on_error (global_dc);
|
|
|
624 }
|
|
|
625
|
|
|
626
|
|
|
627 /* Strip off a legitimate source ending from the input string NAME of
|
|
|
628 length LEN. Rather than having to know the names used by all of
|
|
|
629 our front ends, we strip off an ending of a period followed by
|
|
|
630 up to five characters. (Java uses ".class".) */
|
|
|
631
|
|
|
632 void
|
|
|
633 strip_off_ending (char *name, int len)
|
|
|
634 {
|
|
|
635 int i;
|
|
|
636 for (i = 2; i < 6 && len > i; i++)
|
|
|
637 {
|
|
|
638 if (name[len - i] == '.')
|
|
|
639 {
|
|
|
640 name[len - i] = '\0';
|
|
|
641 break;
|
|
|
642 }
|
|
|
643 }
|
|
|
644 }
|
|
|
645
|
|
|
646 /* Output a quoted string. */
|
|
|
647
|
|
|
648 void
|
|
|
649 output_quoted_string (FILE *asm_file, const char *string)
|
|
|
650 {
|
|
|
651 #ifdef OUTPUT_QUOTED_STRING
|
|
|
652 OUTPUT_QUOTED_STRING (asm_file, string);
|
|
|
653 #else
|
|
|
654 char c;
|
|
|
655
|
|
|
656 putc ('\"', asm_file);
|
|
|
657 while ((c = *string++) != 0)
|
|
|
658 {
|
|
|
659 if (ISPRINT (c))
|
|
|
660 {
|
|
|
661 if (c == '\"' || c == '\\')
|
|
|
662 putc ('\\', asm_file);
|
|
|
663 putc (c, asm_file);
|
|
|
664 }
|
|
|
665 else
|
|
|
666 fprintf (asm_file, "\\%03o", (unsigned char) c);
|
|
|
667 }
|
|
|
668 putc ('\"', asm_file);
|
|
|
669 #endif
|
|
|
670 }
|
|
|
671
|
|
|
672 /* Output a file name in the form wanted by System V. */
|
|
|
673
|
|
|
674 void
|
|
|
675 output_file_directive (FILE *asm_file, const char *input_name)
|
|
|
676 {
|
|
|
677 int len;
|
|
|
678 const char *na;
|
|
|
679
|
|
|
680 if (input_name == NULL)
|
|
|
681 input_name = "<stdin>";
|
|
|
682 else
|
|
|
683 input_name = remap_debug_filename (input_name);
|
|
|
684
|
|
|
685 len = strlen (input_name);
|
|
|
686 na = input_name + len;
|
|
|
687
|
|
|
688 /* NA gets INPUT_NAME sans directory names. */
|
|
|
689 while (na > input_name)
|
|
|
690 {
|
|
|
691 if (IS_DIR_SEPARATOR (na[-1]))
|
|
|
692 break;
|
|
|
693 na--;
|
|
|
694 }
|
|
|
695
|
|
|
696 #ifdef ASM_OUTPUT_SOURCE_FILENAME
|
|
|
697 ASM_OUTPUT_SOURCE_FILENAME (asm_file, na);
|
|
|
698 #else
|
|
|
699 fprintf (asm_file, "\t.file\t");
|
|
|
700 output_quoted_string (asm_file, na);
|
|
|
701 fputc ('\n', asm_file);
|
|
|
702 #endif
|
|
|
703 }
|
|
|
704
|
|
|
705 /* A subroutine of wrapup_global_declarations. We've come to the end of
|
|
|
706 the compilation unit. All deferred variables should be undeferred,
|
|
|
707 and all incomplete decls should be finalized. */
|
|
|
708
|
|
|
709 void
|
|
|
710 wrapup_global_declaration_1 (tree decl)
|
|
|
711 {
|
|
|
712 /* We're not deferring this any longer. Assignment is conditional to
|
|
|
713 avoid needlessly dirtying PCH pages. */
|
|
|
714 if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
|
|
|
715 && DECL_DEFER_OUTPUT (decl) != 0)
|
|
|
716 DECL_DEFER_OUTPUT (decl) = 0;
|
|
|
717
|
|
|
718 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
|
|
|
719 lang_hooks.finish_incomplete_decl (decl);
|
|
|
720 }
|
|
|
721
|
|
|
722 /* A subroutine of wrapup_global_declarations. Decide whether or not DECL
|
|
|
723 needs to be output. Return true if it is output. */
|
|
|
724
|
|
|
725 bool
|
|
|
726 wrapup_global_declaration_2 (tree decl)
|
|
|
727 {
|
|
|
728 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl))
|
|
|
729 return false;
|
|
|
730
|
|
|
731 /* Don't write out static consts, unless we still need them.
|
|
|
732
|
|
|
733 We also keep static consts if not optimizing (for debugging),
|
|
|
734 unless the user specified -fno-keep-static-consts.
|
|
|
735 ??? They might be better written into the debug information.
|
|
|
736 This is possible when using DWARF.
|
|
|
737
|
|
|
738 A language processor that wants static constants to be always
|
|
|
739 written out (even if it is not used) is responsible for
|
|
|
740 calling rest_of_decl_compilation itself. E.g. the C front-end
|
|
|
741 calls rest_of_decl_compilation from finish_decl.
|
|
|
742 One motivation for this is that is conventional in some
|
|
|
743 environments to write things like:
|
|
|
744 static const char rcsid[] = "... version string ...";
|
|
|
745 intending to force the string to be in the executable.
|
|
|
746
|
|
|
747 A language processor that would prefer to have unneeded
|
|
|
748 static constants "optimized away" would just defer writing
|
|
|
749 them out until here. E.g. C++ does this, because static
|
|
|
750 constants are often defined in header files.
|
|
|
751
|
|
|
752 ??? A tempting alternative (for both C and C++) would be
|
|
|
753 to force a constant to be written if and only if it is
|
|
|
754 defined in a main file, as opposed to an include file. */
|
|
|
755
|
|
|
756 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
|
|
|
757 {
|
|
|
758 struct varpool_node *node;
|
|
|
759 bool needed = true;
|
|
|
760 node = varpool_node (decl);
|
|
|
761
|
|
|
762 if (node->finalized)
|
|
|
763 needed = false;
|
|
|
764 else if (node->alias)
|
|
|
765 needed = false;
|
|
|
766 else if (!cgraph_global_info_ready
|
|
|
767 && (TREE_USED (decl)
|
|
|
768 || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
|
|
|
769 /* needed */;
|
|
|
770 else if (node->needed)
|
|
|
771 /* needed */;
|
|
|
772 else if (DECL_COMDAT (decl))
|
|
|
773 needed = false;
|
|
|
774 else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
|
|
|
775 && (optimize || !flag_keep_static_consts
|
|
|
776 || DECL_ARTIFICIAL (decl)))
|
|
|
777 needed = false;
|
|
|
778
|
|
|
779 if (needed)
|
|
|
780 {
|
|
|
781 rest_of_decl_compilation (decl, 1, 1);
|
|
|
782 return true;
|
|
|
783 }
|
|
|
784 }
|
|
|
785
|
|
|
786 return false;
|
|
|
787 }
|
|
|
788
|
|
|
789 /* Do any final processing required for the declarations in VEC, of
|
|
|
790 which there are LEN. We write out inline functions and variables
|
|
|
791 that have been deferred until this point, but which are required.
|
|
|
792 Returns nonzero if anything was put out. */
|
|
|
793
|
|
|
794 bool
|
|
|
795 wrapup_global_declarations (tree *vec, int len)
|
|
|
796 {
|
|
|
797 bool reconsider, output_something = false;
|
|
|
798 int i;
|
|
|
799
|
|
|
800 for (i = 0; i < len; i++)
|
|
|
801 wrapup_global_declaration_1 (vec[i]);
|
|
|
802
|
|
|
803 /* Now emit any global variables or functions that we have been
|
|
|
804 putting off. We need to loop in case one of the things emitted
|
|
|
805 here references another one which comes earlier in the list. */
|
|
|
806 do
|
|
|
807 {
|
|
|
808 reconsider = false;
|
|
|
809 for (i = 0; i < len; i++)
|
|
|
810 reconsider |= wrapup_global_declaration_2 (vec[i]);
|
|
|
811 if (reconsider)
|
|
|
812 output_something = true;
|
|
|
813 }
|
|
|
814 while (reconsider);
|
|
|
815
|
|
|
816 return output_something;
|
|
|
817 }
|
|
|
818
|
|
|
819 /* A subroutine of check_global_declarations. Issue appropriate warnings
|
|
|
820 for the global declaration DECL. */
|
|
|
821
|
|
|
822 void
|
|
|
823 check_global_declaration_1 (tree decl)
|
|
|
824 {
|
|
|
825 /* Warn about any function declared static but not defined. We don't
|
|
|
826 warn about variables, because many programs have static variables
|
|
|
827 that exist only to get some text into the object file. */
|
|
|
828 if (TREE_CODE (decl) == FUNCTION_DECL
|
|
|
829 && DECL_INITIAL (decl) == 0
|
|
|
830 && DECL_EXTERNAL (decl)
|
|
|
831 && ! DECL_ARTIFICIAL (decl)
|
|
|
832 && ! TREE_NO_WARNING (decl)
|
|
|
833 && ! TREE_PUBLIC (decl)
|
|
|
834 && (warn_unused_function
|
|
|
835 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
|
|
|
836 {
|
|
|
837 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
|
|
|
838 pedwarn (input_location, 0, "%q+F used but never defined", decl);
|
|
|
839 else
|
|
|
840 warning (OPT_Wunused_function, "%q+F declared %<static%> but never defined", decl);
|
|
|
841 /* This symbol is effectively an "extern" declaration now. */
|
|
|
842 TREE_PUBLIC (decl) = 1;
|
|
|
843 assemble_external (decl);
|
|
|
844 }
|
|
|
845
|
|
|
846 /* Warn about static fns or vars defined but not used. */
|
|
|
847 if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
848 /* We don't warn about "static const" variables because the
|
|
|
849 "rcs_id" idiom uses that construction. */
|
|
|
850 || (warn_unused_variable
|
|
|
851 && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
|
|
|
852 && ! DECL_IN_SYSTEM_HEADER (decl)
|
|
|
853 && ! TREE_USED (decl)
|
|
|
854 /* The TREE_USED bit for file-scope decls is kept in the identifier,
|
|
|
855 to handle multiple external decls in different scopes. */
|
|
|
856 && ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl)))
|
|
|
857 && ! DECL_EXTERNAL (decl)
|
|
|
858 && ! TREE_PUBLIC (decl)
|
|
|
859 /* A volatile variable might be used in some non-obvious way. */
|
|
|
860 && ! TREE_THIS_VOLATILE (decl)
|
|
|
861 /* Global register variables must be declared to reserve them. */
|
|
|
862 && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
|
|
|
863 /* Otherwise, ask the language. */
|
|
|
864 && lang_hooks.decls.warn_unused_global (decl))
|
|
|
865 warning ((TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
866 ? OPT_Wunused_function
|
|
|
867 : OPT_Wunused_variable,
|
|
|
868 "%q+D defined but not used", decl);
|
|
|
869 }
|
|
|
870
|
|
|
871 /* Issue appropriate warnings for the global declarations in VEC (of
|
|
|
872 which there are LEN). */
|
|
|
873
|
|
|
874 void
|
|
|
875 check_global_declarations (tree *vec, int len)
|
|
|
876 {
|
|
|
877 int i;
|
|
|
878
|
|
|
879 for (i = 0; i < len; i++)
|
|
|
880 check_global_declaration_1 (vec[i]);
|
|
|
881 }
|
|
|
882
|
|
|
883 /* Emit debugging information for all global declarations in VEC. */
|
|
|
884
|
|
|
885 void
|
|
|
886 emit_debug_global_declarations (tree *vec, int len)
|
|
|
887 {
|
|
|
888 int i;
|
|
|
889
|
|
|
890 /* Avoid confusing the debug information machinery when there are errors. */
|
|
|
891 if (errorcount != 0 || sorrycount != 0)
|
|
|
892 return;
|
|
|
893
|
|
|
894 timevar_push (TV_SYMOUT);
|
|
|
895 for (i = 0; i < len; i++)
|
|
|
896 debug_hooks->global_decl (vec[i]);
|
|
|
897 timevar_pop (TV_SYMOUT);
|
|
|
898 }
|
|
|
899
|
|
|
900 /* Warn about a use of an identifier which was marked deprecated. */
|
|
|
901 void
|
|
|
902 warn_deprecated_use (tree node)
|
|
|
903 {
|
|
|
904 if (node == 0 || !warn_deprecated_decl)
|
|
|
905 return;
|
|
|
906
|
|
|
907 if (DECL_P (node))
|
|
|
908 {
|
|
|
909 expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
|
|
|
910 warning (OPT_Wdeprecated_declarations,
|
|
|
911 "%qD is deprecated (declared at %s:%d)",
|
|
|
912 node, xloc.file, xloc.line);
|
|
|
913 }
|
|
|
914 else if (TYPE_P (node))
|
|
|
915 {
|
|
|
916 const char *what = NULL;
|
|
|
917 tree decl = TYPE_STUB_DECL (node);
|
|
|
918
|
|
|
919 if (TYPE_NAME (node))
|
|
|
920 {
|
|
|
921 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
|
|
|
922 what = IDENTIFIER_POINTER (TYPE_NAME (node));
|
|
|
923 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
|
|
|
924 && DECL_NAME (TYPE_NAME (node)))
|
|
|
925 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
|
|
|
926 }
|
|
|
927
|
|
|
928 if (decl)
|
|
|
929 {
|
|
|
930 expanded_location xloc
|
|
|
931 = expand_location (DECL_SOURCE_LOCATION (decl));
|
|
|
932 if (what)
|
|
|
933 warning (OPT_Wdeprecated_declarations,
|
|
|
934 "%qs is deprecated (declared at %s:%d)", what,
|
|
|
935 xloc.file, xloc.line);
|
|
|
936 else
|
|
|
937 warning (OPT_Wdeprecated_declarations,
|
|
|
938 "type is deprecated (declared at %s:%d)",
|
|
|
939 xloc.file, xloc.line);
|
|
|
940 }
|
|
|
941 else
|
|
|
942 {
|
|
|
943 if (what)
|
|
|
944 warning (OPT_Wdeprecated_declarations, "%qs is deprecated", what);
|
|
|
945 else
|
|
|
946 warning (OPT_Wdeprecated_declarations, "type is deprecated");
|
|
|
947 }
|
|
|
948 }
|
|
|
949 }
|
|
|
950
|
|
|
951 /* Compile an entire translation unit. Write a file of assembly
|
|
|
952 output and various debugging dumps. */
|
|
|
953
|
|
|
954 static void
|
|
|
955 compile_file (void)
|
|
|
956 {
|
|
|
957 /* Initialize yet another pass. */
|
|
|
958
|
|
|
959 ggc_protect_identifiers = true;
|
|
|
960
|
|
|
961 init_cgraph ();
|
|
|
962 init_final (main_input_filename);
|
|
|
963 coverage_init (aux_base_name);
|
|
|
964 statistics_init ();
|
|
|
965
|
|
|
966 timevar_push (TV_PARSE);
|
|
|
967
|
|
|
968 /* Call the parser, which parses the entire file (calling
|
|
|
969 rest_of_compilation for each function). */
|
|
|
970 lang_hooks.parse_file (set_yydebug);
|
|
|
971
|
|
|
972 /* Compilation is now finished except for writing
|
|
|
973 what's left of the symbol table output. */
|
|
|
974 timevar_pop (TV_PARSE);
|
|
|
975
|
|
|
976 if (flag_syntax_only)
|
|
|
977 return;
|
|
|
978
|
|
|
979 ggc_protect_identifiers = false;
|
|
|
980
|
|
|
981 lang_hooks.decls.final_write_globals ();
|
|
|
982
|
|
|
983 if (errorcount || sorrycount)
|
|
|
984 return;
|
|
|
985
|
|
|
986 varpool_assemble_pending_decls ();
|
|
|
987 finish_aliases_2 ();
|
|
|
988
|
|
|
989 /* This must occur after the loop to output deferred functions.
|
|
|
990 Else the coverage initializer would not be emitted if all the
|
|
|
991 functions in this compilation unit were deferred. */
|
|
|
992 coverage_finish ();
|
|
|
993
|
|
|
994 /* Likewise for mudflap static object registrations. */
|
|
|
995 if (flag_mudflap)
|
|
|
996 mudflap_finish_file ();
|
|
|
997
|
|
|
998 /* Likewise for emulated thread-local storage. */
|
|
|
999 if (!targetm.have_tls)
|
|
|
1000 emutls_finish ();
|
|
|
1001
|
|
|
1002 output_shared_constant_pool ();
|
|
|
1003 output_object_blocks ();
|
|
|
1004
|
|
|
1005 /* Write out any pending weak symbol declarations. */
|
|
|
1006 weak_finish ();
|
|
|
1007
|
|
|
1008 /* Do dbx symbols. */
|
|
|
1009 timevar_push (TV_SYMOUT);
|
|
|
1010
|
|
|
1011 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
|
|
|
1012 if (dwarf2out_do_frame ())
|
|
|
1013 dwarf2out_frame_finish ();
|
|
|
1014 #endif
|
|
|
1015
|
|
|
1016 (*debug_hooks->finish) (main_input_filename);
|
|
|
1017 timevar_pop (TV_SYMOUT);
|
|
|
1018
|
|
|
1019 /* Output some stuff at end of file if nec. */
|
|
|
1020
|
|
|
1021 dw2_output_indirect_constants ();
|
|
|
1022
|
|
|
1023 /* Flush any pending external directives. */
|
|
|
1024 process_pending_assemble_externals ();
|
|
|
1025
|
|
|
1026 /* Attach a special .ident directive to the end of the file to identify
|
|
|
1027 the version of GCC which compiled this code. The format of the .ident
|
|
|
1028 string is patterned after the ones produced by native SVR4 compilers. */
|
|
|
1029 #ifdef IDENT_ASM_OP
|
|
|
1030 if (!flag_no_ident)
|
|
|
1031 {
|
|
|
1032 const char *pkg_version = "(GNU) ";
|
|
|
1033
|
|
|
1034 if (strcmp ("(GCC) ", pkgversion_string))
|
|
|
1035 pkg_version = pkgversion_string;
|
|
|
1036 fprintf (asm_out_file, "%s\"GCC: %s%s\"\n",
|
|
|
1037 IDENT_ASM_OP, pkg_version, version_string);
|
|
|
1038 }
|
|
|
1039 #endif
|
|
|
1040
|
|
|
1041 /* This must be at the end. Some target ports emit end of file directives
|
|
|
1042 into the assembly file here, and hence we can not output anything to the
|
|
|
1043 assembly file after this point. */
|
|
|
1044 targetm.asm_out.file_end ();
|
|
|
1045 }
|
|
|
1046
|
|
|
1047 /* Parse a -d... command line switch. */
|
|
|
1048
|
|
|
1049 void
|
|
|
1050 decode_d_option (const char *arg)
|
|
|
1051 {
|
|
|
1052 int c;
|
|
|
1053
|
|
|
1054 while (*arg)
|
|
|
1055 switch (c = *arg++)
|
|
|
1056 {
|
|
|
1057 case 'A':
|
|
|
1058 flag_debug_asm = 1;
|
|
|
1059 break;
|
|
|
1060 case 'p':
|
|
|
1061 flag_print_asm_name = 1;
|
|
|
1062 break;
|
|
|
1063 case 'P':
|
|
|
1064 flag_dump_rtl_in_asm = 1;
|
|
|
1065 flag_print_asm_name = 1;
|
|
|
1066 break;
|
|
|
1067 case 'v':
|
|
|
1068 graph_dump_format = vcg;
|
|
|
1069 break;
|
|
|
1070 case 'x':
|
|
|
1071 rtl_dump_and_exit = 1;
|
|
|
1072 break;
|
|
|
1073 case 'y':
|
|
|
1074 set_yydebug = 1;
|
|
|
1075 break;
|
|
|
1076 case 'D': /* These are handled by the preprocessor. */
|
|
|
1077 case 'I':
|
|
|
1078 case 'M':
|
|
|
1079 case 'N':
|
|
|
1080 case 'U':
|
|
|
1081 break;
|
|
|
1082 case 'H':
|
|
|
1083 setup_core_dumping();
|
|
|
1084 break;
|
|
|
1085 case 'a':
|
|
|
1086 enable_rtl_dump_file ();
|
|
|
1087 break;
|
|
|
1088
|
|
|
1089 default:
|
|
|
1090 warning (0, "unrecognized gcc debugging option: %c", c);
|
|
|
1091 break;
|
|
|
1092 }
|
|
|
1093 }
|
|
|
1094
|
|
|
1095 /* Indexed by enum debug_info_type. */
|
|
|
1096 const char *const debug_type_names[] =
|
|
|
1097 {
|
|
|
1098 "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
|
|
|
1099 };
|
|
|
1100
|
|
|
1101 /* Print version information to FILE.
|
|
|
1102 Each line begins with INDENT (for the case where FILE is the
|
|
|
1103 assembler output file). */
|
|
|
1104
|
|
|
1105 void
|
|
|
1106 print_version (FILE *file, const char *indent)
|
|
|
1107 {
|
|
|
1108 static const char fmt1[] =
|
|
|
1109 #ifdef __GNUC__
|
|
|
1110 N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
|
|
|
1111 #else
|
|
|
1112 N_("%s%s%s %sversion %s (%s) compiled by CC, ")
|
|
|
1113 #endif
|
|
|
1114 ;
|
|
|
1115 static const char fmt2[] =
|
|
|
1116 N_("GMP version %s, MPFR version %s.\n");
|
|
|
1117 static const char fmt3[] =
|
|
|
1118 N_("%s%swarning: %s header version %s differs from library version %s.\n");
|
|
|
1119 static const char fmt4[] =
|
|
|
1120 N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
|
|
|
1121 #ifndef __VERSION__
|
|
|
1122 #define __VERSION__ "[?]"
|
|
|
1123 #endif
|
|
|
1124 fprintf (file,
|
|
|
1125 file == stderr ? _(fmt1) : fmt1,
|
|
|
1126 indent, *indent != 0 ? " " : "",
|
|
|
1127 lang_hooks.name, pkgversion_string, version_string, TARGET_NAME,
|
|
|
1128 indent, __VERSION__);
|
|
|
1129
|
|
|
1130 /* We need to stringify the GMP macro values. Ugh, gmp_version has
|
|
|
1131 two string formats, "i.j.k" and "i.j" when k is zero. */
|
|
|
1132 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
|
|
|
1133 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
|
|
|
1134 #if __GNU_MP_VERSION_PATCHLEVEL == 0
|
|
|
1135 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
|
|
|
1136 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
|
|
|
1137 #else
|
|
|
1138 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
|
|
|
1139 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \
|
|
|
1140 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL)
|
|
|
1141 #endif
|
|
|
1142 fprintf (file,
|
|
|
1143 file == stderr ? _(fmt2) : fmt2,
|
|
|
1144 GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING);
|
|
|
1145 if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
|
|
|
1146 fprintf (file,
|
|
|
1147 file == stderr ? _(fmt3) : fmt3,
|
|
|
1148 indent, *indent != 0 ? " " : "",
|
|
|
1149 "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
|
|
|
1150 if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ()))
|
|
|
1151 fprintf (file,
|
|
|
1152 file == stderr ? _(fmt3) : fmt3,
|
|
|
1153 indent, *indent != 0 ? " " : "",
|
|
|
1154 "MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
|
|
|
1155 fprintf (file,
|
|
|
1156 file == stderr ? _(fmt4) : fmt4,
|
|
|
1157 indent, *indent != 0 ? " " : "",
|
|
|
1158 PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
|
|
|
1159 }
|
|
|
1160
|
|
|
1161 #ifdef ASM_COMMENT_START
|
|
|
1162 static int
|
|
|
1163 print_to_asm_out_file (print_switch_type type, const char * text)
|
|
|
1164 {
|
|
|
1165 bool prepend_sep = true;
|
|
|
1166
|
|
|
1167 switch (type)
|
|
|
1168 {
|
|
|
1169 case SWITCH_TYPE_LINE_END:
|
|
|
1170 putc ('\n', asm_out_file);
|
|
|
1171 return 1;
|
|
|
1172
|
|
|
1173 case SWITCH_TYPE_LINE_START:
|
|
|
1174 fputs (ASM_COMMENT_START, asm_out_file);
|
|
|
1175 return strlen (ASM_COMMENT_START);
|
|
|
1176
|
|
|
1177 case SWITCH_TYPE_DESCRIPTIVE:
|
|
|
1178 if (ASM_COMMENT_START[0] == 0)
|
|
|
1179 prepend_sep = false;
|
|
|
1180 /* Drop through. */
|
|
|
1181 case SWITCH_TYPE_PASSED:
|
|
|
1182 case SWITCH_TYPE_ENABLED:
|
|
|
1183 if (prepend_sep)
|
|
|
1184 fputc (' ', asm_out_file);
|
|
|
1185 fprintf (asm_out_file, text);
|
|
|
1186 /* No need to return the length here as
|
|
|
1187 print_single_switch has already done it. */
|
|
|
1188 return 0;
|
|
|
1189
|
|
|
1190 default:
|
|
|
1191 return -1;
|
|
|
1192 }
|
|
|
1193 }
|
|
|
1194 #endif
|
|
|
1195
|
|
|
1196 static int
|
|
|
1197 print_to_stderr (print_switch_type type, const char * text)
|
|
|
1198 {
|
|
|
1199 switch (type)
|
|
|
1200 {
|
|
|
1201 case SWITCH_TYPE_LINE_END:
|
|
|
1202 putc ('\n', stderr);
|
|
|
1203 return 1;
|
|
|
1204
|
|
|
1205 case SWITCH_TYPE_LINE_START:
|
|
|
1206 return 0;
|
|
|
1207
|
|
|
1208 case SWITCH_TYPE_PASSED:
|
|
|
1209 case SWITCH_TYPE_ENABLED:
|
|
|
1210 fputc (' ', stderr);
|
|
|
1211 /* Drop through. */
|
|
|
1212
|
|
|
1213 case SWITCH_TYPE_DESCRIPTIVE:
|
|
|
1214 fprintf (stderr, text);
|
|
|
1215 /* No need to return the length here as
|
|
|
1216 print_single_switch has already done it. */
|
|
|
1217 return 0;
|
|
|
1218
|
|
|
1219 default:
|
|
|
1220 return -1;
|
|
|
1221 }
|
|
|
1222 }
|
|
|
1223
|
|
|
1224 /* Print an option value and return the adjusted position in the line.
|
|
|
1225 ??? print_fn doesn't handle errors, eg disk full; presumably other
|
|
|
1226 code will catch a disk full though. */
|
|
|
1227
|
|
|
1228 static int
|
|
|
1229 print_single_switch (print_switch_fn_type print_fn,
|
|
|
1230 int pos,
|
|
|
1231 print_switch_type type,
|
|
|
1232 const char * text)
|
|
|
1233 {
|
|
|
1234 /* The ultrix fprintf returns 0 on success, so compute the result
|
|
|
1235 we want here since we need it for the following test. The +1
|
|
|
1236 is for the separator character that will probably be emitted. */
|
|
|
1237 int len = strlen (text) + 1;
|
|
|
1238
|
|
|
1239 if (pos != 0
|
|
|
1240 && pos + len > MAX_LINE)
|
|
|
1241 {
|
|
|
1242 print_fn (SWITCH_TYPE_LINE_END, NULL);
|
|
|
1243 pos = 0;
|
|
|
1244 }
|
|
|
1245
|
|
|
1246 if (pos == 0)
|
|
|
1247 pos += print_fn (SWITCH_TYPE_LINE_START, NULL);
|
|
|
1248
|
|
|
1249 print_fn (type, text);
|
|
|
1250 return pos + len;
|
|
|
1251 }
|
|
|
1252
|
|
|
1253 /* Print active target switches using PRINT_FN.
|
|
|
1254 POS is the current cursor position and MAX is the size of a "line".
|
|
|
1255 Each line begins with INDENT and ends with TERM.
|
|
|
1256 Each switch is separated from the next by SEP. */
|
|
|
1257
|
|
|
1258 static void
|
|
|
1259 print_switch_values (print_switch_fn_type print_fn)
|
|
|
1260 {
|
|
|
1261 int pos = 0;
|
|
|
1262 size_t j;
|
|
|
1263 const char **p;
|
|
|
1264
|
|
|
1265 /* Fill in the -frandom-seed option, if the user didn't pass it, so
|
|
|
1266 that it can be printed below. This helps reproducibility. */
|
|
|
1267 if (!flag_random_seed)
|
|
|
1268 init_random_seed ();
|
|
|
1269
|
|
|
1270 /* Print the options as passed. */
|
|
|
1271 pos = print_single_switch (print_fn, pos,
|
|
|
1272 SWITCH_TYPE_DESCRIPTIVE, _("options passed: "));
|
|
|
1273
|
|
|
1274 for (p = &save_argv[1]; *p != NULL; p++)
|
|
|
1275 {
|
|
|
1276 if (**p == '-')
|
|
|
1277 {
|
|
|
1278 /* Ignore these. */
|
|
|
1279 if (strcmp (*p, "-o") == 0
|
|
|
1280 || strcmp (*p, "-dumpbase") == 0
|
|
|
1281 || strcmp (*p, "-auxbase") == 0)
|
|
|
1282 {
|
|
|
1283 if (p[1] != NULL)
|
|
|
1284 p++;
|
|
|
1285 continue;
|
|
|
1286 }
|
|
|
1287
|
|
|
1288 if (strcmp (*p, "-quiet") == 0
|
|
|
1289 || strcmp (*p, "-version") == 0)
|
|
|
1290 continue;
|
|
|
1291
|
|
|
1292 if ((*p)[1] == 'd')
|
|
|
1293 continue;
|
|
|
1294 }
|
|
|
1295
|
|
|
1296 pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED, *p);
|
|
|
1297 }
|
|
|
1298
|
|
|
1299 if (pos > 0)
|
|
|
1300 print_fn (SWITCH_TYPE_LINE_END, NULL);
|
|
|
1301
|
|
|
1302 /* Print the -f and -m options that have been enabled.
|
|
|
1303 We don't handle language specific options but printing argv
|
|
|
1304 should suffice. */
|
|
|
1305 pos = print_single_switch (print_fn, 0,
|
|
|
1306 SWITCH_TYPE_DESCRIPTIVE, _("options enabled: "));
|
|
|
1307
|
|
|
1308 for (j = 0; j < cl_options_count; j++)
|
|
|
1309 if ((cl_options[j].flags & CL_REPORT)
|
|
|
1310 && option_enabled (j) > 0)
|
|
|
1311 pos = print_single_switch (print_fn, pos,
|
|
|
1312 SWITCH_TYPE_ENABLED, cl_options[j].opt_text);
|
|
|
1313
|
|
|
1314 print_fn (SWITCH_TYPE_LINE_END, NULL);
|
|
|
1315 }
|
|
|
1316
|
|
|
1317 /* Open assembly code output file. Do this even if -fsyntax-only is
|
|
|
1318 on, because then the driver will have provided the name of a
|
|
|
1319 temporary file or bit bucket for us. NAME is the file specified on
|
|
|
1320 the command line, possibly NULL. */
|
|
|
1321 static void
|
|
|
1322 init_asm_output (const char *name)
|
|
|
1323 {
|
|
|
1324 if (name == NULL && asm_file_name == 0)
|
|
|
1325 asm_out_file = stdout;
|
|
|
1326 else
|
|
|
1327 {
|
|
|
1328 if (asm_file_name == 0)
|
|
|
1329 {
|
|
|
1330 int len = strlen (dump_base_name);
|
|
|
1331 char *dumpname = XNEWVEC (char, len + 6);
|
|
|
1332
|
|
|
1333 memcpy (dumpname, dump_base_name, len + 1);
|
|
|
1334 strip_off_ending (dumpname, len);
|
|
|
1335 strcat (dumpname, ".s");
|
|
|
1336 asm_file_name = dumpname;
|
|
|
1337 }
|
|
|
1338 if (!strcmp (asm_file_name, "-"))
|
|
|
1339 asm_out_file = stdout;
|
|
|
1340 else
|
|
|
1341 asm_out_file = fopen (asm_file_name, "w+b");
|
|
|
1342 if (asm_out_file == 0)
|
|
|
1343 fatal_error ("can%'t open %s for writing: %m", asm_file_name);
|
|
|
1344 }
|
|
|
1345
|
|
|
1346 if (!flag_syntax_only)
|
|
|
1347 {
|
|
|
1348 targetm.asm_out.file_start ();
|
|
|
1349
|
|
|
1350 if (flag_record_gcc_switches)
|
|
|
1351 {
|
|
|
1352 if (targetm.asm_out.record_gcc_switches)
|
|
|
1353 {
|
|
|
1354 /* Let the target know that we are about to start recording. */
|
|
|
1355 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
|
|
|
1356 NULL);
|
|
|
1357 /* Now record the switches. */
|
|
|
1358 print_switch_values (targetm.asm_out.record_gcc_switches);
|
|
|
1359 /* Let the target know that the recording is over. */
|
|
|
1360 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
|
|
|
1361 NULL);
|
|
|
1362 }
|
|
|
1363 else
|
|
|
1364 inform (input_location, "-frecord-gcc-switches is not supported by the current target");
|
|
|
1365 }
|
|
|
1366
|
|
|
1367 #ifdef ASM_COMMENT_START
|
|
|
1368 if (flag_verbose_asm)
|
|
|
1369 {
|
|
|
1370 /* Print the list of switches in effect
|
|
|
1371 into the assembler file as comments. */
|
|
|
1372 print_version (asm_out_file, ASM_COMMENT_START);
|
|
|
1373 print_switch_values (print_to_asm_out_file);
|
|
|
1374 fprintf (asm_out_file, "\n");
|
|
|
1375 }
|
|
|
1376 #endif
|
|
|
1377 }
|
|
|
1378 }
|
|
|
1379
|
|
|
1380 /* Return true if the state of option OPTION should be stored in PCH files
|
|
|
1381 and checked by default_pch_valid_p. Store the option's current state
|
|
|
1382 in STATE if so. */
|
|
|
1383
|
|
|
1384 static inline bool
|
|
|
1385 option_affects_pch_p (int option, struct cl_option_state *state)
|
|
|
1386 {
|
|
|
1387 if ((cl_options[option].flags & CL_TARGET) == 0)
|
|
|
1388 return false;
|
|
|
1389 if (cl_options[option].flag_var == &target_flags)
|
|
|
1390 if (targetm.check_pch_target_flags)
|
|
|
1391 return false;
|
|
|
1392 return get_option_state (option, state);
|
|
|
1393 }
|
|
|
1394
|
|
|
1395 /* Default version of get_pch_validity.
|
|
|
1396 By default, every flag difference is fatal; that will be mostly right for
|
|
|
1397 most targets, but completely right for very few. */
|
|
|
1398
|
|
|
1399 void *
|
|
|
1400 default_get_pch_validity (size_t *len)
|
|
|
1401 {
|
|
|
1402 struct cl_option_state state;
|
|
|
1403 size_t i;
|
|
|
1404 char *result, *r;
|
|
|
1405
|
|
|
1406 *len = 2;
|
|
|
1407 if (targetm.check_pch_target_flags)
|
|
|
1408 *len += sizeof (target_flags);
|
|
|
1409 for (i = 0; i < cl_options_count; i++)
|
|
|
1410 if (option_affects_pch_p (i, &state))
|
|
|
1411 *len += state.size;
|
|
|
1412
|
|
|
1413 result = r = XNEWVEC (char, *len);
|
|
|
1414 r[0] = flag_pic;
|
|
|
1415 r[1] = flag_pie;
|
|
|
1416 r += 2;
|
|
|
1417 if (targetm.check_pch_target_flags)
|
|
|
1418 {
|
|
|
1419 memcpy (r, &target_flags, sizeof (target_flags));
|
|
|
1420 r += sizeof (target_flags);
|
|
|
1421 }
|
|
|
1422
|
|
|
1423 for (i = 0; i < cl_options_count; i++)
|
|
|
1424 if (option_affects_pch_p (i, &state))
|
|
|
1425 {
|
|
|
1426 memcpy (r, state.data, state.size);
|
|
|
1427 r += state.size;
|
|
|
1428 }
|
|
|
1429
|
|
|
1430 return result;
|
|
|
1431 }
|
|
|
1432
|
|
|
1433 /* Return a message which says that a PCH file was created with a different
|
|
|
1434 setting of OPTION. */
|
|
|
1435
|
|
|
1436 static const char *
|
|
|
1437 pch_option_mismatch (const char *option)
|
|
|
1438 {
|
|
|
1439 char *r;
|
|
|
1440
|
|
|
1441 asprintf (&r, _("created and used with differing settings of '%s'"), option);
|
|
|
1442 if (r == NULL)
|
|
|
1443 return _("out of memory");
|
|
|
1444 return r;
|
|
|
1445 }
|
|
|
1446
|
|
|
1447 /* Default version of pch_valid_p. */
|
|
|
1448
|
|
|
1449 const char *
|
|
|
1450 default_pch_valid_p (const void *data_p, size_t len)
|
|
|
1451 {
|
|
|
1452 struct cl_option_state state;
|
|
|
1453 const char *data = (const char *)data_p;
|
|
|
1454 size_t i;
|
|
|
1455
|
|
|
1456 /* -fpic and -fpie also usually make a PCH invalid. */
|
|
|
1457 if (data[0] != flag_pic)
|
|
|
1458 return _("created and used with different settings of -fpic");
|
|
|
1459 if (data[1] != flag_pie)
|
|
|
1460 return _("created and used with different settings of -fpie");
|
|
|
1461 data += 2;
|
|
|
1462
|
|
|
1463 /* Check target_flags. */
|
|
|
1464 if (targetm.check_pch_target_flags)
|
|
|
1465 {
|
|
|
1466 int tf;
|
|
|
1467 const char *r;
|
|
|
1468
|
|
|
1469 memcpy (&tf, data, sizeof (target_flags));
|
|
|
1470 data += sizeof (target_flags);
|
|
|
1471 len -= sizeof (target_flags);
|
|
|
1472 r = targetm.check_pch_target_flags (tf);
|
|
|
1473 if (r != NULL)
|
|
|
1474 return r;
|
|
|
1475 }
|
|
|
1476
|
|
|
1477 for (i = 0; i < cl_options_count; i++)
|
|
|
1478 if (option_affects_pch_p (i, &state))
|
|
|
1479 {
|
|
|
1480 if (memcmp (data, state.data, state.size) != 0)
|
|
|
1481 return pch_option_mismatch (cl_options[i].opt_text);
|
|
|
1482 data += state.size;
|
|
|
1483 len -= state.size;
|
|
|
1484 }
|
|
|
1485
|
|
|
1486 return NULL;
|
|
|
1487 }
|
|
|
1488
|
|
|
1489 /* Default tree printer. Handles declarations only. */
|
|
|
1490 static bool
|
|
|
1491 default_tree_printer (pretty_printer * pp, text_info *text, const char *spec,
|
|
|
1492 int precision, bool wide, bool set_locus, bool hash)
|
|
|
1493 {
|
|
|
1494 tree t;
|
|
|
1495
|
|
|
1496 /* FUTURE: %+x should set the locus. */
|
|
|
1497 if (precision != 0 || wide || hash)
|
|
|
1498 return false;
|
|
|
1499
|
|
|
1500 switch (*spec)
|
|
|
1501 {
|
|
|
1502 case 'D':
|
|
|
1503 t = va_arg (*text->args_ptr, tree);
|
|
|
1504 if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
|
|
|
1505 t = DECL_DEBUG_EXPR (t);
|
|
|
1506 break;
|
|
|
1507
|
|
|
1508 case 'F':
|
|
|
1509 case 'T':
|
|
|
1510 t = va_arg (*text->args_ptr, tree);
|
|
|
1511 break;
|
|
|
1512
|
|
|
1513 default:
|
|
|
1514 return false;
|
|
|
1515 }
|
|
|
1516
|
|
|
1517 if (set_locus && text->locus)
|
|
|
1518 *text->locus = DECL_SOURCE_LOCATION (t);
|
|
|
1519
|
|
|
1520 if (DECL_P (t))
|
|
|
1521 {
|
|
|
1522 const char *n = DECL_NAME (t)
|
|
|
1523 ? lang_hooks.decl_printable_name (t, 2)
|
|
|
1524 : "<anonymous>";
|
|
|
1525 pp_string (pp, n);
|
|
|
1526 }
|
|
|
1527 else
|
|
|
1528 dump_generic_node (pp, t, 0, TDF_DIAGNOSTIC, 0);
|
|
|
1529
|
|
|
1530 return true;
|
|
|
1531 }
|
|
|
1532
|
|
|
1533 /* A helper function; used as the reallocator function for cpp's line
|
|
|
1534 table. */
|
|
|
1535 static void *
|
|
|
1536 realloc_for_line_map (void *ptr, size_t len)
|
|
|
1537 {
|
|
|
1538 return ggc_realloc (ptr, len);
|
|
|
1539 }
|
|
|
1540
|
|
|
1541 /* Initialization of the front end environment, before command line
|
|
|
1542 options are parsed. Signal handlers, internationalization etc.
|
|
|
1543 ARGV0 is main's argv[0]. */
|
|
|
1544 static void
|
|
|
1545 general_init (const char *argv0)
|
|
|
1546 {
|
|
|
1547 const char *p;
|
|
|
1548
|
|
|
1549 p = argv0 + strlen (argv0);
|
|
|
1550 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
|
|
|
1551 --p;
|
|
|
1552 progname = p;
|
|
|
1553
|
|
|
1554 xmalloc_set_program_name (progname);
|
|
|
1555
|
|
|
1556 hex_init ();
|
|
|
1557
|
|
|
1558 /* Unlock the stdio streams. */
|
|
|
1559 unlock_std_streams ();
|
|
|
1560
|
|
|
1561 gcc_init_libintl ();
|
|
|
1562
|
|
|
1563 /* Initialize the diagnostics reporting machinery, so option parsing
|
|
|
1564 can give warnings and errors. */
|
|
|
1565 diagnostic_initialize (global_dc);
|
|
|
1566 /* Set a default printer. Language specific initializations will
|
|
|
1567 override it later. */
|
|
|
1568 pp_format_decoder (global_dc->printer) = &default_tree_printer;
|
|
|
1569
|
|
|
1570 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
|
|
|
1571 #ifdef SIGSEGV
|
|
|
1572 signal (SIGSEGV, crash_signal);
|
|
|
1573 #endif
|
|
|
1574 #ifdef SIGILL
|
|
|
1575 signal (SIGILL, crash_signal);
|
|
|
1576 #endif
|
|
|
1577 #ifdef SIGBUS
|
|
|
1578 signal (SIGBUS, crash_signal);
|
|
|
1579 #endif
|
|
|
1580 #ifdef SIGABRT
|
|
|
1581 signal (SIGABRT, crash_signal);
|
|
|
1582 #endif
|
|
|
1583 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
|
|
|
1584 signal (SIGIOT, crash_signal);
|
|
|
1585 #endif
|
|
|
1586 #ifdef SIGFPE
|
|
|
1587 signal (SIGFPE, crash_signal);
|
|
|
1588 #endif
|
|
|
1589
|
|
|
1590 /* Other host-specific signal setup. */
|
|
|
1591 (*host_hooks.extra_signals)();
|
|
|
1592
|
|
|
1593 /* Initialize the garbage-collector, string pools and tree type hash
|
|
|
1594 table. */
|
|
|
1595 init_ggc ();
|
|
|
1596 init_stringpool ();
|
|
|
1597 line_table = GGC_NEW (struct line_maps);
|
|
|
1598 linemap_init (line_table);
|
|
|
1599 line_table->reallocator = realloc_for_line_map;
|
|
|
1600 init_ttree ();
|
|
|
1601
|
|
|
1602 /* Initialize register usage now so switches may override. */
|
|
|
1603 init_reg_sets ();
|
|
|
1604
|
|
|
1605 /* Register the language-independent parameters. */
|
|
|
1606 add_params (lang_independent_params, LAST_PARAM);
|
|
|
1607
|
|
|
1608 /* This must be done after add_params but before argument processing. */
|
|
|
1609 init_ggc_heuristics();
|
|
|
1610 init_optimization_passes ();
|
|
|
1611 statistics_early_init ();
|
|
|
1612 }
|
|
|
1613
|
|
|
1614 /* Return true if the current target supports -fsection-anchors. */
|
|
|
1615
|
|
|
1616 static bool
|
|
|
1617 target_supports_section_anchors_p (void)
|
|
|
1618 {
|
|
|
1619 if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
|
|
|
1620 return false;
|
|
|
1621
|
|
|
1622 if (targetm.asm_out.output_anchor == NULL)
|
|
|
1623 return false;
|
|
|
1624
|
|
|
1625 return true;
|
|
|
1626 }
|
|
|
1627
|
|
|
1628 /* Default the align_* variables to 1 if they're still unset, and
|
|
|
1629 set up the align_*_log variables. */
|
|
|
1630 static void
|
|
|
1631 init_alignments (void)
|
|
|
1632 {
|
|
|
1633 if (align_loops <= 0)
|
|
|
1634 align_loops = 1;
|
|
|
1635 if (align_loops_max_skip > align_loops)
|
|
|
1636 align_loops_max_skip = align_loops - 1;
|
|
|
1637 align_loops_log = floor_log2 (align_loops * 2 - 1);
|
|
|
1638 if (align_jumps <= 0)
|
|
|
1639 align_jumps = 1;
|
|
|
1640 if (align_jumps_max_skip > align_jumps)
|
|
|
1641 align_jumps_max_skip = align_jumps - 1;
|
|
|
1642 align_jumps_log = floor_log2 (align_jumps * 2 - 1);
|
|
|
1643 if (align_labels <= 0)
|
|
|
1644 align_labels = 1;
|
|
|
1645 align_labels_log = floor_log2 (align_labels * 2 - 1);
|
|
|
1646 if (align_labels_max_skip > align_labels)
|
|
|
1647 align_labels_max_skip = align_labels - 1;
|
|
|
1648 if (align_functions <= 0)
|
|
|
1649 align_functions = 1;
|
|
|
1650 align_functions_log = floor_log2 (align_functions * 2 - 1);
|
|
|
1651 }
|
|
|
1652
|
|
|
1653 /* Process the options that have been parsed. */
|
|
|
1654 static void
|
|
|
1655 process_options (void)
|
|
|
1656 {
|
|
|
1657 /* Just in case lang_hooks.post_options ends up calling a debug_hook.
|
|
|
1658 This can happen with incorrect pre-processed input. */
|
|
|
1659 debug_hooks = &do_nothing_debug_hooks;
|
|
|
1660
|
|
|
1661 /* This replaces set_Wunused. */
|
|
|
1662 if (warn_unused_function == -1)
|
|
|
1663 warn_unused_function = warn_unused;
|
|
|
1664 if (warn_unused_label == -1)
|
|
|
1665 warn_unused_label = warn_unused;
|
|
|
1666 /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled. */
|
|
|
1667 if (warn_unused_parameter == -1)
|
|
|
1668 warn_unused_parameter = (warn_unused && extra_warnings);
|
|
|
1669 if (warn_unused_variable == -1)
|
|
|
1670 warn_unused_variable = warn_unused;
|
|
|
1671 if (warn_unused_value == -1)
|
|
|
1672 warn_unused_value = warn_unused;
|
|
|
1673
|
|
|
1674 /* Allow the front end to perform consistency checks and do further
|
|
|
1675 initialization based on the command line options. This hook also
|
|
|
1676 sets the original filename if appropriate (e.g. foo.i -> foo.c)
|
|
|
1677 so we can correctly initialize debug output. */
|
|
|
1678 no_backend = lang_hooks.post_options (&main_input_filename);
|
|
|
1679
|
|
|
1680 #ifdef OVERRIDE_OPTIONS
|
|
|
1681 /* Some machines may reject certain combinations of options. */
|
|
|
1682 OVERRIDE_OPTIONS;
|
|
|
1683 #endif
|
|
|
1684
|
|
|
1685 if (flag_section_anchors && !target_supports_section_anchors_p ())
|
|
|
1686 {
|
|
|
1687 warning (OPT_fsection_anchors,
|
|
|
1688 "this target does not support %qs", "-fsection-anchors");
|
|
|
1689 flag_section_anchors = 0;
|
|
|
1690 }
|
|
|
1691
|
|
|
1692 if (flag_short_enums == 2)
|
|
|
1693 flag_short_enums = targetm.default_short_enums ();
|
|
|
1694
|
|
|
1695 /* Set aux_base_name if not already set. */
|
|
|
1696 if (aux_base_name)
|
|
|
1697 ;
|
|
|
1698 else if (main_input_filename)
|
|
|
1699 {
|
|
|
1700 char *name = xstrdup (lbasename (main_input_filename));
|
|
|
1701
|
|
|
1702 strip_off_ending (name, strlen (name));
|
|
|
1703 aux_base_name = name;
|
|
|
1704 }
|
|
|
1705 else
|
|
|
1706 aux_base_name = "gccaux";
|
|
|
1707
|
|
|
1708 #ifndef HAVE_cloog
|
|
|
1709 if (flag_graphite
|
|
|
1710 || flag_loop_block
|
|
|
1711 || flag_loop_interchange
|
|
|
1712 || flag_loop_strip_mine
|
|
|
1713 || flag_graphite_identity)
|
|
|
1714 sorry ("Graphite loop optimizations cannot be used");
|
|
|
1715 #endif
|
|
|
1716
|
|
|
1717 /* Unrolling all loops implies that standard loop unrolling must also
|
|
|
1718 be done. */
|
|
|
1719 if (flag_unroll_all_loops)
|
|
|
1720 flag_unroll_loops = 1;
|
|
|
1721
|
|
|
1722 /* The loop unrolling code assumes that cse will be run after loop.
|
|
|
1723 web and rename-registers also help when run after loop unrolling. */
|
|
|
1724
|
|
|
1725 if (flag_rerun_cse_after_loop == AUTODETECT_VALUE)
|
|
|
1726 flag_rerun_cse_after_loop = flag_unroll_loops || flag_peel_loops;
|
|
|
1727 if (flag_web == AUTODETECT_VALUE)
|
|
|
1728 flag_web = flag_unroll_loops || flag_peel_loops;
|
|
|
1729 if (flag_rename_registers == AUTODETECT_VALUE)
|
|
|
1730 flag_rename_registers = flag_unroll_loops || flag_peel_loops;
|
|
|
1731
|
|
|
1732 if (flag_non_call_exceptions)
|
|
|
1733 flag_asynchronous_unwind_tables = 1;
|
|
|
1734 if (flag_asynchronous_unwind_tables)
|
|
|
1735 flag_unwind_tables = 1;
|
|
|
1736
|
|
|
1737 if (flag_value_profile_transformations)
|
|
|
1738 flag_profile_values = 1;
|
|
|
1739
|
|
|
1740 /* Warn about options that are not supported on this machine. */
|
|
|
1741 #ifndef INSN_SCHEDULING
|
|
|
1742 if (flag_schedule_insns || flag_schedule_insns_after_reload)
|
|
|
1743 warning (0, "instruction scheduling not supported on this target machine");
|
|
|
1744 #endif
|
|
|
1745 #ifndef DELAY_SLOTS
|
|
|
1746 if (flag_delayed_branch)
|
|
|
1747 warning (0, "this target machine does not have delayed branches");
|
|
|
1748 #endif
|
|
|
1749
|
|
|
1750 user_label_prefix = USER_LABEL_PREFIX;
|
|
|
1751 if (flag_leading_underscore != -1)
|
|
|
1752 {
|
|
|
1753 /* If the default prefix is more complicated than "" or "_",
|
|
|
1754 issue a warning and ignore this option. */
|
|
|
1755 if (user_label_prefix[0] == 0 ||
|
|
|
1756 (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
|
|
|
1757 {
|
|
|
1758 user_label_prefix = flag_leading_underscore ? "_" : "";
|
|
|
1759 }
|
|
|
1760 else
|
|
|
1761 warning (0, "-f%sleading-underscore not supported on this target machine",
|
|
|
1762 flag_leading_underscore ? "" : "no-");
|
|
|
1763 }
|
|
|
1764
|
|
|
1765 /* If we are in verbose mode, write out the version and maybe all the
|
|
|
1766 option flags in use. */
|
|
|
1767 if (version_flag)
|
|
|
1768 {
|
|
|
1769 print_version (stderr, "");
|
|
|
1770 if (! quiet_flag)
|
|
|
1771 print_switch_values (print_to_stderr);
|
|
|
1772 }
|
|
|
1773
|
|
|
1774 if (flag_syntax_only)
|
|
|
1775 {
|
|
|
1776 write_symbols = NO_DEBUG;
|
|
|
1777 profile_flag = 0;
|
|
|
1778 }
|
|
|
1779
|
|
|
1780 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
|
|
|
1781 level is 0. */
|
|
|
1782 if (debug_info_level == DINFO_LEVEL_NONE)
|
|
|
1783 write_symbols = NO_DEBUG;
|
|
|
1784
|
|
|
1785 /* Now we know write_symbols, set up the debug hooks based on it.
|
|
|
1786 By default we do nothing for debug output. */
|
|
|
1787 if (PREFERRED_DEBUGGING_TYPE == NO_DEBUG)
|
|
|
1788 default_debug_hooks = &do_nothing_debug_hooks;
|
|
|
1789 #if defined(DBX_DEBUGGING_INFO)
|
|
|
1790 else if (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG)
|
|
|
1791 default_debug_hooks = &dbx_debug_hooks;
|
|
|
1792 #endif
|
|
|
1793 #if defined(XCOFF_DEBUGGING_INFO)
|
|
|
1794 else if (PREFERRED_DEBUGGING_TYPE == XCOFF_DEBUG)
|
|
|
1795 default_debug_hooks = &xcoff_debug_hooks;
|
|
|
1796 #endif
|
|
|
1797 #ifdef SDB_DEBUGGING_INFO
|
|
|
1798 else if (PREFERRED_DEBUGGING_TYPE == SDB_DEBUG)
|
|
|
1799 default_debug_hooks = &sdb_debug_hooks;
|
|
|
1800 #endif
|
|
|
1801 #ifdef DWARF2_DEBUGGING_INFO
|
|
|
1802 else if (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG)
|
|
|
1803 default_debug_hooks = &dwarf2_debug_hooks;
|
|
|
1804 #endif
|
|
|
1805 #ifdef VMS_DEBUGGING_INFO
|
|
|
1806 else if (PREFERRED_DEBUGGING_TYPE == VMS_DEBUG
|
|
|
1807 || PREFERRED_DEBUGGING_TYPE == VMS_AND_DWARF2_DEBUG)
|
|
|
1808 default_debug_hooks = &vmsdbg_debug_hooks;
|
|
|
1809 #endif
|
|
|
1810
|
|
|
1811 if (write_symbols == NO_DEBUG)
|
|
|
1812 ;
|
|
|
1813 #if defined(DBX_DEBUGGING_INFO)
|
|
|
1814 else if (write_symbols == DBX_DEBUG)
|
|
|
1815 debug_hooks = &dbx_debug_hooks;
|
|
|
1816 #endif
|
|
|
1817 #if defined(XCOFF_DEBUGGING_INFO)
|
|
|
1818 else if (write_symbols == XCOFF_DEBUG)
|
|
|
1819 debug_hooks = &xcoff_debug_hooks;
|
|
|
1820 #endif
|
|
|
1821 #ifdef SDB_DEBUGGING_INFO
|
|
|
1822 else if (write_symbols == SDB_DEBUG)
|
|
|
1823 debug_hooks = &sdb_debug_hooks;
|
|
|
1824 #endif
|
|
|
1825 #ifdef DWARF2_DEBUGGING_INFO
|
|
|
1826 else if (write_symbols == DWARF2_DEBUG)
|
|
|
1827 debug_hooks = &dwarf2_debug_hooks;
|
|
|
1828 #endif
|
|
|
1829 #ifdef VMS_DEBUGGING_INFO
|
|
|
1830 else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
|
|
|
1831 debug_hooks = &vmsdbg_debug_hooks;
|
|
|
1832 #endif
|
|
|
1833 else
|
|
|
1834 error ("target system does not support the \"%s\" debug format",
|
|
|
1835 debug_type_names[write_symbols]);
|
|
|
1836
|
|
|
1837 /* Now we know which debug output will be used so we can set
|
|
|
1838 flag_var_tracking, flag_rename_registers if the user has
|
|
|
1839 not specified them. */
|
|
|
1840 if (debug_info_level < DINFO_LEVEL_NORMAL
|
|
|
1841 || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
|
|
|
1842 {
|
|
|
1843 if (flag_var_tracking == 1
|
|
|
1844 || flag_var_tracking_uninit == 1)
|
|
|
1845 {
|
|
|
1846 if (debug_info_level < DINFO_LEVEL_NORMAL)
|
|
|
1847 warning (0, "variable tracking requested, but useless unless "
|
|
|
1848 "producing debug info");
|
|
|
1849 else
|
|
|
1850 warning (0, "variable tracking requested, but not supported "
|
|
|
1851 "by this debug format");
|
|
|
1852 }
|
|
|
1853 flag_var_tracking = 0;
|
|
|
1854 flag_var_tracking_uninit = 0;
|
|
|
1855 }
|
|
|
1856
|
|
|
1857 if (flag_rename_registers == AUTODETECT_VALUE)
|
|
|
1858 flag_rename_registers = default_debug_hooks->var_location
|
|
|
1859 != do_nothing_debug_hooks.var_location;
|
|
|
1860
|
|
|
1861 if (flag_var_tracking == AUTODETECT_VALUE)
|
|
|
1862 flag_var_tracking = optimize >= 1;
|
|
|
1863
|
|
|
1864 if (flag_tree_cselim == AUTODETECT_VALUE)
|
|
|
1865 #ifdef HAVE_conditional_move
|
|
|
1866 flag_tree_cselim = 1;
|
|
|
1867 #else
|
|
|
1868 flag_tree_cselim = 0;
|
|
|
1869 #endif
|
|
|
1870
|
|
|
1871 /* If the user specifically requested variable tracking with tagging
|
|
|
1872 uninitialized variables, we need to turn on variable tracking.
|
|
|
1873 (We already determined above that variable tracking is feasible.) */
|
|
|
1874 if (flag_var_tracking_uninit)
|
|
|
1875 flag_var_tracking = 1;
|
|
|
1876
|
|
|
1877 /* If auxiliary info generation is desired, open the output file.
|
|
|
1878 This goes in the same directory as the source file--unlike
|
|
|
1879 all the other output files. */
|
|
|
1880 if (flag_gen_aux_info)
|
|
|
1881 {
|
|
|
1882 aux_info_file = fopen (aux_info_file_name, "w");
|
|
|
1883 if (aux_info_file == 0)
|
|
|
1884 fatal_error ("can%'t open %s: %m", aux_info_file_name);
|
|
|
1885 }
|
|
|
1886
|
|
|
1887 if (! targetm.have_named_sections)
|
|
|
1888 {
|
|
|
1889 if (flag_function_sections)
|
|
|
1890 {
|
|
|
1891 warning (0, "-ffunction-sections not supported for this target");
|
|
|
1892 flag_function_sections = 0;
|
|
|
1893 }
|
|
|
1894 if (flag_data_sections)
|
|
|
1895 {
|
|
|
1896 warning (0, "-fdata-sections not supported for this target");
|
|
|
1897 flag_data_sections = 0;
|
|
|
1898 }
|
|
|
1899 }
|
|
|
1900
|
|
|
1901 if (flag_function_sections && profile_flag)
|
|
|
1902 {
|
|
|
1903 warning (0, "-ffunction-sections disabled; it makes profiling impossible");
|
|
|
1904 flag_function_sections = 0;
|
|
|
1905 }
|
|
|
1906
|
|
|
1907 #ifndef HAVE_prefetch
|
|
|
1908 if (flag_prefetch_loop_arrays)
|
|
|
1909 {
|
|
|
1910 warning (0, "-fprefetch-loop-arrays not supported for this target");
|
|
|
1911 flag_prefetch_loop_arrays = 0;
|
|
|
1912 }
|
|
|
1913 #else
|
|
|
1914 if (flag_prefetch_loop_arrays && !HAVE_prefetch)
|
|
|
1915 {
|
|
|
1916 warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
|
|
|
1917 flag_prefetch_loop_arrays = 0;
|
|
|
1918 }
|
|
|
1919 #endif
|
|
|
1920
|
|
|
1921 /* This combination of options isn't handled for i386 targets and doesn't
|
|
|
1922 make much sense anyway, so don't allow it. */
|
|
|
1923 if (flag_prefetch_loop_arrays && optimize_size)
|
|
|
1924 {
|
|
|
1925 warning (0, "-fprefetch-loop-arrays is not supported with -Os");
|
|
|
1926 flag_prefetch_loop_arrays = 0;
|
|
|
1927 }
|
|
|
1928
|
|
|
1929 /* The presence of IEEE signaling NaNs, implies all math can trap. */
|
|
|
1930 if (flag_signaling_nans)
|
|
|
1931 flag_trapping_math = 1;
|
|
|
1932
|
|
|
1933 /* We cannot reassociate if we want traps or signed zeros. */
|
|
|
1934 if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
|
|
|
1935 {
|
|
|
1936 warning (0, "-fassociative-math disabled; other options take precedence");
|
|
|
1937 flag_associative_math = 0;
|
|
|
1938 }
|
|
|
1939
|
|
|
1940 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
|
|
|
1941 if (flag_cx_limited_range)
|
|
|
1942 flag_complex_method = 0;
|
|
|
1943
|
|
|
1944 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
|
|
|
1945 if (flag_cx_fortran_rules)
|
|
|
1946 flag_complex_method = 1;
|
|
|
1947
|
|
|
1948 /* Targets must be able to place spill slots at lower addresses. If the
|
|
|
1949 target already uses a soft frame pointer, the transition is trivial. */
|
|
|
1950 if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
|
|
|
1951 {
|
|
|
1952 warning (0, "-fstack-protector not supported for this target");
|
|
|
1953 flag_stack_protect = 0;
|
|
|
1954 }
|
|
|
1955 if (!flag_stack_protect)
|
|
|
1956 warn_stack_protect = 0;
|
|
|
1957
|
|
|
1958 /* ??? Unwind info is not correct around the CFG unless either a frame
|
|
|
1959 pointer is present or A_O_A is set. Fixing this requires rewriting
|
|
|
1960 unwind info generation to be aware of the CFG and propagating states
|
|
|
1961 around edges. */
|
|
|
1962 if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS
|
|
|
1963 && flag_omit_frame_pointer)
|
|
|
1964 {
|
|
|
1965 warning (0, "unwind tables currently require a frame pointer "
|
|
|
1966 "for correctness");
|
|
|
1967 flag_omit_frame_pointer = 0;
|
|
|
1968 }
|
|
|
1969 }
|
|
|
1970
|
|
|
1971 /* This function can be called multiple times to reinitialize the compiler
|
|
|
1972 back end when register classes or instruction sets have changed,
|
|
|
1973 before each function. */
|
|
|
1974 static void
|
|
|
1975 backend_init_target (void)
|
|
|
1976 {
|
|
|
1977 /* Initialize alignment variables. */
|
|
|
1978 init_alignments ();
|
|
|
1979
|
|
|
1980 /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
|
|
|
1981 to initialize reg_raw_mode[]. */
|
|
|
1982 init_emit_regs ();
|
|
|
1983
|
|
|
1984 /* This invokes target hooks to set fixed_reg[] etc, which is
|
|
|
1985 mode-dependent. */
|
|
|
1986 init_regs ();
|
|
|
1987
|
|
|
1988 /* This depends on stack_pointer_rtx. */
|
|
|
1989 init_fake_stack_mems ();
|
|
|
1990
|
|
|
1991 /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
|
|
|
1992 mode-dependent. */
|
|
|
1993 init_alias_target ();
|
|
|
1994
|
|
|
1995 /* Depends on HARD_FRAME_POINTER_REGNUM. */
|
|
|
1996 init_reload ();
|
|
|
1997
|
|
|
1998 /* The following initialization functions need to generate rtl, so
|
|
|
1999 provide a dummy function context for them. */
|
|
|
2000 init_dummy_function_start ();
|
|
|
2001
|
|
|
2002 /* rtx_cost is mode-dependent, so cached values need to be recomputed
|
|
|
2003 on a mode change. */
|
|
|
2004 init_expmed ();
|
|
|
2005
|
|
|
2006 /* We may need to recompute regno_save_code[] and regno_restore_code[]
|
|
|
2007 after a mode change as well. */
|
|
|
2008 if (flag_caller_saves)
|
|
|
2009 init_caller_save ();
|
|
|
2010 expand_dummy_function_end ();
|
|
|
2011 }
|
|
|
2012
|
|
|
2013 /* Initialize the compiler back end. This function is called only once,
|
|
|
2014 when starting the compiler. */
|
|
|
2015 static void
|
|
|
2016 backend_init (void)
|
|
|
2017 {
|
|
|
2018 init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
|
|
|
2019 || debug_info_level == DINFO_LEVEL_VERBOSE
|
|
|
2020 #ifdef VMS_DEBUGGING_INFO
|
|
|
2021 /* Enable line number info for traceback. */
|
|
|
2022 || debug_info_level > DINFO_LEVEL_NONE
|
|
|
2023 #endif
|
|
|
2024 || flag_test_coverage);
|
|
|
2025
|
|
|
2026 init_rtlanal ();
|
|
|
2027 init_inline_once ();
|
|
|
2028 init_varasm_once ();
|
|
|
2029 save_register_info ();
|
|
|
2030
|
|
|
2031 /* Initialize the target-specific back end pieces. */
|
|
|
2032 ira_init_once ();
|
|
|
2033 backend_init_target ();
|
|
|
2034 }
|
|
|
2035
|
|
|
2036 /* Initialize things that are both lang-dependent and target-dependent.
|
|
|
2037 This function can be called more than once if target parameters change. */
|
|
|
2038 static void
|
|
|
2039 lang_dependent_init_target (void)
|
|
|
2040 {
|
|
|
2041 /* This creates various _DECL nodes, so needs to be called after the
|
|
|
2042 front end is initialized. It also depends on the HAVE_xxx macros
|
|
|
2043 generated from the target machine description. */
|
|
|
2044 init_optabs ();
|
|
|
2045
|
|
|
2046 /* The following initialization functions need to generate rtl, so
|
|
|
2047 provide a dummy function context for them. */
|
|
|
2048 init_dummy_function_start ();
|
|
|
2049
|
|
|
2050 /* Do the target-specific parts of expr initialization. */
|
|
|
2051 init_expr_target ();
|
|
|
2052
|
|
|
2053 /* Although the actions of these functions are language-independent,
|
|
|
2054 they use optabs, so we cannot call them from backend_init. */
|
|
|
2055 init_set_costs ();
|
|
|
2056 ira_init ();
|
|
|
2057
|
|
|
2058 expand_dummy_function_end ();
|
|
|
2059 }
|
|
|
2060
|
|
|
2061 /* Language-dependent initialization. Returns nonzero on success. */
|
|
|
2062 static int
|
|
|
2063 lang_dependent_init (const char *name)
|
|
|
2064 {
|
|
|
2065 location_t save_loc = input_location;
|
|
|
2066 if (dump_base_name == 0)
|
|
|
2067 dump_base_name = name && name[0] ? name : "gccdump";
|
|
|
2068
|
|
|
2069 /* Other front-end initialization. */
|
|
|
2070 input_location = BUILTINS_LOCATION;
|
|
|
2071 if (lang_hooks.init () == 0)
|
|
|
2072 return 0;
|
|
|
2073 input_location = save_loc;
|
|
|
2074
|
|
|
2075 init_asm_output (name);
|
|
|
2076
|
|
|
2077 /* This creates various _DECL nodes, so needs to be called after the
|
|
|
2078 front end is initialized. */
|
|
|
2079 init_eh ();
|
|
|
2080
|
|
|
2081 /* Do the target-specific parts of the initialization. */
|
|
|
2082 lang_dependent_init_target ();
|
|
|
2083
|
|
|
2084 /* If dbx symbol table desired, initialize writing it and output the
|
|
|
2085 predefined types. */
|
|
|
2086 timevar_push (TV_SYMOUT);
|
|
|
2087
|
|
|
2088 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
|
|
|
2089 if (dwarf2out_do_frame ())
|
|
|
2090 dwarf2out_frame_init ();
|
|
|
2091 #endif
|
|
|
2092
|
|
|
2093 /* Now we have the correct original filename, we can initialize
|
|
|
2094 debug output. */
|
|
|
2095 (*debug_hooks->init) (name);
|
|
|
2096
|
|
|
2097 timevar_pop (TV_SYMOUT);
|
|
|
2098
|
|
|
2099 return 1;
|
|
|
2100 }
|
|
|
2101
|
|
|
2102
|
|
|
2103 /* Reinitialize everything when target parameters, such as register usage,
|
|
|
2104 have changed. */
|
|
|
2105 void
|
|
|
2106 target_reinit (void)
|
|
|
2107 {
|
|
|
2108 /* Reinitialize RTL backend. */
|
|
|
2109 backend_init_target ();
|
|
|
2110
|
|
|
2111 /* Reinitialize lang-dependent parts. */
|
|
|
2112 lang_dependent_init_target ();
|
|
|
2113 }
|
|
|
2114
|
|
|
2115 void
|
|
|
2116 dump_memory_report (bool final)
|
|
|
2117 {
|
|
|
2118 ggc_print_statistics ();
|
|
|
2119 stringpool_statistics ();
|
|
|
2120 dump_tree_statistics ();
|
|
|
2121 dump_gimple_statistics ();
|
|
|
2122 dump_rtx_statistics ();
|
|
|
2123 dump_varray_statistics ();
|
|
|
2124 dump_alloc_pool_statistics ();
|
|
|
2125 dump_bitmap_statistics ();
|
|
|
2126 dump_vec_loc_statistics ();
|
|
|
2127 dump_ggc_loc_statistics (final);
|
|
|
2128 }
|
|
|
2129
|
|
|
2130 /* Clean up: close opened files, etc. */
|
|
|
2131
|
|
|
2132 static void
|
|
|
2133 finalize (void)
|
|
|
2134 {
|
|
|
2135 /* Close the dump files. */
|
|
|
2136 if (flag_gen_aux_info)
|
|
|
2137 {
|
|
|
2138 fclose (aux_info_file);
|
|
|
2139 if (errorcount)
|
|
|
2140 unlink (aux_info_file_name);
|
|
|
2141 }
|
|
|
2142
|
|
|
2143 /* Close non-debugging input and output files. Take special care to note
|
|
|
2144 whether fclose returns an error, since the pages might still be on the
|
|
|
2145 buffer chain while the file is open. */
|
|
|
2146
|
|
|
2147 if (asm_out_file)
|
|
|
2148 {
|
|
|
2149 if (ferror (asm_out_file) != 0)
|
|
|
2150 fatal_error ("error writing to %s: %m", asm_file_name);
|
|
|
2151 if (fclose (asm_out_file) != 0)
|
|
|
2152 fatal_error ("error closing %s: %m", asm_file_name);
|
|
|
2153 }
|
|
|
2154
|
|
|
2155 statistics_fini ();
|
|
|
2156 finish_optimization_passes ();
|
|
|
2157
|
|
|
2158 ira_finish_once ();
|
|
|
2159
|
|
|
2160 if (mem_report)
|
|
|
2161 dump_memory_report (true);
|
|
|
2162
|
|
|
2163 /* Language-specific end of compilation actions. */
|
|
|
2164 lang_hooks.finish ();
|
|
|
2165 }
|
|
|
2166
|
|
|
2167 /* Initialize the compiler, and compile the input file. */
|
|
|
2168 static void
|
|
|
2169 do_compile (void)
|
|
|
2170 {
|
|
|
2171 /* Initialize timing first. The C front ends read the main file in
|
|
|
2172 the post_options hook, and C++ does file timings. */
|
|
|
2173 if (time_report || !quiet_flag || flag_detailed_statistics)
|
|
|
2174 timevar_init ();
|
|
|
2175 timevar_start (TV_TOTAL);
|
|
|
2176
|
|
|
2177 process_options ();
|
|
|
2178
|
|
|
2179 /* Don't do any more if an error has already occurred. */
|
|
|
2180 if (!errorcount)
|
|
|
2181 {
|
|
|
2182 /* This must be run always, because it is needed to compute the FP
|
|
|
2183 predefined macros, such as __LDBL_MAX__, for targets using non
|
|
|
2184 default FP formats. */
|
|
|
2185 init_adjust_machine_modes ();
|
|
|
2186
|
|
|
2187 /* Set up the back-end if requested. */
|
|
|
2188 if (!no_backend)
|
|
|
2189 backend_init ();
|
|
|
2190
|
|
|
2191 /* Language-dependent initialization. Returns true on success. */
|
|
|
2192 if (lang_dependent_init (main_input_filename))
|
|
|
2193 compile_file ();
|
|
|
2194
|
|
|
2195 finalize ();
|
|
|
2196 }
|
|
|
2197
|
|
|
2198 /* Stop timing and print the times. */
|
|
|
2199 timevar_stop (TV_TOTAL);
|
|
|
2200 timevar_print (stderr);
|
|
|
2201 }
|
|
|
2202
|
|
|
2203 /* Entry point of cc1, cc1plus, jc1, f771, etc.
|
|
|
2204 Exit code is FATAL_EXIT_CODE if can't open files or if there were
|
|
|
2205 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
|
|
|
2206
|
|
|
2207 It is not safe to call this function more than once. */
|
|
|
2208
|
|
|
2209 int
|
|
|
2210 toplev_main (unsigned int argc, const char **argv)
|
|
|
2211 {
|
|
|
2212 save_argv = argv;
|
|
|
2213
|
|
|
2214 /* Initialization of GCC's environment, and diagnostics. */
|
|
|
2215 general_init (argv[0]);
|
|
|
2216
|
|
|
2217 /* Parse the options and do minimal processing; basically just
|
|
|
2218 enough to default flags appropriately. */
|
|
|
2219 decode_options (argc, argv);
|
|
|
2220
|
|
|
2221 init_local_tick ();
|
|
|
2222
|
|
|
2223 /* Exit early if we can (e.g. -help). */
|
|
|
2224 if (!exit_after_options)
|
|
|
2225 do_compile ();
|
|
|
2226
|
|
|
2227 if (warningcount || errorcount)
|
|
|
2228 print_ignored_options ();
|
|
|
2229
|
|
|
2230 if (errorcount || sorrycount)
|
|
|
2231 return (FATAL_EXIT_CODE);
|
|
|
2232
|
|
|
2233 return (SUCCESS_EXIT_CODE);
|
|
|
2234 }
|
