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