]>
Commit | Line | Data |
---|---|---|
bccafa26 | 1 | /* Top level of GCC compilers (cc1, cc1plus, etc.) |
d353bf18 | 2 | Copyright (C) 1987-2015 Free Software Foundation, Inc. |
3bcb26d1 | 3 | |
f12b58b3 | 4 | This file is part of GCC. |
3bcb26d1 | 5 | |
f12b58b3 | 6 | GCC is free software; you can redistribute it and/or modify it under |
7 | the terms of the GNU General Public License as published by the Free | |
8c4c00c1 | 8 | Software Foundation; either version 3, or (at your option) any later |
f12b58b3 | 9 | version. |
3bcb26d1 | 10 | |
f12b58b3 | 11 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
12 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
14 | for more details. | |
3bcb26d1 | 15 | |
16 | You should have received a copy of the GNU General Public License | |
8c4c00c1 | 17 | along with GCC; see the file COPYING3. If not see |
18 | <http://www.gnu.org/licenses/>. */ | |
3bcb26d1 | 19 | |
3bcb26d1 | 20 | /* This is the top level of cc1/c++. |
21 | It parses command args, opens files, invokes the various passes | |
22 | in the proper order, and counts the time used by each. | |
23 | Error messages and low-level interface to malloc also handled here. */ | |
24 | ||
25 | #include "config.h" | |
405711de | 26 | #include "system.h" |
805e22b2 | 27 | #include "coretypes.h" |
28 | #include "tm.h" | |
de269355 | 29 | #include "line-map.h" |
3bcb26d1 | 30 | #include "input.h" |
b20a8bb4 | 31 | #include "hash-set.h" |
32 | #include "machmode.h" | |
33 | #include "vec.h" | |
34 | #include "double-int.h" | |
b20a8bb4 | 35 | #include "alias.h" |
36 | #include "symtab.h" | |
37 | #include "wide-int.h" | |
38 | #include "inchash.h" | |
3bcb26d1 | 39 | #include "tree.h" |
b20a8bb4 | 40 | #include "fold-const.h" |
9ed99284 | 41 | #include "varasm.h" |
42 | #include "tree-inline.h" | |
dae0b5cb | 43 | #include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version. */ |
af225e7d | 44 | #include "version.h" |
3bcb26d1 | 45 | #include "rtl.h" |
7953c610 | 46 | #include "tm_p.h" |
3bcb26d1 | 47 | #include "flags.h" |
48 | #include "insn-attr.h" | |
997d68fe | 49 | #include "insn-config.h" |
ba38e12b | 50 | #include "insn-flags.h" |
3e9f1237 | 51 | #include "hard-reg-set.h" |
997d68fe | 52 | #include "recog.h" |
1ff68c01 | 53 | #include "output.h" |
037a5228 | 54 | #include "except.h" |
0a893c29 | 55 | #include "function.h" |
c3ab7bd5 | 56 | #include "toplev.h" |
d53441c8 | 57 | #include "hashtab.h" |
58 | #include "statistics.h" | |
59 | #include "real.h" | |
60 | #include "fixed-value.h" | |
61 | #include "expmed.h" | |
62 | #include "dojump.h" | |
63 | #include "explow.h" | |
64 | #include "calls.h" | |
65 | #include "emit-rtl.h" | |
66 | #include "stmt.h" | |
74273693 | 67 | #include "expr.h" |
be2828ce | 68 | #include "intl.h" |
5d0e87b7 | 69 | #include "regs.h" |
74d2af64 | 70 | #include "timevar.h" |
990339dd | 71 | #include "diagnostic.h" |
ce084dfc | 72 | #include "tree-diagnostic.h" |
73 | #include "tree-pretty-print.h" | |
9a33a2e8 | 74 | #include "params.h" |
75eb327c | 75 | #include "reload.h" |
47dd2e78 | 76 | #include "ira.h" |
0c61fbed | 77 | #include "lra.h" |
8a34c73b | 78 | #include "dwarf2asm.h" |
b896d81b | 79 | #include "debug.h" |
2cb4ac60 | 80 | #include "target.h" |
218e3e4e | 81 | #include "common/common-target.h" |
b0278d39 | 82 | #include "langhooks.h" |
0f246197 | 83 | #include "cfgloop.h" /* for init_set_costs */ |
b197fbcf | 84 | #include "hosthooks.h" |
94ea8568 | 85 | #include "predict.h" |
86 | #include "basic-block.h" | |
1140c305 | 87 | #include "hash-map.h" |
88 | #include "is-a.h" | |
89 | #include "plugin-api.h" | |
90 | #include "ipa-ref.h" | |
28992b23 | 91 | #include "cgraph.h" |
5457b645 | 92 | #include "opts.h" |
3c6a9715 | 93 | #include "opts-diagnostic.h" |
a0ed384d | 94 | #include "coverage.h" |
1c6a7b8c | 95 | #include "value-prof.h" |
15ac28e3 | 96 | #include "alloc-pool.h" |
b92cccf4 | 97 | #include "asan.h" |
b077695d | 98 | #include "tsan.h" |
dd277d48 | 99 | #include "tree-ssa-alias.h" |
bc61cadb | 100 | #include "internal-fn.h" |
101 | #include "gimple-expr.h" | |
102 | #include "gimple.h" | |
9227b6fc | 103 | #include "plugin.h" |
8d0badf1 | 104 | #include "context.h" |
bcfddb5b | 105 | #include "pass_manager.h" |
94bed7c3 | 106 | #include "auto-profile.h" |
415309e2 | 107 | #include "dwarf2out.h" |
1140c305 | 108 | #include "bitmap.h" |
415309e2 | 109 | #include "ipa-reference.h" |
a5d83f7d | 110 | #include "symbol-summary.h" |
415309e2 | 111 | #include "ipa-prop.h" |
112 | #include "gcse.h" | |
34517c64 | 113 | #include "insn-codes.h" |
2265e215 | 114 | #include "optabs.h" |
058a1b7a | 115 | #include "tree-chkp.h" |
dccabdd1 | 116 | #include "omp-low.h" |
e3a24b9a | 117 | |
02da6382 | 118 | #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO) |
744d3441 | 119 | #include "dbxout.h" |
120 | #endif | |
121 | ||
122 | #ifdef SDB_DEBUGGING_INFO | |
123 | #include "sdbout.h" | |
124 | #endif | |
397c7bc7 | 125 | |
126 | #ifdef XCOFF_DEBUGGING_INFO | |
127 | #include "xcoffout.h" /* Needed for external data | |
128 | declarations for e.g. AIX 4.x. */ | |
129 | #endif | |
03414cfb | 130 | |
def3bf8c | 131 | #ifndef HAVE_epilogue |
132 | #define HAVE_epilogue 0 | |
133 | #endif | |
134 | #ifndef HAVE_prologue | |
135 | #define HAVE_prologue 0 | |
136 | #endif | |
137 | ||
35ee1c66 | 138 | #include <new> |
139 | ||
4d31ecc4 | 140 | static void general_init (const char *, bool); |
415309e2 | 141 | static void do_compile (); |
7237deda | 142 | static void process_options (void); |
143 | static void backend_init (void); | |
144 | static int lang_dependent_init (const char *); | |
145 | static void init_asm_output (const char *); | |
f666c964 | 146 | static void finalize (bool); |
7237deda | 147 | |
7237deda | 148 | static void crash_signal (int) ATTRIBUTE_NORETURN; |
7237deda | 149 | static void compile_file (void); |
7237deda | 150 | |
03bde601 | 151 | /* True if we don't need a backend (e.g. preprocessing only). */ |
152 | static bool no_backend; | |
153 | ||
e87e2aa9 | 154 | /* Length of line when printing switch values. */ |
155 | #define MAX_LINE 75 | |
156 | ||
615ef0bb | 157 | /* Decoded options, and number of such options. */ |
e3d1ab2b | 158 | struct cl_decoded_option *save_decoded_options; |
159 | unsigned int save_decoded_options_count; | |
03414cfb | 160 | |
ad469377 | 161 | /* Used to enable -fvar-tracking, -fweb and -frename-registers according |
2a95155a | 162 | to optimize in process_options (). */ |
472cd78a | 163 | #define AUTODETECT_VALUE 2 |
ad469377 | 164 | |
b896d81b | 165 | /* Debug hooks - dependent upon command line options. */ |
166 | ||
b0e56fb1 | 167 | const struct gcc_debug_hooks *debug_hooks; |
b896d81b | 168 | |
d0309f39 | 169 | /* The FUNCTION_DECL for the function currently being compiled, |
170 | or 0 if between functions. */ | |
171 | tree current_function_decl; | |
172 | ||
2d754264 | 173 | /* Set to the FUNC_BEGIN label of the current function, or NULL |
d0309f39 | 174 | if none. */ |
2d754264 | 175 | const char * current_function_func_begin_label; |
d0309f39 | 176 | |
81d47035 | 177 | /* A random sequence of characters, unless overridden by user. */ |
b6c1bd72 | 178 | static const char *flag_random_seed; |
b80f1d67 | 179 | |
180 | /* A local time stamp derived from the time of compilation. It will be | |
181 | zero if the system cannot provide a time. It will be -1u, if the | |
182 | user has specified a particular random seed. */ | |
183 | unsigned local_tick; | |
184 | ||
badc6cfa | 185 | /* Random number for this compilation */ |
186 | HOST_WIDE_INT random_seed; | |
187 | ||
3bcb26d1 | 188 | /* -f flags. */ |
189 | ||
8f8ac140 | 190 | /* When non-NULL, indicates that whenever space is allocated on the |
191 | stack, the resulting stack pointer must not pass this | |
192 | address---that is, for stacks that grow downward, the stack pointer | |
193 | must always be greater than or equal to this address; for stacks | |
194 | that grow upward, the stack pointer must be less than this address. | |
195 | At present, the rtx may be either a REG or a SYMBOL_REF, although | |
196 | the support provided depends on the backend. */ | |
197 | rtx stack_limit_rtx; | |
198 | ||
065efcb1 | 199 | /* True if the user has tagged the function with the 'section' |
200 | attribute. */ | |
201 | ||
202 | bool user_defined_section_attribute = false; | |
203 | ||
821d4118 | 204 | struct target_flag_state default_target_flag_state; |
205 | #if SWITCHABLE_TARGET | |
206 | struct target_flag_state *this_target_flag_state = &default_target_flag_state; | |
207 | #else | |
208 | #define this_target_flag_state (&default_target_flag_state) | |
209 | #endif | |
61e95947 | 210 | |
95c4b02a | 211 | /* The user symbol prefix after having resolved same. */ |
951f0f62 | 212 | const char *user_label_prefix; |
95c4b02a | 213 | |
3bcb26d1 | 214 | /* Output files for assembler code (real compiler output) |
215 | and debugging dumps. */ | |
216 | ||
217 | FILE *asm_out_file; | |
218 | FILE *aux_info_file; | |
990495a7 | 219 | FILE *stack_usage_file = NULL; |
3bcb26d1 | 220 | |
e7aa92b2 | 221 | /* The current working directory of a translation. It's generally the |
222 | directory from which compilation was initiated, but a preprocessed | |
223 | file may specify the original directory in which it was | |
224 | created. */ | |
225 | ||
226 | static const char *src_pwd; | |
227 | ||
228 | /* Initialize src_pwd with the given string, and return true. If it | |
229 | was already initialized, return false. As a special case, it may | |
230 | be called with a NULL argument to test whether src_pwd has NOT been | |
231 | initialized yet. */ | |
232 | ||
233 | bool | |
234 | set_src_pwd (const char *pwd) | |
235 | { | |
236 | if (src_pwd) | |
dc1dd09b | 237 | { |
238 | if (strcmp (src_pwd, pwd) == 0) | |
239 | return true; | |
240 | else | |
241 | return false; | |
242 | } | |
e7aa92b2 | 243 | |
244 | src_pwd = xstrdup (pwd); | |
245 | return true; | |
246 | } | |
247 | ||
248 | /* Return the directory from which the translation unit was initiated, | |
249 | in case set_src_pwd() was not called before to assign it a | |
250 | different value. */ | |
251 | ||
252 | const char * | |
253 | get_src_pwd (void) | |
254 | { | |
255 | if (! src_pwd) | |
8bc418a1 | 256 | { |
257 | src_pwd = getpwd (); | |
258 | if (!src_pwd) | |
259 | src_pwd = "."; | |
260 | } | |
e7aa92b2 | 261 | |
262 | return src_pwd; | |
263 | } | |
264 | ||
53d712d9 | 265 | /* Called when the start of a function definition is parsed, |
266 | this function prints on stderr the name of the function. */ | |
267 | void | |
268 | announce_function (tree decl) | |
269 | { | |
270 | if (!quiet_flag) | |
271 | { | |
272 | if (rtl_dump_and_exit) | |
abd3e6b5 | 273 | fprintf (stderr, "%s ", |
274 | identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)))); | |
53d712d9 | 275 | else |
abd3e6b5 | 276 | fprintf (stderr, " %s", |
277 | identifier_to_locale (lang_hooks.decl_printable_name (decl, 2))); | |
53d712d9 | 278 | fflush (stderr); |
279 | pp_needs_newline (global_dc->printer) = true; | |
b8c23db3 | 280 | diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL); |
53d712d9 | 281 | } |
282 | } | |
283 | ||
badc6cfa | 284 | /* Initialize local_tick with a random number or -1 if |
b6c1bd72 | 285 | flag_random_seed is set. */ |
b80f1d67 | 286 | |
287 | static void | |
b6c1bd72 | 288 | init_local_tick (void) |
b80f1d67 | 289 | { |
290 | if (!flag_random_seed) | |
291 | { | |
ad766573 | 292 | /* Try urandom first. Time of day is too likely to collide. |
293 | In case of any error we just use the local tick. */ | |
294 | ||
295 | int fd = open ("/dev/urandom", O_RDONLY); | |
296 | if (fd >= 0) | |
297 | { | |
e351f8ce | 298 | if (read (fd, &random_seed, sizeof (random_seed)) |
299 | != sizeof (random_seed)) | |
300 | random_seed = 0; | |
ad766573 | 301 | close (fd); |
302 | } | |
303 | ||
304 | /* Now get the tick anyways */ | |
b80f1d67 | 305 | #ifdef HAVE_GETTIMEOFDAY |
306 | { | |
b6c1bd72 | 307 | struct timeval tv; |
7e614678 | 308 | |
b6c1bd72 | 309 | gettimeofday (&tv, NULL); |
80dc2066 | 310 | local_tick = (unsigned) tv.tv_sec * 1000 + tv.tv_usec / 1000; |
b80f1d67 | 311 | } |
312 | #else | |
313 | { | |
c48e08ab | 314 | time_t now = time (NULL); |
b80f1d67 | 315 | |
316 | if (now != (time_t)-1) | |
317 | local_tick = (unsigned) now; | |
318 | } | |
319 | #endif | |
b80f1d67 | 320 | } |
b6c1bd72 | 321 | else |
b80f1d67 | 322 | local_tick = -1; |
323 | } | |
324 | ||
b6c1bd72 | 325 | /* Set up a default flag_random_seed and local_tick, unless the user |
326 | already specified one. Must be called after init_local_tick. */ | |
327 | ||
328 | static void | |
329 | init_random_seed (void) | |
330 | { | |
8c3766fd | 331 | if (!random_seed) |
badc6cfa | 332 | random_seed = local_tick ^ getpid (); /* Old racey fallback method */ |
b6c1bd72 | 333 | } |
334 | ||
badc6cfa | 335 | /* Obtain the random_seed. Unless NOINIT, initialize it if |
b6c1bd72 | 336 | it's not provided in the command line. */ |
337 | ||
badc6cfa | 338 | HOST_WIDE_INT |
b6c1bd72 | 339 | get_random_seed (bool noinit) |
340 | { | |
341 | if (!flag_random_seed && !noinit) | |
342 | init_random_seed (); | |
badc6cfa | 343 | return random_seed; |
b6c1bd72 | 344 | } |
345 | ||
346 | /* Modify the random_seed string to VAL. Return its previous | |
347 | value. */ | |
348 | ||
349 | const char * | |
350 | set_random_seed (const char *val) | |
351 | { | |
352 | const char *old = flag_random_seed; | |
353 | flag_random_seed = val; | |
8c3766fd | 354 | if (flag_random_seed) |
355 | { | |
356 | char *endp; | |
357 | ||
358 | /* When the driver passed in a hex number don't crc it again */ | |
359 | random_seed = strtoul (flag_random_seed, &endp, 0); | |
360 | if (!(endp > flag_random_seed && *endp == 0)) | |
361 | random_seed = crc32_string (0, flag_random_seed); | |
362 | } | |
b6c1bd72 | 363 | return old; |
364 | } | |
b80f1d67 | 365 | |
b9b90cce | 366 | /* Handler for fatal signals, such as SIGSEGV. These are transformed |
3a2aee0e | 367 | into ICE messages, which is much more user friendly. In case the |
368 | error printer crashes, reset the signal to prevent infinite recursion. */ | |
3bcb26d1 | 369 | |
370 | static void | |
7237deda | 371 | crash_signal (int signo) |
3bcb26d1 | 372 | { |
3a2aee0e | 373 | signal (signo, SIG_DFL); |
c706a9d9 | 374 | |
375 | /* If we crashed while processing an ASM statement, then be a little more | |
376 | graceful. It's most likely the user's fault. */ | |
377 | if (this_is_asm_operands) | |
378 | { | |
379 | output_operand_lossage ("unrecoverable error"); | |
380 | exit (FATAL_EXIT_CODE); | |
381 | } | |
382 | ||
59b7a777 | 383 | internal_error ("%s", strsignal (signo)); |
3bcb26d1 | 384 | } |
385 | ||
c131e678 | 386 | /* A subroutine of wrapup_global_declarations. We've come to the end of |
387 | the compilation unit. All deferred variables should be undeferred, | |
388 | and all incomplete decls should be finalized. */ | |
389 | ||
390 | void | |
391 | wrapup_global_declaration_1 (tree decl) | |
392 | { | |
393 | /* We're not deferring this any longer. Assignment is conditional to | |
394 | avoid needlessly dirtying PCH pages. */ | |
395 | if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS) | |
396 | && DECL_DEFER_OUTPUT (decl) != 0) | |
397 | DECL_DEFER_OUTPUT (decl) = 0; | |
398 | ||
399 | if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0) | |
400 | lang_hooks.finish_incomplete_decl (decl); | |
401 | } | |
402 | ||
403 | /* A subroutine of wrapup_global_declarations. Decide whether or not DECL | |
404 | needs to be output. Return true if it is output. */ | |
405 | ||
406 | bool | |
407 | wrapup_global_declaration_2 (tree decl) | |
408 | { | |
3d1c0354 | 409 | if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl) |
410 | || (TREE_CODE (decl) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (decl))) | |
c131e678 | 411 | return false; |
412 | ||
413 | /* Don't write out static consts, unless we still need them. | |
414 | ||
415 | We also keep static consts if not optimizing (for debugging), | |
416 | unless the user specified -fno-keep-static-consts. | |
417 | ??? They might be better written into the debug information. | |
418 | This is possible when using DWARF. | |
419 | ||
420 | A language processor that wants static constants to be always | |
421 | written out (even if it is not used) is responsible for | |
422 | calling rest_of_decl_compilation itself. E.g. the C front-end | |
423 | calls rest_of_decl_compilation from finish_decl. | |
424 | One motivation for this is that is conventional in some | |
425 | environments to write things like: | |
426 | static const char rcsid[] = "... version string ..."; | |
427 | intending to force the string to be in the executable. | |
428 | ||
429 | A language processor that would prefer to have unneeded | |
430 | static constants "optimized away" would just defer writing | |
431 | them out until here. E.g. C++ does this, because static | |
432 | constants are often defined in header files. | |
433 | ||
434 | ??? A tempting alternative (for both C and C++) would be | |
435 | to force a constant to be written if and only if it is | |
436 | defined in a main file, as opposed to an include file. */ | |
437 | ||
438 | if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)) | |
439 | { | |
098f44bc | 440 | varpool_node *node; |
c131e678 | 441 | bool needed = true; |
97221fd7 | 442 | node = varpool_node::get (decl); |
c131e678 | 443 | |
c087e689 | 444 | if (!node && flag_ltrans) |
c131e678 | 445 | needed = false; |
02774f2d | 446 | else if (node && node->definition) |
c087e689 | 447 | needed = false; |
02774f2d | 448 | else if (node && node->alias) |
c131e678 | 449 | needed = false; |
35ee1c66 | 450 | else if (!symtab->global_info_ready |
c131e678 | 451 | && (TREE_USED (decl) |
452 | || TREE_USED (DECL_ASSEMBLER_NAME (decl)))) | |
453 | /* needed */; | |
02774f2d | 454 | else if (node && node->analyzed) |
c131e678 | 455 | /* needed */; |
456 | else if (DECL_COMDAT (decl)) | |
457 | needed = false; | |
458 | else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl) | |
459 | && (optimize || !flag_keep_static_consts | |
460 | || DECL_ARTIFICIAL (decl))) | |
461 | needed = false; | |
462 | ||
463 | if (needed) | |
464 | { | |
465 | rest_of_decl_compilation (decl, 1, 1); | |
466 | return true; | |
467 | } | |
468 | } | |
469 | ||
470 | return false; | |
471 | } | |
472 | ||
a84da62d | 473 | /* Do any final processing required for the declarations in VEC, of |
474 | which there are LEN. We write out inline functions and variables | |
475 | that have been deferred until this point, but which are required. | |
f712a0dc | 476 | Returns nonzero if anything was put out. */ |
89a75961 | 477 | |
c131e678 | 478 | bool |
7237deda | 479 | wrapup_global_declarations (tree *vec, int len) |
a84da62d | 480 | { |
c131e678 | 481 | bool reconsider, output_something = false; |
a84da62d | 482 | int i; |
a84da62d | 483 | |
484 | for (i = 0; i < len; i++) | |
c131e678 | 485 | wrapup_global_declaration_1 (vec[i]); |
a84da62d | 486 | |
487 | /* Now emit any global variables or functions that we have been | |
488 | putting off. We need to loop in case one of the things emitted | |
489 | here references another one which comes earlier in the list. */ | |
490 | do | |
491 | { | |
c131e678 | 492 | reconsider = false; |
a84da62d | 493 | for (i = 0; i < len; i++) |
c131e678 | 494 | reconsider |= wrapup_global_declaration_2 (vec[i]); |
a84da62d | 495 | if (reconsider) |
c131e678 | 496 | output_something = true; |
a84da62d | 497 | } |
498 | while (reconsider); | |
499 | ||
500 | return output_something; | |
501 | } | |
502 | ||
c131e678 | 503 | /* A subroutine of check_global_declarations. Issue appropriate warnings |
504 | for the global declaration DECL. */ | |
505 | ||
506 | void | |
507 | check_global_declaration_1 (tree decl) | |
508 | { | |
509 | /* Warn about any function declared static but not defined. We don't | |
510 | warn about variables, because many programs have static variables | |
511 | that exist only to get some text into the object file. */ | |
512 | if (TREE_CODE (decl) == FUNCTION_DECL | |
513 | && DECL_INITIAL (decl) == 0 | |
514 | && DECL_EXTERNAL (decl) | |
515 | && ! DECL_ARTIFICIAL (decl) | |
516 | && ! TREE_NO_WARNING (decl) | |
517 | && ! TREE_PUBLIC (decl) | |
518 | && (warn_unused_function | |
519 | || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))) | |
520 | { | |
521 | if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))) | |
21ca8540 | 522 | pedwarn (input_location, 0, "%q+F used but never defined", decl); |
c131e678 | 523 | else |
2006d7dc | 524 | warning (OPT_Wunused_function, "%q+F declared %<static%> but never defined", decl); |
c131e678 | 525 | /* This symbol is effectively an "extern" declaration now. */ |
526 | TREE_PUBLIC (decl) = 1; | |
c131e678 | 527 | } |
528 | ||
529 | /* Warn about static fns or vars defined but not used. */ | |
530 | if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL) | |
531 | /* We don't warn about "static const" variables because the | |
532 | "rcs_id" idiom uses that construction. */ | |
533 | || (warn_unused_variable | |
534 | && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl))) | |
535 | && ! DECL_IN_SYSTEM_HEADER (decl) | |
536 | && ! TREE_USED (decl) | |
537 | /* The TREE_USED bit for file-scope decls is kept in the identifier, | |
538 | to handle multiple external decls in different scopes. */ | |
1563f282 | 539 | && ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl))) |
c131e678 | 540 | && ! DECL_EXTERNAL (decl) |
541 | && ! TREE_PUBLIC (decl) | |
542 | /* A volatile variable might be used in some non-obvious way. */ | |
543 | && ! TREE_THIS_VOLATILE (decl) | |
544 | /* Global register variables must be declared to reserve them. */ | |
545 | && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)) | |
546 | /* Otherwise, ask the language. */ | |
547 | && lang_hooks.decls.warn_unused_global (decl)) | |
48e1416a | 548 | warning ((TREE_CODE (decl) == FUNCTION_DECL) |
549 | ? OPT_Wunused_function | |
550 | : OPT_Wunused_variable, | |
2006d7dc | 551 | "%q+D defined but not used", decl); |
c131e678 | 552 | } |
553 | ||
f1f41a6c | 554 | /* Issue appropriate warnings for the global declarations in V (of |
c131e678 | 555 | which there are LEN). */ |
89a75961 | 556 | |
a84da62d | 557 | void |
f1f41a6c | 558 | check_global_declarations (tree *v, int len) |
a84da62d | 559 | { |
a84da62d | 560 | int i; |
561 | ||
562 | for (i = 0; i < len; i++) | |
f1f41a6c | 563 | check_global_declaration_1 (v[i]); |
c131e678 | 564 | } |
a84da62d | 565 | |
c131e678 | 566 | /* Emit debugging information for all global declarations in VEC. */ |
567 | ||
568 | void | |
569 | emit_debug_global_declarations (tree *vec, int len) | |
570 | { | |
571 | int i; | |
572 | ||
573 | /* Avoid confusing the debug information machinery when there are errors. */ | |
852f689e | 574 | if (seen_error ()) |
c131e678 | 575 | return; |
576 | ||
577 | timevar_push (TV_SYMOUT); | |
578 | for (i = 0; i < len; i++) | |
72b4d83e | 579 | debug_hooks->global_decl (vec[i]); |
c131e678 | 580 | timevar_pop (TV_SYMOUT); |
a84da62d | 581 | } |
7291115d | 582 | |
9ceb1c29 | 583 | /* Compile an entire translation unit. Write a file of assembly |
584 | output and various debugging dumps. */ | |
3bcb26d1 | 585 | |
586 | static void | |
7237deda | 587 | compile_file (void) |
3bcb26d1 | 588 | { |
6198e8f6 | 589 | timevar_start (TV_PHASE_PARSING); |
590 | timevar_push (TV_PARSE_GLOBAL); | |
3bcb26d1 | 591 | |
b78207a0 | 592 | /* Call the parser, which parses the entire file (calling |
593 | rest_of_compilation for each function). */ | |
b8ba44e7 | 594 | lang_hooks.parse_file (); |
3bcb26d1 | 595 | |
6198e8f6 | 596 | timevar_pop (TV_PARSE_GLOBAL); |
597 | timevar_stop (TV_PHASE_PARSING); | |
598 | ||
3bcb26d1 | 599 | /* Compilation is now finished except for writing |
600 | what's left of the symbol table output. */ | |
3bcb26d1 | 601 | |
57305941 | 602 | if (flag_syntax_only || flag_wpa) |
cdc9fa3e | 603 | return; |
a7b7430b | 604 | |
dfecde36 | 605 | ggc_protect_identifiers = false; |
606 | ||
cf951b1a | 607 | /* This must also call finalize_compilation_unit. */ |
dc24ddbd | 608 | lang_hooks.decls.final_write_globals (); |
15daca6e | 609 | |
852f689e | 610 | if (seen_error ()) |
161121a9 | 611 | return; |
612 | ||
613 | timevar_start (TV_PHASE_LATE_ASM); | |
15daca6e | 614 | |
b33542ab | 615 | /* Compilation unit is finalized. When producing non-fat LTO object, we are |
616 | basically finished. */ | |
617 | if (in_lto_p || !flag_lto || flag_fat_lto_objects) | |
618 | { | |
b92cccf4 | 619 | /* File-scope initialization for AddressSanitizer. */ |
9e46467d | 620 | if (flag_sanitize & SANITIZE_ADDRESS) |
b92cccf4 | 621 | asan_finish_file (); |
622 | ||
9e46467d | 623 | if (flag_sanitize & SANITIZE_THREAD) |
b077695d | 624 | tsan_finish_file (); |
625 | ||
058a1b7a | 626 | if (flag_check_pointer_bounds) |
627 | chkp_finish_file (); | |
628 | ||
dccabdd1 | 629 | omp_finish_file (); |
630 | ||
b33542ab | 631 | output_shared_constant_pool (); |
632 | output_object_blocks (); | |
ea259bbe | 633 | finish_tm_clone_pairs (); |
f2d0e9f1 | 634 | |
b33542ab | 635 | /* Write out any pending weak symbol declarations. */ |
636 | weak_finish (); | |
df1c8607 | 637 | |
b33542ab | 638 | /* This must be at the end before unwind and debug info. |
639 | Some target ports emit PIC setup thunks here. */ | |
640 | targetm.asm_out.code_end (); | |
5cbd74a3 | 641 | |
b33542ab | 642 | /* Do dbx symbols. */ |
643 | timevar_push (TV_SYMOUT); | |
c140b944 | 644 | |
b33542ab | 645 | #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO |
646 | if (dwarf2out_do_frame ()) | |
647 | dwarf2out_frame_finish (); | |
648 | #endif | |
d757b8c9 | 649 | |
b33542ab | 650 | (*debug_hooks->finish) (main_input_filename); |
651 | timevar_pop (TV_SYMOUT); | |
be6eb971 | 652 | |
b33542ab | 653 | /* Output some stuff at end of file if nec. */ |
3bcb26d1 | 654 | |
b33542ab | 655 | dw2_output_indirect_constants (); |
ad5818ae | 656 | |
b33542ab | 657 | /* Flush any pending external directives. */ |
658 | process_pending_assemble_externals (); | |
659 | } | |
4ffeedd3 | 660 | |
7bfefa9d | 661 | /* Emit LTO marker if LTO info has been previously emitted. This is |
662 | used by collect2 to determine whether an object file contains IL. | |
663 | We used to emit an undefined reference here, but this produces | |
664 | link errors if an object file with IL is stored into a shared | |
665 | library without invoking lto1. */ | |
9f28dc4c | 666 | if (flag_generate_lto || flag_generate_offload) |
51eafa60 | 667 | { |
668 | #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON | |
669 | ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE, | |
670 | "__gnu_lto_v1", | |
671 | (unsigned HOST_WIDE_INT) 1, 8); | |
672 | #elif defined ASM_OUTPUT_ALIGNED_COMMON | |
673 | ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_v1", | |
674 | (unsigned HOST_WIDE_INT) 1, 8); | |
675 | #else | |
676 | ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_v1", | |
677 | (unsigned HOST_WIDE_INT) 1, | |
678 | (unsigned HOST_WIDE_INT) 1); | |
679 | #endif | |
9f28dc4c | 680 | } |
681 | ||
682 | /* Let linker plugin know that this is a slim object and must be LTOed | |
683 | even when user did not ask for it. */ | |
684 | if (flag_generate_lto && !flag_fat_lto_objects) | |
685 | { | |
b33542ab | 686 | #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON |
9f28dc4c | 687 | ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE, "__gnu_lto_slim", |
688 | (unsigned HOST_WIDE_INT) 1, 8); | |
b33542ab | 689 | #elif defined ASM_OUTPUT_ALIGNED_COMMON |
9f28dc4c | 690 | ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_slim", |
691 | (unsigned HOST_WIDE_INT) 1, 8); | |
b33542ab | 692 | #else |
9f28dc4c | 693 | ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_slim", |
694 | (unsigned HOST_WIDE_INT) 1, | |
695 | (unsigned HOST_WIDE_INT) 1); | |
b33542ab | 696 | #endif |
51eafa60 | 697 | } |
7bfefa9d | 698 | |
f006a2e6 | 699 | /* Attach a special .ident directive to the end of the file to identify |
700 | the version of GCC which compiled this code. The format of the .ident | |
701 | string is patterned after the ones produced by native SVR4 compilers. */ | |
f006a2e6 | 702 | if (!flag_no_ident) |
d25dc80e | 703 | { |
704 | const char *pkg_version = "(GNU) "; | |
367b1459 | 705 | char *ident_str; |
d25dc80e | 706 | |
707 | if (strcmp ("(GCC) ", pkgversion_string)) | |
708 | pkg_version = pkgversion_string; | |
367b1459 | 709 | |
710 | ident_str = ACONCAT (("GCC: ", pkg_version, version_string, NULL)); | |
711 | targetm.asm_out.output_ident (ident_str); | |
d25dc80e | 712 | } |
5cf09555 | 713 | |
94bed7c3 | 714 | /* Auto profile finalization. */ |
715 | if (flag_auto_profile) | |
716 | end_auto_profile (); | |
717 | ||
67a2b55a | 718 | /* Invoke registered plugin callbacks. */ |
719 | invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL); | |
48e1416a | 720 | |
5cf09555 | 721 | /* This must be at the end. Some target ports emit end of file directives |
722 | into the assembly file here, and hence we can not output anything to the | |
723 | assembly file after this point. */ | |
724 | targetm.asm_out.file_end (); | |
6198e8f6 | 725 | |
161121a9 | 726 | timevar_stop (TV_PHASE_LATE_ASM); |
3bcb26d1 | 727 | } |
03414cfb | 728 | |
a49a878f | 729 | /* Print version information to FILE. |
730 | Each line begins with INDENT (for the case where FILE is the | |
b86fa9da | 731 | assembler output file). |
732 | ||
733 | If SHOW_GLOBAL_STATE is true (for cc1 etc), we are within the compiler | |
734 | proper and can print pertinent state (e.g. params and plugins). | |
735 | ||
736 | If SHOW_GLOBAL_STATE is false (for use by libgccjit), we are outside the | |
737 | compiler, and we don't hold the mutex on the compiler's global state: | |
738 | we can't print params and plugins, since they might not be initialized, | |
739 | or might be being manipulated by a compile running in another | |
740 | thread. */ | |
9dda7915 | 741 | |
a49a878f | 742 | void |
b86fa9da | 743 | print_version (FILE *file, const char *indent, bool show_global_state) |
9ceb1c29 | 744 | { |
0a81f5a0 | 745 | static const char fmt1[] = |
9ceb1c29 | 746 | #ifdef __GNUC__ |
d25dc80e | 747 | N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ") |
9ceb1c29 | 748 | #else |
d25dc80e | 749 | N_("%s%s%s %sversion %s (%s) compiled by CC, ") |
9ceb1c29 | 750 | #endif |
0a81f5a0 | 751 | ; |
752 | static const char fmt2[] = | |
239d491a | 753 | N_("GMP version %s, MPFR version %s, MPC version %s\n"); |
bd0d5325 | 754 | static const char fmt3[] = |
ceb21d85 | 755 | N_("%s%swarning: %s header version %s differs from library version %s.\n"); |
bd0d5325 | 756 | static const char fmt4[] = |
0a81f5a0 | 757 | N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"); |
758 | #ifndef __VERSION__ | |
759 | #define __VERSION__ "[?]" | |
760 | #endif | |
761 | fprintf (file, | |
762 | file == stderr ? _(fmt1) : fmt1, | |
763 | indent, *indent != 0 ? " " : "", | |
d25dc80e | 764 | lang_hooks.name, pkgversion_string, version_string, TARGET_NAME, |
9ceb1c29 | 765 | indent, __VERSION__); |
bd0d5325 | 766 | |
767 | /* We need to stringify the GMP macro values. Ugh, gmp_version has | |
660b6c15 | 768 | two string formats, "i.j.k" and "i.j" when k is zero. As of |
769 | gmp-4.3.0, GMP always uses the 3 number format. */ | |
bd0d5325 | 770 | #define GCC_GMP_STRINGIFY_VERSION3(X) #X |
9af5ce0c | 771 | #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3 (X) |
660b6c15 | 772 | #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z)) |
773 | #define GCC_GMP_VERSION \ | |
774 | GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL) | |
775 | #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0 | |
9af5ce0c | 776 | #define GCC_GMP_STRINGIFY_VERSION \ |
777 | GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \ | |
778 | GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) | |
bd0d5325 | 779 | #else |
9af5ce0c | 780 | #define GCC_GMP_STRINGIFY_VERSION \ |
781 | GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \ | |
782 | GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) "." \ | |
783 | GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_PATCHLEVEL) | |
bd0d5325 | 784 | #endif |
0a81f5a0 | 785 | fprintf (file, |
786 | file == stderr ? _(fmt2) : fmt2, | |
965d0f29 | 787 | GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING); |
bd0d5325 | 788 | if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version)) |
789 | fprintf (file, | |
790 | file == stderr ? _(fmt3) : fmt3, | |
ceb21d85 | 791 | indent, *indent != 0 ? " " : "", |
bd0d5325 | 792 | "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version); |
793 | if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ())) | |
794 | fprintf (file, | |
795 | file == stderr ? _(fmt3) : fmt3, | |
ceb21d85 | 796 | indent, *indent != 0 ? " " : "", |
bd0d5325 | 797 | "MPFR", MPFR_VERSION_STRING, mpfr_get_version ()); |
239d491a | 798 | if (strcmp (MPC_VERSION_STRING, mpc_get_version ())) |
799 | fprintf (file, | |
800 | file == stderr ? _(fmt3) : fmt3, | |
801 | indent, *indent != 0 ? " " : "", | |
802 | "MPC", MPC_VERSION_STRING, mpc_get_version ()); | |
e16288b4 | 803 | |
b86fa9da | 804 | if (show_global_state) |
805 | { | |
806 | fprintf (file, | |
807 | file == stderr ? _(fmt4) : fmt4, | |
808 | indent, *indent != 0 ? " " : "", | |
809 | PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE)); | |
810 | ||
811 | print_plugins_versions (file, indent); | |
812 | } | |
9ceb1c29 | 813 | } |
814 | ||
7c6733e8 | 815 | static int |
816 | print_to_asm_out_file (print_switch_type type, const char * text) | |
817 | { | |
818 | bool prepend_sep = true; | |
819 | ||
820 | switch (type) | |
821 | { | |
822 | case SWITCH_TYPE_LINE_END: | |
823 | putc ('\n', asm_out_file); | |
824 | return 1; | |
825 | ||
826 | case SWITCH_TYPE_LINE_START: | |
827 | fputs (ASM_COMMENT_START, asm_out_file); | |
828 | return strlen (ASM_COMMENT_START); | |
829 | ||
830 | case SWITCH_TYPE_DESCRIPTIVE: | |
831 | if (ASM_COMMENT_START[0] == 0) | |
832 | prepend_sep = false; | |
833 | /* Drop through. */ | |
834 | case SWITCH_TYPE_PASSED: | |
835 | case SWITCH_TYPE_ENABLED: | |
836 | if (prepend_sep) | |
837 | fputc (' ', asm_out_file); | |
609e7ca1 | 838 | fputs (text, asm_out_file); |
7c6733e8 | 839 | /* No need to return the length here as |
840 | print_single_switch has already done it. */ | |
841 | return 0; | |
842 | ||
843 | default: | |
844 | return -1; | |
845 | } | |
846 | } | |
7c6733e8 | 847 | |
848 | static int | |
849 | print_to_stderr (print_switch_type type, const char * text) | |
850 | { | |
851 | switch (type) | |
852 | { | |
853 | case SWITCH_TYPE_LINE_END: | |
854 | putc ('\n', stderr); | |
855 | return 1; | |
856 | ||
857 | case SWITCH_TYPE_LINE_START: | |
858 | return 0; | |
48e1416a | 859 | |
7c6733e8 | 860 | case SWITCH_TYPE_PASSED: |
861 | case SWITCH_TYPE_ENABLED: | |
862 | fputc (' ', stderr); | |
863 | /* Drop through. */ | |
864 | ||
865 | case SWITCH_TYPE_DESCRIPTIVE: | |
609e7ca1 | 866 | fputs (text, stderr); |
7c6733e8 | 867 | /* No need to return the length here as |
868 | print_single_switch has already done it. */ | |
869 | return 0; | |
870 | ||
871 | default: | |
872 | return -1; | |
873 | } | |
874 | } | |
875 | ||
9ceb1c29 | 876 | /* Print an option value and return the adjusted position in the line. |
7c6733e8 | 877 | ??? print_fn doesn't handle errors, eg disk full; presumably other |
878 | code will catch a disk full though. */ | |
9ceb1c29 | 879 | |
880 | static int | |
7c6733e8 | 881 | print_single_switch (print_switch_fn_type print_fn, |
882 | int pos, | |
883 | print_switch_type type, | |
884 | const char * text) | |
9ceb1c29 | 885 | { |
7c6733e8 | 886 | /* The ultrix fprintf returns 0 on success, so compute the result |
887 | we want here since we need it for the following test. The +1 | |
7920eed5 | 888 | is for the separator character that will probably be emitted. */ |
7c6733e8 | 889 | int len = strlen (text) + 1; |
9ceb1c29 | 890 | |
891 | if (pos != 0 | |
7c6733e8 | 892 | && pos + len > MAX_LINE) |
9ceb1c29 | 893 | { |
7c6733e8 | 894 | print_fn (SWITCH_TYPE_LINE_END, NULL); |
9ceb1c29 | 895 | pos = 0; |
896 | } | |
7c6733e8 | 897 | |
9ceb1c29 | 898 | if (pos == 0) |
7c6733e8 | 899 | pos += print_fn (SWITCH_TYPE_LINE_START, NULL); |
900 | ||
901 | print_fn (type, text); | |
902 | return pos + len; | |
9ceb1c29 | 903 | } |
904 | ||
7c6733e8 | 905 | /* Print active target switches using PRINT_FN. |
9ceb1c29 | 906 | POS is the current cursor position and MAX is the size of a "line". |
907 | Each line begins with INDENT and ends with TERM. | |
908 | Each switch is separated from the next by SEP. */ | |
909 | ||
910 | static void | |
7c6733e8 | 911 | print_switch_values (print_switch_fn_type print_fn) |
9ceb1c29 | 912 | { |
7c6733e8 | 913 | int pos = 0; |
9ceb1c29 | 914 | size_t j; |
9ceb1c29 | 915 | |
eb54bdbd | 916 | /* Fill in the -frandom-seed option, if the user didn't pass it, so |
b80f1d67 | 917 | that it can be printed below. This helps reproducibility. */ |
b6c1bd72 | 918 | if (!flag_random_seed) |
919 | init_random_seed (); | |
eb54bdbd | 920 | |
9ceb1c29 | 921 | /* Print the options as passed. */ |
7c6733e8 | 922 | pos = print_single_switch (print_fn, pos, |
923 | SWITCH_TYPE_DESCRIPTIVE, _("options passed: ")); | |
9ceb1c29 | 924 | |
615ef0bb | 925 | for (j = 1; j < save_decoded_options_count; j++) |
7c6733e8 | 926 | { |
615ef0bb | 927 | switch (save_decoded_options[j].opt_index) |
7c6733e8 | 928 | { |
615ef0bb | 929 | case OPT_o: |
930 | case OPT_d: | |
931 | case OPT_dumpbase: | |
932 | case OPT_dumpdir: | |
933 | case OPT_auxbase: | |
934 | case OPT_quiet: | |
935 | case OPT_version: | |
7c6733e8 | 936 | /* Ignore these. */ |
615ef0bb | 937 | continue; |
7c6733e8 | 938 | } |
939 | ||
615ef0bb | 940 | pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED, |
941 | save_decoded_options[j].orig_option_with_args_text); | |
7c6733e8 | 942 | } |
943 | ||
9ceb1c29 | 944 | if (pos > 0) |
7c6733e8 | 945 | print_fn (SWITCH_TYPE_LINE_END, NULL); |
9ceb1c29 | 946 | |
947 | /* Print the -f and -m options that have been enabled. | |
948 | We don't handle language specific options but printing argv | |
949 | should suffice. */ | |
7c6733e8 | 950 | pos = print_single_switch (print_fn, 0, |
951 | SWITCH_TYPE_DESCRIPTIVE, _("options enabled: ")); | |
9ceb1c29 | 952 | |
2e9da478 | 953 | for (j = 0; j < cl_options_count; j++) |
ec840af4 | 954 | if (cl_options[j].cl_report |
2c5d2e39 | 955 | && option_enabled (j, &global_options) > 0) |
7c6733e8 | 956 | pos = print_single_switch (print_fn, pos, |
957 | SWITCH_TYPE_ENABLED, cl_options[j].opt_text); | |
9ceb1c29 | 958 | |
7c6733e8 | 959 | print_fn (SWITCH_TYPE_LINE_END, NULL); |
9ceb1c29 | 960 | } |
03414cfb | 961 | |
9ceb1c29 | 962 | /* Open assembly code output file. Do this even if -fsyntax-only is |
963 | on, because then the driver will have provided the name of a | |
964 | temporary file or bit bucket for us. NAME is the file specified on | |
965 | the command line, possibly NULL. */ | |
966 | static void | |
7237deda | 967 | init_asm_output (const char *name) |
9ceb1c29 | 968 | { |
969 | if (name == NULL && asm_file_name == 0) | |
970 | asm_out_file = stdout; | |
971 | else | |
972 | { | |
973 | if (asm_file_name == 0) | |
b1157638 | 974 | { |
975 | int len = strlen (dump_base_name); | |
eb59413a | 976 | char *dumpname = XNEWVEC (char, len + 6); |
7c6733e8 | 977 | |
b1157638 | 978 | memcpy (dumpname, dump_base_name, len + 1); |
979 | strip_off_ending (dumpname, len); | |
980 | strcat (dumpname, ".s"); | |
981 | asm_file_name = dumpname; | |
982 | } | |
9ceb1c29 | 983 | if (!strcmp (asm_file_name, "-")) |
b1157638 | 984 | asm_out_file = stdout; |
25dbe4c7 | 985 | else if (!canonical_filename_eq (asm_file_name, name) |
986 | || !strcmp (asm_file_name, HOST_BIT_BUCKET)) | |
1d715999 | 987 | asm_out_file = fopen (asm_file_name, "w"); |
4d0069ee | 988 | else |
c05be867 | 989 | /* Use UNKOWN_LOCATION to prevent gcc from printing the first |
990 | line in the current file. */ | |
4d0069ee | 991 | fatal_error (UNKNOWN_LOCATION, |
992 | "input file %qs is the same as output file", | |
993 | asm_file_name); | |
9ceb1c29 | 994 | if (asm_out_file == 0) |
4d0069ee | 995 | fatal_error (UNKNOWN_LOCATION, |
996 | "can%'t open %qs for writing: %m", asm_file_name); | |
9ceb1c29 | 997 | } |
998 | ||
9ceb1c29 | 999 | if (!flag_syntax_only) |
1000 | { | |
92c473b8 | 1001 | targetm.asm_out.file_start (); |
9ceb1c29 | 1002 | |
7c6733e8 | 1003 | if (flag_record_gcc_switches) |
1004 | { | |
1005 | if (targetm.asm_out.record_gcc_switches) | |
1006 | { | |
1007 | /* Let the target know that we are about to start recording. */ | |
1008 | targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE, | |
1009 | NULL); | |
1010 | /* Now record the switches. */ | |
1011 | print_switch_values (targetm.asm_out.record_gcc_switches); | |
1012 | /* Let the target know that the recording is over. */ | |
1013 | targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE, | |
1014 | NULL); | |
1015 | } | |
1016 | else | |
5bcc316e | 1017 | inform (input_location, "-frecord-gcc-switches is not supported by the current target"); |
7c6733e8 | 1018 | } |
1019 | ||
9ceb1c29 | 1020 | if (flag_verbose_asm) |
1021 | { | |
7c6733e8 | 1022 | /* Print the list of switches in effect |
1023 | into the assembler file as comments. */ | |
b86fa9da | 1024 | print_version (asm_out_file, ASM_COMMENT_START, true); |
7c6733e8 | 1025 | print_switch_values (print_to_asm_out_file); |
609e7ca1 | 1026 | putc ('\n', asm_out_file); |
9ceb1c29 | 1027 | } |
9ceb1c29 | 1028 | } |
1029 | } | |
03414cfb | 1030 | |
931b0a0f | 1031 | /* A helper function; used as the reallocator function for cpp's line |
1032 | table. */ | |
1033 | static void * | |
1034 | realloc_for_line_map (void *ptr, size_t len) | |
1035 | { | |
881f903e | 1036 | return ggc_realloc (ptr, len); |
931b0a0f | 1037 | } |
1038 | ||
ddcdd2ab | 1039 | /* A helper function: used as the allocator function for |
1040 | identifier_to_locale. */ | |
1041 | static void * | |
1042 | alloc_for_identifier_to_locale (size_t len) | |
1043 | { | |
ba72912a | 1044 | return ggc_alloc_atomic (len); |
ddcdd2ab | 1045 | } |
1046 | ||
990495a7 | 1047 | /* Output stack usage information. */ |
1048 | void | |
1049 | output_stack_usage (void) | |
1050 | { | |
1051 | static bool warning_issued = false; | |
1052 | enum stack_usage_kind_type { STATIC = 0, DYNAMIC, DYNAMIC_BOUNDED }; | |
1053 | const char *stack_usage_kind_str[] = { | |
1054 | "static", | |
1055 | "dynamic", | |
1056 | "dynamic,bounded" | |
1057 | }; | |
1058 | HOST_WIDE_INT stack_usage = current_function_static_stack_size; | |
1059 | enum stack_usage_kind_type stack_usage_kind; | |
990495a7 | 1060 | |
1061 | if (stack_usage < 0) | |
1062 | { | |
1063 | if (!warning_issued) | |
1064 | { | |
8c0dd614 | 1065 | warning (0, "stack usage computation not supported for this target"); |
990495a7 | 1066 | warning_issued = true; |
1067 | } | |
1068 | return; | |
1069 | } | |
1070 | ||
1071 | stack_usage_kind = STATIC; | |
1072 | ||
1073 | /* Add the maximum amount of space pushed onto the stack. */ | |
1074 | if (current_function_pushed_stack_size > 0) | |
1075 | { | |
1076 | stack_usage += current_function_pushed_stack_size; | |
1077 | stack_usage_kind = DYNAMIC_BOUNDED; | |
1078 | } | |
1079 | ||
1080 | /* Now on to the tricky part: dynamic stack allocation. */ | |
1081 | if (current_function_allocates_dynamic_stack_space) | |
1082 | { | |
1083 | if (current_function_has_unbounded_dynamic_stack_size) | |
1084 | stack_usage_kind = DYNAMIC; | |
1085 | else | |
1086 | stack_usage_kind = DYNAMIC_BOUNDED; | |
1087 | ||
1088 | /* Add the size even in the unbounded case, this can't hurt. */ | |
1089 | stack_usage += current_function_dynamic_stack_size; | |
1090 | } | |
1091 | ||
8c0dd614 | 1092 | if (flag_stack_usage) |
1093 | { | |
1094 | expanded_location loc | |
1095 | = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); | |
8d6cadac | 1096 | /* We don't want to print the full qualified name because it can be long, |
1097 | so we strip the scope prefix, but we may need to deal with the suffix | |
1098 | created by the compiler. */ | |
1099 | const char *suffix | |
1100 | = strchr (IDENTIFIER_POINTER (DECL_NAME (current_function_decl)), '.'); | |
1101 | const char *name | |
1102 | = lang_hooks.decl_printable_name (current_function_decl, 2); | |
1103 | if (suffix) | |
1104 | { | |
1105 | const char *dot = strchr (name, '.'); | |
1106 | while (dot && strcasecmp (dot, suffix) != 0) | |
1107 | { | |
1108 | name = dot + 1; | |
1109 | dot = strchr (name, '.'); | |
1110 | } | |
1111 | } | |
8c0dd614 | 1112 | else |
8d6cadac | 1113 | { |
1114 | const char *dot = strrchr (name, '.'); | |
1115 | if (dot) | |
1116 | name = dot + 1; | |
1117 | } | |
8c0dd614 | 1118 | |
1119 | fprintf (stack_usage_file, | |
1120 | "%s:%d:%d:%s\t"HOST_WIDE_INT_PRINT_DEC"\t%s\n", | |
1121 | lbasename (loc.file), | |
1122 | loc.line, | |
1123 | loc.column, | |
8d6cadac | 1124 | name, |
8c0dd614 | 1125 | stack_usage, |
1126 | stack_usage_kind_str[stack_usage_kind]); | |
1127 | } | |
990495a7 | 1128 | |
8c0dd614 | 1129 | if (warn_stack_usage >= 0) |
1130 | { | |
9025d8f0 | 1131 | const location_t loc = DECL_SOURCE_LOCATION (current_function_decl); |
1132 | ||
8c0dd614 | 1133 | if (stack_usage_kind == DYNAMIC) |
9025d8f0 | 1134 | warning_at (loc, OPT_Wstack_usage_, "stack usage might be unbounded"); |
8c0dd614 | 1135 | else if (stack_usage > warn_stack_usage) |
1136 | { | |
1137 | if (stack_usage_kind == DYNAMIC_BOUNDED) | |
9025d8f0 | 1138 | warning_at (loc, |
1139 | OPT_Wstack_usage_, "stack usage might be %wd bytes", | |
1140 | stack_usage); | |
8c0dd614 | 1141 | else |
9025d8f0 | 1142 | warning_at (loc, OPT_Wstack_usage_, "stack usage is %wd bytes", |
1143 | stack_usage); | |
8c0dd614 | 1144 | } |
1145 | } | |
990495a7 | 1146 | } |
1147 | ||
1148 | /* Open an auxiliary output file. */ | |
1149 | static FILE * | |
1150 | open_auxiliary_file (const char *ext) | |
1151 | { | |
1152 | char *filename; | |
1153 | FILE *file; | |
1154 | ||
1155 | filename = concat (aux_base_name, ".", ext, NULL); | |
1156 | file = fopen (filename, "w"); | |
1157 | if (!file) | |
c05be867 | 1158 | fatal_error (input_location, "can%'t open %s for writing: %m", filename); |
990495a7 | 1159 | free (filename); |
1160 | return file; | |
1161 | } | |
1162 | ||
9ceb1c29 | 1163 | /* Initialization of the front end environment, before command line |
1164 | options are parsed. Signal handlers, internationalization etc. | |
1165 | ARGV0 is main's argv[0]. */ | |
1166 | static void | |
4d31ecc4 | 1167 | general_init (const char *argv0, bool init_signals) |
9ceb1c29 | 1168 | { |
4838a8b6 | 1169 | const char *p; |
9ceb1c29 | 1170 | |
1171 | p = argv0 + strlen (argv0); | |
1172 | while (p != argv0 && !IS_DIR_SEPARATOR (p[-1])) | |
1173 | --p; | |
1174 | progname = p; | |
1175 | ||
1176 | xmalloc_set_program_name (progname); | |
6deeea15 | 1177 | |
77e1a5df | 1178 | hex_init (); |
1179 | ||
4367c81f | 1180 | /* Unlock the stdio streams. */ |
9c8f076b | 1181 | unlock_std_streams (); |
4367c81f | 1182 | |
eb718689 | 1183 | gcc_init_libintl (); |
be2828ce | 1184 | |
ddcdd2ab | 1185 | identifier_to_locale_alloc = alloc_for_identifier_to_locale; |
1186 | identifier_to_locale_free = ggc_free; | |
1187 | ||
aa6db498 | 1188 | /* Initialize the diagnostics reporting machinery, so option parsing |
1189 | can give warnings and errors. */ | |
3c6a9715 | 1190 | diagnostic_initialize (global_dc, N_OPTS); |
aa6db498 | 1191 | /* Set a default printer. Language specific initializations will |
1192 | override it later. */ | |
c224fa34 | 1193 | tree_diagnostics_defaults (global_dc); |
c224fa34 | 1194 | |
5a983084 | 1195 | global_dc->show_caret |
1196 | = global_options_init.x_flag_diagnostics_show_caret; | |
f3f006ad | 1197 | global_dc->show_option_requested |
1198 | = global_options_init.x_flag_diagnostics_show_option; | |
1199 | global_dc->show_column | |
1200 | = global_options_init.x_flag_show_column; | |
1f63d337 | 1201 | global_dc->internal_error = plugins_internal_error_function; |
3c6a9715 | 1202 | global_dc->option_enabled = option_enabled; |
2c5d2e39 | 1203 | global_dc->option_state = &global_options; |
3c6a9715 | 1204 | global_dc->option_name = option_name; |
aa6db498 | 1205 | |
4d31ecc4 | 1206 | if (init_signals) |
1207 | { | |
1208 | /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */ | |
b9b90cce | 1209 | #ifdef SIGSEGV |
4d31ecc4 | 1210 | signal (SIGSEGV, crash_signal); |
004cf1e3 | 1211 | #endif |
b9b90cce | 1212 | #ifdef SIGILL |
4d31ecc4 | 1213 | signal (SIGILL, crash_signal); |
b9b90cce | 1214 | #endif |
1215 | #ifdef SIGBUS | |
4d31ecc4 | 1216 | signal (SIGBUS, crash_signal); |
b9b90cce | 1217 | #endif |
1218 | #ifdef SIGABRT | |
4d31ecc4 | 1219 | signal (SIGABRT, crash_signal); |
b9b90cce | 1220 | #endif |
1221 | #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT) | |
4d31ecc4 | 1222 | signal (SIGIOT, crash_signal); |
b9b90cce | 1223 | #endif |
536f5fb1 | 1224 | #ifdef SIGFPE |
4d31ecc4 | 1225 | signal (SIGFPE, crash_signal); |
536f5fb1 | 1226 | #endif |
89a75961 | 1227 | |
4d31ecc4 | 1228 | /* Other host-specific signal setup. */ |
1229 | (*host_hooks.extra_signals)(); | |
1230 | } | |
b197fbcf | 1231 | |
5934ea7a | 1232 | /* Initialize the garbage-collector, string pools and tree type hash |
1233 | table. */ | |
1234 | init_ggc (); | |
1235 | init_stringpool (); | |
415309e2 | 1236 | input_location = UNKNOWN_LOCATION; |
25a27413 | 1237 | line_table = ggc_alloc<line_maps> (); |
a4cfdfed | 1238 | linemap_init (line_table, BUILTINS_LOCATION); |
931b0a0f | 1239 | line_table->reallocator = realloc_for_line_map; |
1ae3520e | 1240 | line_table->round_alloc_size = ggc_round_alloc_size; |
5934ea7a | 1241 | init_ttree (); |
262444a6 | 1242 | |
9ceb1c29 | 1243 | /* Initialize register usage now so switches may override. */ |
1244 | init_reg_sets (); | |
990339dd | 1245 | |
9a33a2e8 | 1246 | /* Register the language-independent parameters. */ |
6a2fc14e | 1247 | global_init_params (); |
9a33a2e8 | 1248 | |
6a2fc14e | 1249 | /* This must be done after global_init_params but before argument |
1250 | processing. */ | |
9af5ce0c | 1251 | init_ggc_heuristics (); |
8d0badf1 | 1252 | |
3ea50c01 | 1253 | /* Create the singleton holder for global state. |
1254 | Doing so also creates the pass manager and with it the passes. */ | |
9af5ce0c | 1255 | g = new gcc::context (); |
a5d83f7d | 1256 | symtab = new (ggc_cleared_alloc <symbol_table> ()) symbol_table (); |
8d0badf1 | 1257 | |
9659d177 | 1258 | statistics_early_init (); |
56f280c4 | 1259 | finish_params (); |
5764e93a | 1260 | } |
03414cfb | 1261 | |
f2d0e9f1 | 1262 | /* Return true if the current target supports -fsection-anchors. */ |
1263 | ||
1264 | static bool | |
1265 | target_supports_section_anchors_p (void) | |
1266 | { | |
1267 | if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0) | |
1268 | return false; | |
1269 | ||
1270 | if (targetm.asm_out.output_anchor == NULL) | |
1271 | return false; | |
1272 | ||
1273 | return true; | |
1274 | } | |
1275 | ||
6d8b68a3 | 1276 | /* Default the align_* variables to 1 if they're still unset, and |
1277 | set up the align_*_log variables. */ | |
1278 | static void | |
1279 | init_alignments (void) | |
1280 | { | |
1281 | if (align_loops <= 0) | |
1282 | align_loops = 1; | |
1283 | if (align_loops_max_skip > align_loops) | |
1284 | align_loops_max_skip = align_loops - 1; | |
1285 | align_loops_log = floor_log2 (align_loops * 2 - 1); | |
1286 | if (align_jumps <= 0) | |
1287 | align_jumps = 1; | |
1288 | if (align_jumps_max_skip > align_jumps) | |
1289 | align_jumps_max_skip = align_jumps - 1; | |
1290 | align_jumps_log = floor_log2 (align_jumps * 2 - 1); | |
1291 | if (align_labels <= 0) | |
1292 | align_labels = 1; | |
1293 | align_labels_log = floor_log2 (align_labels * 2 - 1); | |
1294 | if (align_labels_max_skip > align_labels) | |
1295 | align_labels_max_skip = align_labels - 1; | |
1296 | if (align_functions <= 0) | |
1297 | align_functions = 1; | |
1298 | align_functions_log = floor_log2 (align_functions * 2 - 1); | |
1299 | } | |
1300 | ||
5764e93a | 1301 | /* Process the options that have been parsed. */ |
1302 | static void | |
7237deda | 1303 | process_options (void) |
5764e93a | 1304 | { |
0c5e3a3d | 1305 | /* Just in case lang_hooks.post_options ends up calling a debug_hook. |
1306 | This can happen with incorrect pre-processed input. */ | |
1307 | debug_hooks = &do_nothing_debug_hooks; | |
1308 | ||
9faf44d6 | 1309 | maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT; |
1310 | ||
03bde601 | 1311 | /* Allow the front end to perform consistency checks and do further |
1312 | initialization based on the command line options. This hook also | |
1313 | sets the original filename if appropriate (e.g. foo.i -> foo.c) | |
1314 | so we can correctly initialize debug output. */ | |
dc24ddbd | 1315 | no_backend = lang_hooks.post_options (&main_input_filename); |
03bde601 | 1316 | |
67622758 | 1317 | /* Set default values for parameters relation to the Scalar Reduction |
1318 | of Aggregates passes (SRA and IP-SRA). We must do this here, rather | |
1319 | than in opts.c:default_options_optimization as historically these | |
1320 | tuning heuristics have been based on MOVE_RATIO, which on some | |
1321 | targets requires other symbols from the backend. */ | |
1322 | maybe_set_param_value | |
1323 | (PARAM_SRA_MAX_SCALARIZATION_SIZE_SPEED, | |
1324 | get_move_ratio (true) * UNITS_PER_WORD, | |
1325 | global_options.x_param_values, global_options_set.x_param_values); | |
1326 | maybe_set_param_value | |
1327 | (PARAM_SRA_MAX_SCALARIZATION_SIZE_SIZE, | |
1328 | get_move_ratio (false) * UNITS_PER_WORD, | |
1329 | global_options.x_param_values, global_options_set.x_param_values); | |
1330 | ||
3bcb26d1 | 1331 | /* Some machines may reject certain combinations of options. */ |
cc5d3821 | 1332 | targetm.target_option.override (); |
3bcb26d1 | 1333 | |
16b4d5bb | 1334 | /* Avoid any informative notes in the second run of -fcompare-debug. */ |
1335 | if (flag_compare_debug) | |
1336 | diagnostic_inhibit_notes (global_dc); | |
1337 | ||
f2d0e9f1 | 1338 | if (flag_section_anchors && !target_supports_section_anchors_p ()) |
1339 | { | |
1340 | warning (OPT_fsection_anchors, | |
1341 | "this target does not support %qs", "-fsection-anchors"); | |
1342 | flag_section_anchors = 0; | |
1343 | } | |
1344 | ||
5bf3fee3 | 1345 | if (flag_short_enums == 2) |
1346 | flag_short_enums = targetm.default_short_enums (); | |
1347 | ||
a766fb27 | 1348 | /* Set aux_base_name if not already set. */ |
1349 | if (aux_base_name) | |
1350 | ; | |
3272db82 | 1351 | else if (main_input_filename) |
a766fb27 | 1352 | { |
3272db82 | 1353 | char *name = xstrdup (lbasename (main_input_filename)); |
7237deda | 1354 | |
a766fb27 | 1355 | strip_off_ending (name, strlen (name)); |
1356 | aux_base_name = name; | |
1357 | } | |
1358 | else | |
1359 | aux_base_name = "gccaux"; | |
1360 | ||
429cca51 | 1361 | #ifndef HAVE_isl |
abb60a19 | 1362 | if (flag_graphite |
63c5b29f | 1363 | || flag_graphite_identity |
abb60a19 | 1364 | || flag_loop_block |
1365 | || flag_loop_interchange | |
f4c4e2a2 | 1366 | || flag_loop_strip_mine |
120092dd | 1367 | || flag_loop_parallelize_all |
1368 | || flag_loop_unroll_jam) | |
429cca51 | 1369 | sorry ("Graphite loop optimizations cannot be used (ISL is not available)" |
1370 | "(-fgraphite, -fgraphite-identity, -floop-block, " | |
63c5b29f | 1371 | "-floop-interchange, -floop-strip-mine, -floop-parallelize-all, " |
120092dd | 1372 | "-floop-unroll-and-jam, and -ftree-loop-linear)"); |
abb60a19 | 1373 | #endif |
1374 | ||
058a1b7a | 1375 | if (flag_check_pointer_bounds) |
1376 | { | |
1377 | if (targetm.chkp_bound_mode () == VOIDmode) | |
1378 | error ("-fcheck-pointer-bounds is not supported for this target"); | |
1379 | } | |
1380 | ||
0cb057cb | 1381 | /* One region RA really helps to decrease the code size. */ |
1382 | if (flag_ira_region == IRA_REGION_AUTODETECT) | |
1383 | flag_ira_region | |
1384 | = optimize_size || !optimize ? IRA_REGION_ONE : IRA_REGION_MIXED; | |
1385 | ||
f591db9a | 1386 | if (!abi_version_at_least (2)) |
941a2396 | 1387 | { |
f591db9a | 1388 | /* -fabi-version=1 support was removed after GCC 4.9. */ |
1389 | error ("%<-fabi-version=1%> is no longer supported"); | |
1390 | flag_abi_version = 2; | |
941a2396 | 1391 | } |
1392 | ||
3bcb26d1 | 1393 | /* Unrolling all loops implies that standard loop unrolling must also |
1394 | be done. */ | |
1395 | if (flag_unroll_all_loops) | |
1396 | flag_unroll_loops = 1; | |
ce32fe65 | 1397 | |
c17f64cc | 1398 | /* web and rename-registers help when run after loop unrolling. */ |
472cd78a | 1399 | if (flag_web == AUTODETECT_VALUE) |
1400 | flag_web = flag_unroll_loops || flag_peel_loops; | |
a64054c0 | 1401 | |
472cd78a | 1402 | if (flag_rename_registers == AUTODETECT_VALUE) |
1403 | flag_rename_registers = flag_unroll_loops || flag_peel_loops; | |
3bcb26d1 | 1404 | |
9645fa4f | 1405 | if (flag_non_call_exceptions) |
1406 | flag_asynchronous_unwind_tables = 1; | |
1407 | if (flag_asynchronous_unwind_tables) | |
1408 | flag_unwind_tables = 1; | |
1409 | ||
1c6a7b8c | 1410 | if (flag_value_profile_transformations) |
1411 | flag_profile_values = 1; | |
1412 | ||
3bcb26d1 | 1413 | /* Warn about options that are not supported on this machine. */ |
1414 | #ifndef INSN_SCHEDULING | |
1415 | if (flag_schedule_insns || flag_schedule_insns_after_reload) | |
c3ceba8e | 1416 | warning (0, "instruction scheduling not supported on this target machine"); |
3bcb26d1 | 1417 | #endif |
1418 | #ifndef DELAY_SLOTS | |
1419 | if (flag_delayed_branch) | |
c3ceba8e | 1420 | warning (0, "this target machine does not have delayed branches"); |
3bcb26d1 | 1421 | #endif |
1422 | ||
95c4b02a | 1423 | user_label_prefix = USER_LABEL_PREFIX; |
1424 | if (flag_leading_underscore != -1) | |
1425 | { | |
89a75961 | 1426 | /* If the default prefix is more complicated than "" or "_", |
95c4b02a | 1427 | issue a warning and ignore this option. */ |
1428 | if (user_label_prefix[0] == 0 || | |
1429 | (user_label_prefix[0] == '_' && user_label_prefix[1] == 0)) | |
1430 | { | |
1431 | user_label_prefix = flag_leading_underscore ? "_" : ""; | |
1432 | } | |
1433 | else | |
c3ceba8e | 1434 | warning (0, "-f%sleading-underscore not supported on this target machine", |
95c4b02a | 1435 | flag_leading_underscore ? "" : "no-"); |
1436 | } | |
1437 | ||
3bcb26d1 | 1438 | /* If we are in verbose mode, write out the version and maybe all the |
1439 | option flags in use. */ | |
1440 | if (version_flag) | |
1441 | { | |
b86fa9da | 1442 | print_version (stderr, "", true); |
3bcb26d1 | 1443 | if (! quiet_flag) |
7c6733e8 | 1444 | print_switch_values (print_to_stderr); |
3bcb26d1 | 1445 | } |
1446 | ||
9ceb1c29 | 1447 | if (flag_syntax_only) |
1448 | { | |
1449 | write_symbols = NO_DEBUG; | |
1450 | profile_flag = 0; | |
9ceb1c29 | 1451 | } |
3bcb26d1 | 1452 | |
71278019 | 1453 | if (flag_gtoggle) |
1454 | { | |
1455 | if (debug_info_level == DINFO_LEVEL_NONE) | |
bb6e20de | 1456 | { |
1457 | debug_info_level = DINFO_LEVEL_NORMAL; | |
1458 | ||
1459 | if (write_symbols == NO_DEBUG) | |
1460 | write_symbols = PREFERRED_DEBUGGING_TYPE; | |
1461 | } | |
71278019 | 1462 | else |
1463 | debug_info_level = DINFO_LEVEL_NONE; | |
1464 | } | |
1465 | ||
9845d120 | 1466 | if (flag_dump_final_insns && !flag_syntax_only && !no_backend) |
71278019 | 1467 | { |
1468 | FILE *final_output = fopen (flag_dump_final_insns, "w"); | |
1469 | if (!final_output) | |
1470 | { | |
8fb69344 | 1471 | error ("could not open final insn dump file %qs: %m", |
1472 | flag_dump_final_insns); | |
71278019 | 1473 | flag_dump_final_insns = NULL; |
1474 | } | |
1475 | else if (fclose (final_output)) | |
1476 | { | |
8fb69344 | 1477 | error ("could not close zeroed insn dump file %qs: %m", |
1478 | flag_dump_final_insns); | |
71278019 | 1479 | flag_dump_final_insns = NULL; |
1480 | } | |
1481 | } | |
1482 | ||
b0e56fb1 | 1483 | /* A lot of code assumes write_symbols == NO_DEBUG if the debugging |
1484 | level is 0. */ | |
1485 | if (debug_info_level == DINFO_LEVEL_NONE) | |
1486 | write_symbols = NO_DEBUG; | |
1487 | ||
b0e56fb1 | 1488 | if (write_symbols == NO_DEBUG) |
8b7af0c0 | 1489 | ; |
9ceb1c29 | 1490 | #if defined(DBX_DEBUGGING_INFO) |
b0e56fb1 | 1491 | else if (write_symbols == DBX_DEBUG) |
9ceb1c29 | 1492 | debug_hooks = &dbx_debug_hooks; |
3bcb26d1 | 1493 | #endif |
9ceb1c29 | 1494 | #if defined(XCOFF_DEBUGGING_INFO) |
b0e56fb1 | 1495 | else if (write_symbols == XCOFF_DEBUG) |
9ceb1c29 | 1496 | debug_hooks = &xcoff_debug_hooks; |
e87e2aa9 | 1497 | #endif |
9ceb1c29 | 1498 | #ifdef SDB_DEBUGGING_INFO |
b0e56fb1 | 1499 | else if (write_symbols == SDB_DEBUG) |
9ceb1c29 | 1500 | debug_hooks = &sdb_debug_hooks; |
1501 | #endif | |
9ceb1c29 | 1502 | #ifdef DWARF2_DEBUGGING_INFO |
b0e56fb1 | 1503 | else if (write_symbols == DWARF2_DEBUG) |
9ceb1c29 | 1504 | debug_hooks = &dwarf2_debug_hooks; |
e87e2aa9 | 1505 | #endif |
8d60d2bc | 1506 | #ifdef VMS_DEBUGGING_INFO |
b0e56fb1 | 1507 | else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG) |
8d60d2bc | 1508 | debug_hooks = &vmsdbg_debug_hooks; |
1509 | #endif | |
b0e56fb1 | 1510 | else |
2bef00f6 | 1511 | error ("target system does not support the %qs debug format", |
b0e56fb1 | 1512 | debug_type_names[write_symbols]); |
3bcb26d1 | 1513 | |
a64054c0 | 1514 | /* We know which debug output will be used so we can set flag_var_tracking |
1515 | and flag_var_tracking_uninit if the user has not specified them. */ | |
ad469377 | 1516 | if (debug_info_level < DINFO_LEVEL_NORMAL |
1517 | || debug_hooks->var_location == do_nothing_debug_hooks.var_location) | |
5923a5e7 | 1518 | { |
d53bb226 | 1519 | if (flag_var_tracking == 1 |
1520 | || flag_var_tracking_uninit == 1) | |
ad469377 | 1521 | { |
1522 | if (debug_info_level < DINFO_LEVEL_NORMAL) | |
c3ceba8e | 1523 | warning (0, "variable tracking requested, but useless unless " |
ad469377 | 1524 | "producing debug info"); |
1525 | else | |
c3ceba8e | 1526 | warning (0, "variable tracking requested, but not supported " |
ad469377 | 1527 | "by this debug format"); |
1528 | } | |
1529 | flag_var_tracking = 0; | |
d53bb226 | 1530 | flag_var_tracking_uninit = 0; |
5923a5e7 | 1531 | } |
1532 | ||
929d2a90 | 1533 | /* The debug hooks are used to implement -fdump-go-spec because it |
1534 | gives a simple and stable API for all the information we need to | |
1535 | dump. */ | |
1536 | if (flag_dump_go_spec != NULL) | |
1537 | debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks); | |
1538 | ||
8f7630da | 1539 | /* If the user specifically requested variable tracking with tagging |
1540 | uninitialized variables, we need to turn on variable tracking. | |
1541 | (We already determined above that variable tracking is feasible.) */ | |
3e1cce93 | 1542 | if (flag_var_tracking_uninit == 1) |
8f7630da | 1543 | flag_var_tracking = 1; |
ad469377 | 1544 | |
472cd78a | 1545 | if (flag_var_tracking == AUTODETECT_VALUE) |
ad469377 | 1546 | flag_var_tracking = optimize >= 1; |
1547 | ||
3e1cce93 | 1548 | if (flag_var_tracking_uninit == AUTODETECT_VALUE) |
1549 | flag_var_tracking_uninit = flag_var_tracking; | |
1550 | ||
9845d120 | 1551 | if (flag_var_tracking_assignments == AUTODETECT_VALUE) |
8f7630da | 1552 | flag_var_tracking_assignments = flag_var_tracking |
1553 | && !(flag_selective_scheduling || flag_selective_scheduling2); | |
9845d120 | 1554 | |
1555 | if (flag_var_tracking_assignments_toggle) | |
1556 | flag_var_tracking_assignments = !flag_var_tracking_assignments; | |
1557 | ||
1558 | if (flag_var_tracking_assignments && !flag_var_tracking) | |
1559 | flag_var_tracking = flag_var_tracking_assignments = -1; | |
1560 | ||
8f7630da | 1561 | if (flag_var_tracking_assignments |
1562 | && (flag_selective_scheduling || flag_selective_scheduling2)) | |
1563 | warning (0, "var-tracking-assignments changes selective scheduling"); | |
1564 | ||
e6d0e152 | 1565 | if (flag_tree_cselim == AUTODETECT_VALUE) |
1566 | #ifdef HAVE_conditional_move | |
1567 | flag_tree_cselim = 1; | |
1568 | #else | |
1569 | flag_tree_cselim = 0; | |
1570 | #endif | |
1571 | ||
9ceb1c29 | 1572 | /* If auxiliary info generation is desired, open the output file. |
1573 | This goes in the same directory as the source file--unlike | |
1574 | all the other output files. */ | |
1575 | if (flag_gen_aux_info) | |
1576 | { | |
1577 | aux_info_file = fopen (aux_info_file_name, "w"); | |
1578 | if (aux_info_file == 0) | |
c05be867 | 1579 | fatal_error (input_location, "can%'t open %s: %m", aux_info_file_name); |
9ceb1c29 | 1580 | } |
56a44361 | 1581 | |
218e3e4e | 1582 | if (!targetm_common.have_named_sections) |
3bcb26d1 | 1583 | { |
9ceb1c29 | 1584 | if (flag_function_sections) |
1585 | { | |
c3ceba8e | 1586 | warning (0, "-ffunction-sections not supported for this target"); |
9ceb1c29 | 1587 | flag_function_sections = 0; |
1588 | } | |
1589 | if (flag_data_sections) | |
1590 | { | |
c3ceba8e | 1591 | warning (0, "-fdata-sections not supported for this target"); |
9ceb1c29 | 1592 | flag_data_sections = 0; |
1593 | } | |
3bcb26d1 | 1594 | } |
9ceb1c29 | 1595 | |
ba38e12b | 1596 | #ifndef HAVE_prefetch |
cd459e62 | 1597 | if (flag_prefetch_loop_arrays > 0) |
ba38e12b | 1598 | { |
c3ceba8e | 1599 | warning (0, "-fprefetch-loop-arrays not supported for this target"); |
ba38e12b | 1600 | flag_prefetch_loop_arrays = 0; |
1601 | } | |
1602 | #else | |
cd459e62 | 1603 | if (flag_prefetch_loop_arrays > 0 && !HAVE_prefetch) |
ba38e12b | 1604 | { |
c3ceba8e | 1605 | warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)"); |
ba38e12b | 1606 | flag_prefetch_loop_arrays = 0; |
1607 | } | |
1608 | #endif | |
1609 | ||
9544445b | 1610 | /* This combination of options isn't handled for i386 targets and doesn't |
1611 | make much sense anyway, so don't allow it. */ | |
cd459e62 | 1612 | if (flag_prefetch_loop_arrays > 0 && optimize_size) |
9544445b | 1613 | { |
c3ceba8e | 1614 | warning (0, "-fprefetch-loop-arrays is not supported with -Os"); |
9544445b | 1615 | flag_prefetch_loop_arrays = 0; |
1616 | } | |
1617 | ||
4ee9c684 | 1618 | /* The presence of IEEE signaling NaNs, implies all math can trap. */ |
1619 | if (flag_signaling_nans) | |
1620 | flag_trapping_math = 1; | |
45b9d334 | 1621 | |
26c166eb | 1622 | /* We cannot reassociate if we want traps or signed zeros. */ |
4a2a1c11 | 1623 | if (flag_associative_math && (flag_trapping_math || flag_signed_zeros)) |
1624 | { | |
1625 | warning (0, "-fassociative-math disabled; other options take precedence"); | |
1626 | flag_associative_math = 0; | |
1627 | } | |
1628 | ||
45b9d334 | 1629 | /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */ |
1630 | if (flag_cx_limited_range) | |
1631 | flag_complex_method = 0; | |
f1a0edff | 1632 | |
608256a0 | 1633 | /* With -fcx-fortran-rules, we do something in-between cheap and C99. */ |
1634 | if (flag_cx_fortran_rules) | |
1635 | flag_complex_method = 1; | |
1636 | ||
f1a0edff | 1637 | /* Targets must be able to place spill slots at lower addresses. If the |
1638 | target already uses a soft frame pointer, the transition is trivial. */ | |
3837145e | 1639 | if (!FRAME_GROWS_DOWNWARD && flag_stack_protect) |
f1a0edff | 1640 | { |
1641 | warning (0, "-fstack-protector not supported for this target"); | |
1642 | flag_stack_protect = 0; | |
1643 | } | |
f1a0edff | 1644 | if (!flag_stack_protect) |
1645 | warn_stack_protect = 0; | |
77ff57c8 | 1646 | |
7ad5fd20 | 1647 | /* Address Sanitizer needs porting to each target architecture. */ |
3e1dd01e | 1648 | |
9e46467d | 1649 | if ((flag_sanitize & SANITIZE_ADDRESS) |
3e1dd01e | 1650 | && !FRAME_GROWS_DOWNWARD) |
1651 | { | |
1652 | warning (0, | |
1653 | "-fsanitize=address and -fsanitize=kernel-address " | |
1654 | "are not supported for this target"); | |
1655 | flag_sanitize &= ~SANITIZE_ADDRESS; | |
1656 | } | |
1657 | ||
1658 | if ((flag_sanitize & SANITIZE_USER_ADDRESS) | |
1659 | && targetm.asan_shadow_offset == NULL) | |
7ad5fd20 | 1660 | { |
5ab1f49e | 1661 | warning (0, "-fsanitize=address not supported for this target"); |
9e46467d | 1662 | flag_sanitize &= ~SANITIZE_ADDRESS; |
7ad5fd20 | 1663 | } |
1664 | ||
68ebb06f | 1665 | /* Enable -Werror=coverage-mismatch when -Werror and -Wno-error |
1666 | have not been set. */ | |
1667 | if (!global_options_set.x_warnings_are_errors | |
1668 | && warn_coverage_mismatch | |
1669 | && (global_dc->classify_diagnostic[OPT_Wcoverage_mismatch] == | |
1670 | DK_UNSPECIFIED)) | |
1671 | diagnostic_classify_diagnostic (global_dc, OPT_Wcoverage_mismatch, | |
1672 | DK_ERROR, UNKNOWN_LOCATION); | |
1673 | ||
1da23459 | 1674 | /* Save the current optimization options. */ |
55310327 | 1675 | optimization_default_node = build_optimization_node (&global_options); |
1da23459 | 1676 | optimization_current_node = optimization_default_node; |
def3bf8c | 1677 | |
1678 | /* Disable use caller save optimization if profiler is active or port | |
1679 | does not emit prologue and epilogue as RTL. */ | |
1680 | if (profile_flag || !HAVE_prologue || !HAVE_epilogue) | |
1681 | flag_ipa_ra = 0; | |
3bcb26d1 | 1682 | } |
03414cfb | 1683 | |
6d8b68a3 | 1684 | /* This function can be called multiple times to reinitialize the compiler |
1685 | back end when register classes or instruction sets have changed, | |
1686 | before each function. */ | |
1687 | static void | |
1688 | backend_init_target (void) | |
1689 | { | |
1690 | /* Initialize alignment variables. */ | |
1691 | init_alignments (); | |
1692 | ||
6d8b68a3 | 1693 | /* This depends on stack_pointer_rtx. */ |
1694 | init_fake_stack_mems (); | |
1695 | ||
1696 | /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is | |
1697 | mode-dependent. */ | |
1698 | init_alias_target (); | |
1699 | ||
1700 | /* Depends on HARD_FRAME_POINTER_REGNUM. */ | |
1701 | init_reload (); | |
1702 | ||
d2b854bc | 1703 | /* Depends on the enabled attribute. */ |
1704 | recog_init (); | |
1705 | ||
6d8b68a3 | 1706 | /* The following initialization functions need to generate rtl, so |
1707 | provide a dummy function context for them. */ | |
1708 | init_dummy_function_start (); | |
1709 | ||
1710 | /* rtx_cost is mode-dependent, so cached values need to be recomputed | |
1711 | on a mode change. */ | |
1712 | init_expmed (); | |
c7944dce | 1713 | init_lower_subreg (); |
a264508e | 1714 | init_set_costs (); |
1715 | ||
1716 | init_expr_target (); | |
1717 | ira_init (); | |
6d8b68a3 | 1718 | |
1719 | /* We may need to recompute regno_save_code[] and regno_restore_code[] | |
1720 | after a mode change as well. */ | |
4e4c89ec | 1721 | caller_save_initialized_p = false; |
1722 | ||
6d8b68a3 | 1723 | expand_dummy_function_end (); |
1724 | } | |
1725 | ||
1726 | /* Initialize the compiler back end. This function is called only once, | |
1727 | when starting the compiler. */ | |
9ceb1c29 | 1728 | static void |
7237deda | 1729 | backend_init (void) |
9ceb1c29 | 1730 | { |
01703575 | 1731 | init_emit_once (); |
c235b58a | 1732 | |
a87cf6e5 | 1733 | init_rtlanal (); |
bc8bb825 | 1734 | init_inline_once (); |
9ceb1c29 | 1735 | init_varasm_once (); |
7fecc8b3 | 1736 | save_register_info (); |
9ceb1c29 | 1737 | |
e0ff5636 | 1738 | /* Middle end needs this initialization for default mem attributes |
1739 | used by early calls to make_decl_rtl. */ | |
1740 | init_emit_regs (); | |
1741 | ||
1742 | /* Middle end needs this initialization for mode tables used to assign | |
1743 | modes to vector variables. */ | |
1744 | init_regs (); | |
6d8b68a3 | 1745 | } |
1746 | ||
c6418a4e | 1747 | /* Initialize excess precision settings. */ |
1748 | static void | |
1749 | init_excess_precision (void) | |
1750 | { | |
1751 | /* Adjust excess precision handling based on the target options. If | |
1752 | the front end cannot handle it, flag_excess_precision_cmdline | |
1753 | will already have been set accordingly in the post_options | |
1754 | hook. */ | |
1755 | gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT); | |
1756 | flag_excess_precision = flag_excess_precision_cmdline; | |
1757 | if (flag_unsafe_math_optimizations) | |
1758 | flag_excess_precision = EXCESS_PRECISION_FAST; | |
1759 | if (flag_excess_precision == EXCESS_PRECISION_STANDARD) | |
1760 | { | |
1761 | int flt_eval_method = TARGET_FLT_EVAL_METHOD; | |
1762 | switch (flt_eval_method) | |
1763 | { | |
1764 | case -1: | |
1765 | case 0: | |
1766 | /* Either the target acts unpredictably (-1) or has all the | |
1767 | operations required not to have excess precision (0). */ | |
1768 | flag_excess_precision = EXCESS_PRECISION_FAST; | |
1769 | break; | |
1770 | case 1: | |
1771 | case 2: | |
1772 | /* In these cases, predictable excess precision makes | |
1773 | sense. */ | |
1774 | break; | |
1775 | default: | |
1776 | /* Any other implementation-defined FLT_EVAL_METHOD values | |
1777 | require the compiler to handle the associated excess | |
1778 | precision rules in excess_precision_type. */ | |
1779 | gcc_unreachable (); | |
1780 | } | |
1781 | } | |
1782 | } | |
1783 | ||
6d8b68a3 | 1784 | /* Initialize things that are both lang-dependent and target-dependent. |
1785 | This function can be called more than once if target parameters change. */ | |
1786 | static void | |
1787 | lang_dependent_init_target (void) | |
1788 | { | |
c6418a4e | 1789 | /* This determines excess precision settings. */ |
1790 | init_excess_precision (); | |
1791 | ||
6d8b68a3 | 1792 | /* This creates various _DECL nodes, so needs to be called after the |
1793 | front end is initialized. It also depends on the HAVE_xxx macros | |
1794 | generated from the target machine description. */ | |
1795 | init_optabs (); | |
a264508e | 1796 | |
1797 | gcc_assert (!this_target_rtl->target_specific_initialized); | |
e0ff5636 | 1798 | } |
1799 | ||
1800 | /* Perform initializations that are lang-dependent or target-dependent. | |
1801 | but matters only for late optimizations and RTL generation. */ | |
1802 | ||
415309e2 | 1803 | static int rtl_initialized; |
1804 | ||
e0ff5636 | 1805 | void |
1806 | initialize_rtl (void) | |
1807 | { | |
e0ff5636 | 1808 | /* Initialization done just once per compilation, but delayed |
1809 | till code generation. */ | |
415309e2 | 1810 | if (!rtl_initialized) |
e0ff5636 | 1811 | ira_init_once (); |
415309e2 | 1812 | rtl_initialized = true; |
e0ff5636 | 1813 | |
1814 | /* Target specific RTL backend initialization. */ | |
1815 | if (!this_target_rtl->target_specific_initialized) | |
a264508e | 1816 | { |
1817 | backend_init_target (); | |
1818 | this_target_rtl->target_specific_initialized = true; | |
1819 | } | |
9ceb1c29 | 1820 | } |
03414cfb | 1821 | |
f712a0dc | 1822 | /* Language-dependent initialization. Returns nonzero on success. */ |
cdc9fa3e | 1823 | static int |
7237deda | 1824 | lang_dependent_init (const char *name) |
3bcb26d1 | 1825 | { |
fdfe4b3f | 1826 | location_t save_loc = input_location; |
9ceb1c29 | 1827 | if (dump_base_name == 0) |
0f9005dd | 1828 | dump_base_name = name && name[0] ? name : "gccdump"; |
da980a43 | 1829 | |
03bde601 | 1830 | /* Other front-end initialization. */ |
fdfe4b3f | 1831 | input_location = BUILTINS_LOCATION; |
dc24ddbd | 1832 | if (lang_hooks.init () == 0) |
cdc9fa3e | 1833 | return 0; |
fdfe4b3f | 1834 | input_location = save_loc; |
3bcb26d1 | 1835 | |
f463da94 | 1836 | if (!flag_wpa) |
1837 | { | |
1838 | init_asm_output (name); | |
e87e2aa9 | 1839 | |
f463da94 | 1840 | /* If stack usage information is desired, open the output file. */ |
1841 | if (flag_stack_usage) | |
1842 | stack_usage_file = open_auxiliary_file ("su"); | |
1843 | } | |
990495a7 | 1844 | |
6d8b68a3 | 1845 | /* This creates various _DECL nodes, so needs to be called after the |
9ceb1c29 | 1846 | front end is initialized. */ |
1847 | init_eh (); | |
7a9ae52e | 1848 | |
6d8b68a3 | 1849 | /* Do the target-specific parts of the initialization. */ |
1850 | lang_dependent_init_target (); | |
e87e2aa9 | 1851 | |
f463da94 | 1852 | if (!flag_wpa) |
1853 | { | |
1854 | /* If dbx symbol table desired, initialize writing it and output the | |
1855 | predefined types. */ | |
1856 | timevar_push (TV_SYMOUT); | |
3bcb26d1 | 1857 | |
f463da94 | 1858 | /* Now we have the correct original filename, we can initialize |
1859 | debug output. */ | |
1860 | (*debug_hooks->init) (name); | |
3bcb26d1 | 1861 | |
f463da94 | 1862 | timevar_pop (TV_SYMOUT); |
1863 | } | |
cdc9fa3e | 1864 | |
1865 | return 1; | |
1866 | } | |
03414cfb | 1867 | |
6d8b68a3 | 1868 | |
1869 | /* Reinitialize everything when target parameters, such as register usage, | |
1870 | have changed. */ | |
1871 | void | |
1872 | target_reinit (void) | |
1873 | { | |
7b29dd2f | 1874 | struct rtl_data saved_x_rtl; |
1875 | rtx *saved_regno_reg_rtx; | |
2265e215 | 1876 | tree saved_optimization_current_node; |
1877 | struct target_optabs *saved_this_fn_optabs; | |
1878 | ||
1879 | /* Temporarily switch to the default optimization node, so that | |
1880 | *this_target_optabs is set to the default, not reflecting | |
1881 | whatever a previous function used for the optimize | |
1882 | attribute. */ | |
1883 | saved_optimization_current_node = optimization_current_node; | |
1884 | saved_this_fn_optabs = this_fn_optabs; | |
1885 | if (saved_optimization_current_node != optimization_default_node) | |
1886 | { | |
1887 | optimization_current_node = optimization_default_node; | |
1888 | cl_optimization_restore | |
1889 | (&global_options, | |
1890 | TREE_OPTIMIZATION (optimization_default_node)); | |
1891 | } | |
1892 | this_fn_optabs = this_target_optabs; | |
7b29dd2f | 1893 | |
1894 | /* Save *crtl and regno_reg_rtx around the reinitialization | |
1895 | to allow target_reinit being called even after prepare_function_start. */ | |
1896 | saved_regno_reg_rtx = regno_reg_rtx; | |
1897 | if (saved_regno_reg_rtx) | |
1898 | { | |
1899 | saved_x_rtl = *crtl; | |
1900 | memset (crtl, '\0', sizeof (*crtl)); | |
1901 | regno_reg_rtx = NULL; | |
1902 | } | |
1903 | ||
e0ff5636 | 1904 | this_target_rtl->target_specific_initialized = false; |
1905 | ||
1906 | /* This initializes hard_frame_pointer, and calls init_reg_modes_target() | |
1907 | to initialize reg_raw_mode[]. */ | |
1908 | init_emit_regs (); | |
1909 | ||
1910 | /* This invokes target hooks to set fixed_reg[] etc, which is | |
1911 | mode-dependent. */ | |
1912 | init_regs (); | |
6d8b68a3 | 1913 | |
1914 | /* Reinitialize lang-dependent parts. */ | |
1915 | lang_dependent_init_target (); | |
7b29dd2f | 1916 | |
2265e215 | 1917 | /* Restore the original optimization node. */ |
1918 | if (saved_optimization_current_node != optimization_default_node) | |
1919 | { | |
1920 | optimization_current_node = saved_optimization_current_node; | |
1921 | cl_optimization_restore (&global_options, | |
1922 | TREE_OPTIMIZATION (optimization_current_node)); | |
1923 | } | |
1924 | this_fn_optabs = saved_this_fn_optabs; | |
1925 | ||
1926 | /* Restore regno_reg_rtx at the end, as free_after_compilation from | |
7b29dd2f | 1927 | expand_dummy_function_end clears it. */ |
1928 | if (saved_regno_reg_rtx) | |
1929 | { | |
1930 | *crtl = saved_x_rtl; | |
1931 | regno_reg_rtx = saved_regno_reg_rtx; | |
1932 | saved_regno_reg_rtx = NULL; | |
1933 | } | |
6d8b68a3 | 1934 | } |
1935 | ||
51949610 | 1936 | void |
1937 | dump_memory_report (bool final) | |
1938 | { | |
e77b8253 | 1939 | dump_line_table_statistics (); |
51949610 | 1940 | ggc_print_statistics (); |
1941 | stringpool_statistics (); | |
1942 | dump_tree_statistics (); | |
75a70cf9 | 1943 | dump_gimple_statistics (); |
51949610 | 1944 | dump_rtx_statistics (); |
51949610 | 1945 | dump_alloc_pool_statistics (); |
1946 | dump_bitmap_statistics (); | |
eec2888b | 1947 | dump_vec_loc_statistics (); |
51949610 | 1948 | dump_ggc_loc_statistics (final); |
dd277d48 | 1949 | dump_alias_stats (stderr); |
1950 | dump_pta_stats (stderr); | |
51949610 | 1951 | } |
1952 | ||
cdc9fa3e | 1953 | /* Clean up: close opened files, etc. */ |
1954 | ||
1955 | static void | |
f666c964 | 1956 | finalize (bool no_backend) |
cdc9fa3e | 1957 | { |
1958 | /* Close the dump files. */ | |
1959 | if (flag_gen_aux_info) | |
1960 | { | |
1961 | fclose (aux_info_file); | |
852f689e | 1962 | if (seen_error ()) |
cdc9fa3e | 1963 | unlink (aux_info_file_name); |
1964 | } | |
1965 | ||
1966 | /* Close non-debugging input and output files. Take special care to note | |
1967 | whether fclose returns an error, since the pages might still be on the | |
1968 | buffer chain while the file is open. */ | |
1969 | ||
1970 | if (asm_out_file) | |
1971 | { | |
1972 | if (ferror (asm_out_file) != 0) | |
c05be867 | 1973 | fatal_error (input_location, "error writing to %s: %m", asm_file_name); |
cdc9fa3e | 1974 | if (fclose (asm_out_file) != 0) |
c05be867 | 1975 | fatal_error (input_location, "error closing %s: %m", asm_file_name); |
cdc9fa3e | 1976 | } |
1977 | ||
990495a7 | 1978 | if (stack_usage_file) |
1979 | fclose (stack_usage_file); | |
1980 | ||
f666c964 | 1981 | if (!no_backend) |
1982 | { | |
1983 | statistics_fini (); | |
1984 | ||
bcfddb5b | 1985 | g->get_passes ()->finish_optimization_passes (); |
cdc9fa3e | 1986 | |
0c61fbed | 1987 | lra_finish_once (); |
f666c964 | 1988 | } |
47dd2e78 | 1989 | |
cdc9fa3e | 1990 | if (mem_report) |
51949610 | 1991 | dump_memory_report (true); |
cdc9fa3e | 1992 | |
2fc0fcf7 | 1993 | if (profile_report) |
5168ef25 | 1994 | dump_profile_report (); |
1995 | ||
cdc9fa3e | 1996 | /* Language-specific end of compilation actions. */ |
dc24ddbd | 1997 | lang_hooks.finish (); |
9ceb1c29 | 1998 | } |
03414cfb | 1999 | |
9f75f026 | 2000 | static bool |
2001 | standard_type_bitsize (int bitsize) | |
2002 | { | |
2003 | /* As a special exception, we always want __int128 enabled if possible. */ | |
2004 | if (bitsize == 128) | |
2005 | return false; | |
2006 | if (bitsize == CHAR_TYPE_SIZE | |
2007 | || bitsize == SHORT_TYPE_SIZE | |
2008 | || bitsize == INT_TYPE_SIZE | |
2009 | || bitsize == LONG_TYPE_SIZE | |
2010 | || bitsize == LONG_LONG_TYPE_SIZE) | |
2011 | return true; | |
2012 | return false; | |
2013 | } | |
2014 | ||
435fb09b | 2015 | /* Initialize the compiler, and compile the input file. */ |
2016 | static void | |
415309e2 | 2017 | do_compile () |
9ceb1c29 | 2018 | { |
9a35b648 | 2019 | process_options (); |
2020 | ||
2021 | /* Don't do any more if an error has already occurred. */ | |
852f689e | 2022 | if (!seen_error ()) |
9a35b648 | 2023 | { |
9f75f026 | 2024 | int i; |
2025 | ||
6198e8f6 | 2026 | timevar_start (TV_PHASE_SETUP); |
2027 | ||
2b4ca870 | 2028 | /* This must be run always, because it is needed to compute the FP |
2029 | predefined macros, such as __LDBL_MAX__, for targets using non | |
2030 | default FP formats. */ | |
2031 | init_adjust_machine_modes (); | |
8059b95a | 2032 | init_derived_machine_modes (); |
2b4ca870 | 2033 | |
9f75f026 | 2034 | /* This must happen after the backend has a chance to process |
2035 | command line options, but before the parsers are | |
2036 | initialized. */ | |
2037 | for (i = 0; i < NUM_INT_N_ENTS; i ++) | |
2038 | if (targetm.scalar_mode_supported_p (int_n_data[i].m) | |
2039 | && ! standard_type_bitsize (int_n_data[i].bitsize)) | |
2040 | int_n_enabled_p[i] = true; | |
2041 | else | |
2042 | int_n_enabled_p[i] = false; | |
2043 | ||
9a35b648 | 2044 | /* Set up the back-end if requested. */ |
2045 | if (!no_backend) | |
2046 | backend_init (); | |
9ceb1c29 | 2047 | |
9a35b648 | 2048 | /* Language-dependent initialization. Returns true on success. */ |
3272db82 | 2049 | if (lang_dependent_init (main_input_filename)) |
6198e8f6 | 2050 | { |
2051 | /* Initialize yet another pass. */ | |
2052 | ||
2053 | ggc_protect_identifiers = true; | |
2054 | ||
35ee1c66 | 2055 | symtab->initialize (); |
6198e8f6 | 2056 | init_final (main_input_filename); |
2057 | coverage_init (aux_base_name); | |
2058 | statistics_init (); | |
2059 | invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL); | |
2060 | ||
2061 | timevar_stop (TV_PHASE_SETUP); | |
2062 | ||
2063 | compile_file (); | |
2064 | } | |
2065 | else | |
2066 | { | |
2067 | timevar_stop (TV_PHASE_SETUP); | |
2068 | } | |
2069 | ||
2070 | timevar_start (TV_PHASE_FINALIZE); | |
f79b6507 | 2071 | |
f666c964 | 2072 | finalize (no_backend); |
6198e8f6 | 2073 | |
2074 | timevar_stop (TV_PHASE_FINALIZE); | |
9a35b648 | 2075 | } |
415309e2 | 2076 | } |
9ceb1c29 | 2077 | |
4d31ecc4 | 2078 | toplev::toplev (bool use_TV_TOTAL, bool init_signals) |
2079 | : m_use_TV_TOTAL (use_TV_TOTAL), | |
2080 | m_init_signals (init_signals) | |
415309e2 | 2081 | { |
2082 | if (!m_use_TV_TOTAL) | |
2083 | start_timevars (); | |
2084 | } | |
2085 | ||
2086 | toplev::~toplev () | |
2087 | { | |
9ceb1c29 | 2088 | timevar_stop (TV_TOTAL); |
2089 | timevar_print (stderr); | |
435fb09b | 2090 | } |
03414cfb | 2091 | |
415309e2 | 2092 | void |
2093 | toplev::start_timevars () | |
2094 | { | |
2095 | if (time_report || !quiet_flag || flag_detailed_statistics) | |
2096 | timevar_init (); | |
2097 | ||
2098 | timevar_start (TV_TOTAL); | |
2099 | } | |
2100 | ||
435fb09b | 2101 | /* Entry point of cc1, cc1plus, jc1, f771, etc. |
435fb09b | 2102 | Exit code is FATAL_EXIT_CODE if can't open files or if there were |
2103 | any errors, or SUCCESS_EXIT_CODE if compilation succeeded. | |
2104 | ||
2105 | It is not safe to call this function more than once. */ | |
2106 | ||
2107 | int | |
415309e2 | 2108 | toplev::main (int argc, char **argv) |
435fb09b | 2109 | { |
00dacc40 | 2110 | /* Parsing and gimplification sometimes need quite large stack. |
2111 | Increase stack size limits if possible. */ | |
2112 | stack_limit_increase (64 * 1024 * 1024); | |
2113 | ||
46782931 | 2114 | expandargv (&argc, &argv); |
2115 | ||
435fb09b | 2116 | /* Initialization of GCC's environment, and diagnostics. */ |
4d31ecc4 | 2117 | general_init (argv[0], m_init_signals); |
435fb09b | 2118 | |
f3f006ad | 2119 | /* One-off initialization of options that does not need to be |
2120 | repeated when options are added for particular functions. */ | |
2121 | init_options_once (); | |
2122 | ||
2123 | /* Initialize global options structures; this must be repeated for | |
2124 | each structure used for parsing options. */ | |
2125 | init_options_struct (&global_options, &global_options_set); | |
2126 | lang_hooks.init_options_struct (&global_options); | |
2127 | ||
2128 | /* Convert the options to an array. */ | |
2129 | decode_cmdline_options_to_array_default_mask (argc, | |
2130 | CONST_CAST2 (const char **, | |
2131 | char **, argv), | |
2132 | &save_decoded_options, | |
2133 | &save_decoded_options_count); | |
2134 | ||
2135 | /* Perform language-specific options initialization. */ | |
2136 | lang_hooks.init_options (save_decoded_options_count, save_decoded_options); | |
2137 | ||
435fb09b | 2138 | /* Parse the options and do minimal processing; basically just |
2139 | enough to default flags appropriately. */ | |
f3f006ad | 2140 | decode_options (&global_options, &global_options_set, |
6bd9d862 | 2141 | save_decoded_options, save_decoded_options_count, |
3c6c0e40 | 2142 | UNKNOWN_LOCATION, global_dc); |
435fb09b | 2143 | |
f0da0668 | 2144 | handle_common_deferred_options (); |
2145 | ||
b6c1bd72 | 2146 | init_local_tick (); |
b80f1d67 | 2147 | |
e16288b4 | 2148 | initialize_plugins (); |
2149 | ||
2150 | if (version_flag) | |
b86fa9da | 2151 | print_version (stderr, "", true); |
e16288b4 | 2152 | |
2dfeb300 | 2153 | if (help_flag) |
2154 | print_plugins_help (stderr, ""); | |
2155 | ||
435fb09b | 2156 | /* Exit early if we can (e.g. -help). */ |
5934ea7a | 2157 | if (!exit_after_options) |
415309e2 | 2158 | { |
2159 | if (m_use_TV_TOTAL) | |
2160 | start_timevars (); | |
2161 | do_compile (); | |
2162 | } | |
9ceb1c29 | 2163 | |
d9d1b0a4 | 2164 | if (warningcount || errorcount || werrorcount) |
ddb48b82 | 2165 | print_ignored_options (); |
2166 | ||
28cd2e89 | 2167 | /* Invoke registered plugin callbacks if any. Some plugins could |
2168 | emit some diagnostics here. */ | |
9227b6fc | 2169 | invoke_plugin_callbacks (PLUGIN_FINISH, NULL); |
2170 | ||
28cd2e89 | 2171 | diagnostic_finish (global_dc); |
2172 | ||
e16288b4 | 2173 | finalize_plugins (); |
5169661d | 2174 | location_adhoc_data_fini (line_table); |
d9d1b0a4 | 2175 | if (seen_error () || werrorcount) |
9ceb1c29 | 2176 | return (FATAL_EXIT_CODE); |
2177 | ||
2178 | return (SUCCESS_EXIT_CODE); | |
3bcb26d1 | 2179 | } |
415309e2 | 2180 | |
2181 | /* For those that want to, this function aims to clean up enough state that | |
2182 | you can call toplev::main again. */ | |
2183 | void | |
2184 | toplev::finalize (void) | |
2185 | { | |
2186 | rtl_initialized = false; | |
2187 | this_target_rtl->target_specific_initialized = false; | |
2188 | ||
2da26d04 | 2189 | /* Needs to be called before cgraph_c_finalize since it uses symtab. */ |
2190 | ipa_reference_c_finalize (); | |
2191 | ||
415309e2 | 2192 | cgraph_c_finalize (); |
2193 | cgraphunit_c_finalize (); | |
2194 | dwarf2out_c_finalize (); | |
2195 | gcse_c_finalize (); | |
2196 | ipa_cp_c_finalize (); | |
6015ec52 | 2197 | ira_costs_c_finalize (); |
415309e2 | 2198 | params_c_finalize (); |
d7be771e | 2199 | |
2200 | finalize_options_struct (&global_options); | |
2201 | finalize_options_struct (&global_options_set); | |
33c6d8ad | 2202 | |
bfb81ef0 | 2203 | XDELETEVEC (save_decoded_options); |
2204 | ||
33c6d8ad | 2205 | /* Clean up the context (and pass_manager etc). */ |
2206 | delete g; | |
2207 | g = NULL; | |
4cab9b1a | 2208 | |
2209 | obstack_free (&opts_obstack, NULL); | |
415309e2 | 2210 | } |