Branch data Line data Source code
1 : : /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 : : Copyright (C) 1987-2025 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
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
8 : : Software Foundation; either version 3, or (at your option) any later
9 : : version.
10 : :
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.
15 : :
16 : : You should have received a copy of the GNU General Public License
17 : : along with GCC; see the file COPYING3. If not see
18 : : <http://www.gnu.org/licenses/>. */
19 : :
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"
26 : : #include "system.h"
27 : : #include "coretypes.h"
28 : : #include "backend.h"
29 : : #include "target.h"
30 : : #include "rtl.h"
31 : : #include "tree.h"
32 : : #include "gimple.h"
33 : : #include "alloc-pool.h"
34 : : #include "timevar.h"
35 : : #include "memmodel.h"
36 : : #include "tm_p.h"
37 : : #include "optabs-libfuncs.h"
38 : : #include "insn-config.h"
39 : : #include "ira.h"
40 : : #include "recog.h"
41 : : #include "cgraph.h"
42 : : #include "coverage.h"
43 : : #include "diagnostic.h"
44 : : #include "pretty-print-urlifier.h"
45 : : #include "varasm.h"
46 : : #include "tree-inline.h"
47 : : #include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version. */
48 : : #include "version.h"
49 : : #include "flags.h"
50 : : #include "insn-attr.h"
51 : : #include "output.h"
52 : : #include "toplev.h"
53 : : #include "expr.h"
54 : : #include "intl.h"
55 : : #include "tree-diagnostic.h"
56 : : #include "reload.h"
57 : : #include "lra.h"
58 : : #include "dwarf2asm.h"
59 : : #include "debug.h"
60 : : #include "common/common-target.h"
61 : : #include "langhooks.h"
62 : : #include "cfgloop.h" /* for init_set_costs */
63 : : #include "hosthooks.h"
64 : : #include "opts.h"
65 : : #include "opts-diagnostic.h"
66 : : #include "stringpool.h"
67 : : #include "attribs.h"
68 : : #include "asan.h"
69 : : #include "tsan.h"
70 : : #include "plugin.h"
71 : : #include "context.h"
72 : : #include "pass_manager.h"
73 : : #include "auto-profile.h"
74 : : #include "dwarf2out.h"
75 : : #include "ipa-reference.h"
76 : : #include "symbol-summary.h"
77 : : #include "tree-vrp.h"
78 : : #include "sreal.h"
79 : : #include "ipa-cp.h"
80 : : #include "ipa-prop.h"
81 : : #include "ipa-utils.h"
82 : : #include "gcse.h"
83 : : #include "omp-offload.h"
84 : : #include "edit-context.h"
85 : : #include "tree-pass.h"
86 : : #include "dumpfile.h"
87 : : #include "ipa-fnsummary.h"
88 : : #include "dump-context.h"
89 : : #include "print-tree.h"
90 : : #include "optinfo-emit-json.h"
91 : : #include "ipa-modref-tree.h"
92 : : #include "ipa-modref.h"
93 : : #include "ipa-param-manipulation.h"
94 : : #include "dbgcnt.h"
95 : : #include "gcc-urlifier.h"
96 : : #include "unique-argv.h"
97 : : #include "make-unique.h"
98 : :
99 : : #include "selftest.h"
100 : :
101 : : #ifdef HAVE_isl
102 : : #include <isl/version.h>
103 : : #endif
104 : :
105 : : static void general_init (const char *, bool, unique_argv original_argv);
106 : : static void backend_init (void);
107 : : static int lang_dependent_init (const char *);
108 : : static void init_asm_output (const char *);
109 : : static void finalize ();
110 : :
111 : : static void crash_signal (int) ATTRIBUTE_NORETURN;
112 : : static void compile_file (void);
113 : :
114 : : /* Decoded options, and number of such options. */
115 : : struct cl_decoded_option *save_decoded_options;
116 : : unsigned int save_decoded_options_count;
117 : :
118 : : /* Vector of saved Optimization decoded command line options. */
119 : : vec<cl_decoded_option> *save_opt_decoded_options;
120 : :
121 : : /* Debug hooks - dependent upon command line options. */
122 : :
123 : : const struct gcc_debug_hooks *debug_hooks;
124 : :
125 : : /* The FUNCTION_DECL for the function currently being compiled,
126 : : or 0 if between functions. */
127 : : tree current_function_decl;
128 : :
129 : : /* Set to the FUNC_BEGIN label of the current function, or NULL
130 : : if none. */
131 : : const char * current_function_func_begin_label;
132 : :
133 : : /* A random sequence of characters, unless overridden by user. */
134 : : static const char *flag_random_seed;
135 : :
136 : : /* A local time stamp derived from the time of compilation. It will be
137 : : zero if the system cannot provide a time. It will be -1u, if the
138 : : user has specified a particular random seed. */
139 : : unsigned local_tick;
140 : :
141 : : /* Random number for this compilation */
142 : : HOST_WIDE_INT random_seed;
143 : :
144 : : /* -f flags. */
145 : :
146 : : /* When non-NULL, indicates that whenever space is allocated on the
147 : : stack, the resulting stack pointer must not pass this
148 : : address---that is, for stacks that grow downward, the stack pointer
149 : : must always be greater than or equal to this address; for stacks
150 : : that grow upward, the stack pointer must be less than this address.
151 : : At present, the rtx may be either a REG or a SYMBOL_REF, although
152 : : the support provided depends on the backend. */
153 : : rtx stack_limit_rtx;
154 : :
155 : : class target_flag_state default_target_flag_state;
156 : : #if SWITCHABLE_TARGET
157 : : class target_flag_state *this_target_flag_state = &default_target_flag_state;
158 : : #else
159 : : #define this_target_flag_state (&default_target_flag_state)
160 : : #endif
161 : :
162 : : /* The user symbol prefix after having resolved same. */
163 : : const char *user_label_prefix;
164 : :
165 : : /* Output files for assembler code (real compiler output)
166 : : and debugging dumps. */
167 : :
168 : : FILE *asm_out_file;
169 : : FILE *aux_info_file;
170 : : FILE *callgraph_info_file = NULL;
171 : : static bitmap callgraph_info_external_printed;
172 : : FILE *stack_usage_file = NULL;
173 : : static bool no_backend = false;
174 : :
175 : : /* The current working directory of a translation. It's generally the
176 : : directory from which compilation was initiated, but a preprocessed
177 : : file may specify the original directory in which it was
178 : : created. */
179 : :
180 : : static const char *src_pwd;
181 : :
182 : : /* Initialize src_pwd with the given string, and return true. If it
183 : : was already initialized, return false. As a special case, it may
184 : : be called with a NULL argument to test whether src_pwd has NOT been
185 : : initialized yet. */
186 : :
187 : : bool
188 : 54 : set_src_pwd (const char *pwd)
189 : : {
190 : 54 : if (src_pwd)
191 : : {
192 : 0 : if (strcmp (src_pwd, pwd) == 0)
193 : : return true;
194 : : else
195 : : return false;
196 : : }
197 : :
198 : 54 : src_pwd = xstrdup (pwd);
199 : 54 : return true;
200 : : }
201 : :
202 : : /* Return the directory from which the translation unit was initiated,
203 : : in case set_src_pwd() was not called before to assign it a
204 : : different value. */
205 : :
206 : : const char *
207 : 71759 : get_src_pwd (void)
208 : : {
209 : 71759 : if (! src_pwd)
210 : : {
211 : 62651 : src_pwd = getpwd ();
212 : 62651 : if (!src_pwd)
213 : 0 : src_pwd = ".";
214 : : }
215 : :
216 : 71759 : return src_pwd;
217 : : }
218 : :
219 : : /* Called when the start of a function definition is parsed,
220 : : this function prints on stderr the name of the function. */
221 : : void
222 : 173517273 : announce_function (tree decl)
223 : : {
224 : 173517273 : if (!quiet_flag)
225 : : {
226 : 0 : if (rtl_dump_and_exit)
227 : 0 : fprintf (stderr, "%s ",
228 : 0 : identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl))));
229 : : else
230 : 0 : fprintf (stderr, " %s",
231 : 0 : identifier_to_locale (lang_hooks.decl_printable_name (decl, 2)));
232 : 0 : fflush (stderr);
233 : 0 : pp_needs_newline (global_dc->get_reference_printer ()) = true;
234 : 0 : diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
235 : : }
236 : 173517273 : }
237 : :
238 : : /* Initialize local_tick with the time of day, or -1 if
239 : : flag_random_seed is set. */
240 : :
241 : : static void
242 : 283153 : init_local_tick (void)
243 : : {
244 : 283153 : if (!flag_random_seed)
245 : : {
246 : : #ifdef HAVE_GETTIMEOFDAY
247 : 281373 : {
248 : 281373 : struct timeval tv;
249 : :
250 : 281373 : gettimeofday (&tv, NULL);
251 : 281373 : local_tick = (unsigned) tv.tv_sec * 1000 + tv.tv_usec / 1000;
252 : : }
253 : : #else
254 : : {
255 : : time_t now = time (NULL);
256 : :
257 : : if (now != (time_t)-1)
258 : : local_tick = (unsigned) now;
259 : : }
260 : : #endif
261 : : }
262 : : else
263 : 1780 : local_tick = -1;
264 : 283153 : }
265 : :
266 : : /* Obtain the random_seed. Unless NOINIT, initialize it if
267 : : it's not provided in the command line. */
268 : :
269 : : HOST_WIDE_INT
270 : 401901 : get_random_seed (bool noinit)
271 : : {
272 : 401901 : if (!random_seed && !noinit)
273 : : {
274 : 23646 : int fd = open ("/dev/urandom", O_RDONLY);
275 : 23646 : if (fd >= 0)
276 : : {
277 : 23646 : if (read (fd, &random_seed, sizeof (random_seed))
278 : : != sizeof (random_seed))
279 : 0 : random_seed = 0;
280 : 23646 : close (fd);
281 : : }
282 : 23646 : if (!random_seed)
283 : 0 : random_seed = local_tick ^ getpid ();
284 : : }
285 : 401901 : return random_seed;
286 : : }
287 : :
288 : : /* Set flag_random_seed to VAL, and if non-null, reinitialize random_seed. */
289 : :
290 : : void
291 : 1780 : set_random_seed (const char *val)
292 : : {
293 : 1780 : flag_random_seed = val;
294 : 1780 : if (flag_random_seed)
295 : : {
296 : 1780 : char *endp;
297 : :
298 : : /* When the driver passed in a hex number don't crc it again */
299 : 1780 : random_seed = strtoul (flag_random_seed, &endp, 0);
300 : 1780 : if (!(endp > flag_random_seed && *endp == 0))
301 : 554 : random_seed = crc32_string (0, flag_random_seed);
302 : : }
303 : 1780 : }
304 : :
305 : : /* Handler for fatal signals, such as SIGSEGV. These are transformed
306 : : into ICE messages, which is much more user friendly. In case the
307 : : error printer crashes, reset the signal to prevent infinite recursion. */
308 : :
309 : : static void
310 : 2 : crash_signal (int signo)
311 : : {
312 : 2 : signal (signo, SIG_DFL);
313 : :
314 : : /* If we crashed while processing an ASM statement, then be a little more
315 : : graceful. It's most likely the user's fault. */
316 : 2 : if (this_is_asm_operands)
317 : : {
318 : 0 : output_operand_lossage ("unrecoverable error");
319 : 0 : exit (FATAL_EXIT_CODE);
320 : : }
321 : :
322 : 2 : internal_error ("%s", strsignal (signo));
323 : : }
324 : :
325 : : /* A subroutine of wrapup_global_declarations. We've come to the end of
326 : : the compilation unit. All deferred variables should be undeferred,
327 : : and all incomplete decls should be finalized. */
328 : :
329 : : void
330 : 586881498 : wrapup_global_declaration_1 (tree decl)
331 : : {
332 : : /* We're not deferring this any longer. Assignment is conditional to
333 : : avoid needlessly dirtying PCH pages. */
334 : 586881498 : if (HAS_DECL_ASSEMBLER_NAME_P (decl)
335 : 586881498 : && DECL_DEFER_OUTPUT (decl) != 0)
336 : 21406326 : DECL_DEFER_OUTPUT (decl) = 0;
337 : :
338 : 586881498 : if (VAR_P (decl) && DECL_SIZE (decl) == 0)
339 : 346759 : lang_hooks.finish_incomplete_decl (decl);
340 : 586881498 : }
341 : :
342 : : /* A subroutine of wrapup_global_declarations. Decide whether or not DECL
343 : : needs to be output. Return true if it is output. */
344 : :
345 : : bool
346 : 717982291 : wrapup_global_declaration_2 (tree decl)
347 : : {
348 : 716236986 : if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl)
349 : 803528214 : || (VAR_P (decl) && DECL_HAS_VALUE_EXPR_P (decl)))
350 : : return false;
351 : :
352 : : /* Don't write out static consts, unless we still need them.
353 : :
354 : : We also keep static consts if not optimizing (for debugging),
355 : : unless the user specified -fno-keep-static-consts.
356 : : ??? They might be better written into the debug information.
357 : : This is possible when using DWARF.
358 : :
359 : : A language processor that wants static constants to be always
360 : : written out (even if it is not used) is responsible for
361 : : calling rest_of_decl_compilation itself. E.g. the C front-end
362 : : calls rest_of_decl_compilation from finish_decl.
363 : : One motivation for this is that is conventional in some
364 : : environments to write things like:
365 : : static const char rcsid[] = "... version string ...";
366 : : intending to force the string to be in the executable.
367 : :
368 : : A language processor that would prefer to have unneeded
369 : : static constants "optimized away" would just defer writing
370 : : them out until here. E.g. C++ does this, because static
371 : : constants are often defined in header files.
372 : :
373 : : ??? A tempting alternative (for both C and C++) would be
374 : : to force a constant to be written if and only if it is
375 : : defined in a main file, as opposed to an include file. */
376 : :
377 : 85545027 : if (VAR_P (decl) && TREE_STATIC (decl))
378 : : {
379 : 61268284 : varpool_node *node;
380 : 61268284 : bool needed = true;
381 : 61268284 : node = varpool_node::get (decl);
382 : :
383 : 61268284 : if (!node && flag_ltrans)
384 : : needed = false;
385 : 61169326 : else if (node && node->definition)
386 : : needed = false;
387 : 5408539 : else if (node && node->alias)
388 : : needed = false;
389 : 5507265 : else if (!symtab->global_info_ready
390 : 5507265 : && (TREE_USED (decl)
391 : 745037 : || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
392 : : /* needed */;
393 : 745026 : else if (node && node->analyzed)
394 : : /* needed */;
395 : 745026 : else if (DECL_COMDAT (decl))
396 : : needed = false;
397 : 724238 : else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
398 : 724114 : && (optimize || !flag_keep_static_consts
399 : 6 : || DECL_ARTIFICIAL (decl)))
400 : : needed = false;
401 : :
402 : : if (needed)
403 : : {
404 : 5486347 : rest_of_decl_compilation (decl, 1, 1);
405 : 5486347 : return true;
406 : : }
407 : : }
408 : :
409 : : return false;
410 : : }
411 : :
412 : : /* Do any final processing required for the declarations in VEC, of
413 : : which there are LEN. We write out inline functions and variables
414 : : that have been deferred until this point, but which are required.
415 : : Returns nonzero if anything was put out. */
416 : :
417 : : bool
418 : 222292 : wrapup_global_declarations (tree *vec, int len)
419 : : {
420 : 222292 : bool reconsider, output_something = false;
421 : 222292 : int i;
422 : :
423 : 213792437 : for (i = 0; i < len; i++)
424 : 213570145 : wrapup_global_declaration_1 (vec[i]);
425 : :
426 : : /* Now emit any global variables or functions that we have been
427 : : putting off. We need to loop in case one of the things emitted
428 : : here references another one which comes earlier in the list. */
429 : 252018 : do
430 : : {
431 : 252018 : reconsider = false;
432 : 236645109 : for (i = 0; i < len; i++)
433 : 236393091 : reconsider |= wrapup_global_declaration_2 (vec[i]);
434 : 252018 : if (reconsider)
435 : 29726 : output_something = true;
436 : : }
437 : : while (reconsider);
438 : :
439 : 222292 : return output_something;
440 : : }
441 : :
442 : : /* Compile an entire translation unit. Write a file of assembly
443 : : output and various debugging dumps. */
444 : :
445 : : static void
446 : 276800 : compile_file (void)
447 : : {
448 : 276800 : timevar_start (TV_PHASE_PARSING);
449 : 276800 : timevar_push (TV_PARSE_GLOBAL);
450 : :
451 : : /* Parse entire file and generate initial debug information. */
452 : 276800 : lang_hooks.parse_file ();
453 : :
454 : 275057 : timevar_pop (TV_PARSE_GLOBAL);
455 : 275057 : timevar_stop (TV_PHASE_PARSING);
456 : :
457 : 275057 : if (flag_dump_locations)
458 : 0 : dump_location_info (stderr);
459 : :
460 : 275057 : free_attr_data ();
461 : :
462 : : /* Compilation is now finished except for writing
463 : : what's left of the symbol table output. */
464 : :
465 : 275057 : if (flag_syntax_only || flag_wpa)
466 : : return;
467 : :
468 : : /* Reset maximum_field_alignment, it can be adjusted by #pragma pack
469 : : and this shouldn't influence any types built by the middle-end
470 : : from now on (like gcov_info_type). */
471 : 265871 : maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
472 : :
473 : 265871 : ggc_protect_identifiers = false;
474 : :
475 : : /* Run the actual compilation process. */
476 : 265871 : if (!in_lto_p)
477 : : {
478 : 252700 : timevar_start (TV_PHASE_OPT_GEN);
479 : 252700 : symtab->finalize_compilation_unit ();
480 : 252680 : timevar_stop (TV_PHASE_OPT_GEN);
481 : : }
482 : :
483 : : /* Perform any post compilation-proper parser cleanups and
484 : : processing. This is currently only needed for the C++ parser,
485 : : which can be hopefully cleaned up so this hook is no longer
486 : : necessary. */
487 : 265851 : if (lang_hooks.decls.post_compilation_parsing_cleanups)
488 : 91771 : lang_hooks.decls.post_compilation_parsing_cleanups ();
489 : :
490 : 265851 : dump_context::get ().finish_any_json_writer ();
491 : :
492 : 265851 : if (seen_error ())
493 : : return;
494 : :
495 : 240134 : timevar_start (TV_PHASE_LATE_ASM);
496 : :
497 : : /* Compilation unit is finalized. When producing non-fat LTO object, we are
498 : : basically finished. */
499 : 240134 : if ((in_lto_p && flag_incremental_link != INCREMENTAL_LINK_LTO)
500 : 226995 : || !flag_lto || flag_fat_lto_objects)
501 : : {
502 : : /* File-scope initialization for AddressSanitizer. */
503 : 226924 : if (flag_sanitize & SANITIZE_ADDRESS)
504 : 2349 : asan_finish_file ();
505 : :
506 : 226924 : if (flag_sanitize & SANITIZE_THREAD)
507 : 323 : tsan_finish_file ();
508 : :
509 : 226924 : if (gate_hwasan ())
510 : 328 : hwasan_finish_file ();
511 : :
512 : 226924 : omp_finish_file ();
513 : :
514 : 226924 : output_shared_constant_pool ();
515 : 226924 : output_object_blocks ();
516 : 226924 : finish_tm_clone_pairs ();
517 : :
518 : : /* Write out any pending weak symbol declarations. */
519 : 226924 : weak_finish ();
520 : :
521 : : /* This must be at the end before unwind and debug info.
522 : : Some target ports emit PIC setup thunks here. */
523 : 226924 : insn_locations_init ();
524 : 226924 : targetm.asm_out.code_end ();
525 : :
526 : : /* Do dbx symbols. */
527 : 226924 : timevar_push (TV_SYMOUT);
528 : :
529 : : #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
530 : 226924 : dwarf2out_frame_finish ();
531 : : #endif
532 : :
533 : 226924 : debuginfo_start ();
534 : 226924 : (*debug_hooks->finish) (main_input_filename);
535 : 226924 : debuginfo_stop ();
536 : 226924 : timevar_pop (TV_SYMOUT);
537 : :
538 : : /* Output some stuff at end of file if nec. */
539 : :
540 : 226924 : dw2_output_indirect_constants ();
541 : :
542 : : /* Flush any pending external directives. */
543 : 226924 : process_pending_assemble_externals ();
544 : : }
545 : :
546 : : /* Let linker plugin know that this is a slim object and must be LTOed
547 : : even when user did not ask for it. */
548 : 240134 : if (flag_generate_lto && !flag_fat_lto_objects)
549 : : {
550 : : #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
551 : 13210 : ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE, "__gnu_lto_slim",
552 : 13210 : HOST_WIDE_INT_1U, 8);
553 : : #elif defined ASM_OUTPUT_ALIGNED_COMMON
554 : : ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_slim",
555 : : HOST_WIDE_INT_1U, 8);
556 : : #else
557 : : ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_slim",
558 : : HOST_WIDE_INT_1U,
559 : : HOST_WIDE_INT_1U);
560 : : #endif
561 : : }
562 : :
563 : : /* Attach a special .ident directive to the end of the file to identify
564 : : the version of GCC which compiled this code. The format of the .ident
565 : : string is patterned after the ones produced by native SVR4 compilers. */
566 : 240134 : if (!flag_no_ident)
567 : : {
568 : 232744 : const char *pkg_version = "(GNU) ";
569 : 232744 : char *ident_str;
570 : :
571 : 232744 : if (strcmp ("(GCC) ", pkgversion_string))
572 : : pkg_version = pkgversion_string;
573 : :
574 : 232744 : ident_str = ACONCAT (("GCC: ", pkg_version, version_string, NULL));
575 : 232744 : targetm.asm_out.output_ident (ident_str);
576 : : }
577 : :
578 : : /* Auto profile finalization. */
579 : 240134 : if (flag_auto_profile)
580 : 0 : end_auto_profile ();
581 : :
582 : : /* Invoke registered plugin callbacks. */
583 : 240134 : invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
584 : :
585 : : /* This must be at the end. Some target ports emit end of file directives
586 : : into the assembly file here, and hence we cannot output anything to the
587 : : assembly file after this point. */
588 : 240134 : targetm.asm_out.file_end ();
589 : :
590 : 240134 : timevar_stop (TV_PHASE_LATE_ASM);
591 : : }
592 : :
593 : : /* Print version information to FILE.
594 : : Each line begins with INDENT (for the case where FILE is the
595 : : assembler output file).
596 : :
597 : : If SHOW_GLOBAL_STATE is true (for cc1 etc), we are within the compiler
598 : : proper and can print pertinent state (e.g. params and plugins).
599 : :
600 : : If SHOW_GLOBAL_STATE is false (for use by libgccjit), we are outside the
601 : : compiler, and we don't hold the mutex on the compiler's global state:
602 : : we can't print params and plugins, since they might not be initialized,
603 : : or might be being manipulated by a compile running in another
604 : : thread. */
605 : :
606 : : void
607 : 2337 : print_version (FILE *file, const char *indent, bool show_global_state)
608 : : {
609 : 2337 : static const char fmt1[] =
610 : : #ifdef __GNUC__
611 : : N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
612 : : #else
613 : : N_("%s%s%s %sversion %s (%s) compiled by CC, ")
614 : : #endif
615 : : ;
616 : 2337 : static const char fmt2[] =
617 : : N_("GMP version %s, MPFR version %s, MPC version %s, isl version %s\n");
618 : 2337 : static const char fmt3[] =
619 : : N_("%s%swarning: %s header version %s differs from library version %s.\n");
620 : 2337 : static const char fmt4[] =
621 : : N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
622 : : #ifndef __VERSION__
623 : : #define __VERSION__ "[?]"
624 : : #endif
625 : 2337 : fprintf (file,
626 : 2337 : file == stderr ? _(fmt1) : fmt1,
627 : 2337 : indent, *indent != 0 ? " " : "",
628 : : lang_hooks.name, pkgversion_string, version_string, TARGET_NAME,
629 : : indent, __VERSION__);
630 : :
631 : : /* We need to stringify the GMP macro values. Ugh, gmp_version has
632 : : two string formats, "i.j.k" and "i.j" when k is zero. As of
633 : : gmp-4.3.0, GMP always uses the 3 number format. */
634 : : #define GCC_GMP_STRINGIFY_VERSION3(X) #X
635 : : #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3 (X)
636 : : #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
637 : : #define GCC_GMP_VERSION \
638 : : GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
639 : : #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
640 : : #define GCC_GMP_STRINGIFY_VERSION \
641 : : GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
642 : : GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR)
643 : : #else
644 : : #define GCC_GMP_STRINGIFY_VERSION \
645 : : GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
646 : : GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) "." \
647 : : GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_PATCHLEVEL)
648 : : #endif
649 : 4674 : fprintf (file,
650 : 2337 : file == stderr ? _(fmt2) : fmt2,
651 : : GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING,
652 : : #ifndef HAVE_isl
653 : : "none"
654 : : #else
655 : : isl_version ()
656 : : #endif
657 : : );
658 : 2337 : if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
659 : 0 : fprintf (file,
660 : 0 : file == stderr ? _(fmt3) : fmt3,
661 : 0 : indent, *indent != 0 ? " " : "",
662 : : "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
663 : 2337 : if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ()))
664 : 0 : fprintf (file,
665 : 0 : file == stderr ? _(fmt3) : fmt3,
666 : 0 : indent, *indent != 0 ? " " : "",
667 : : "MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
668 : 2337 : if (strcmp (MPC_VERSION_STRING, mpc_get_version ()))
669 : 0 : fprintf (file,
670 : 0 : file == stderr ? _(fmt3) : fmt3,
671 : 0 : indent, *indent != 0 ? " " : "",
672 : : "MPC", MPC_VERSION_STRING, mpc_get_version ());
673 : :
674 : 2337 : if (show_global_state)
675 : : {
676 : 123 : fprintf (file,
677 : 123 : file == stderr ? _(fmt4) : fmt4,
678 : 123 : indent, *indent != 0 ? " " : "",
679 : : param_ggc_min_expand, param_ggc_min_heapsize);
680 : :
681 : 123 : print_plugins_versions (file, indent);
682 : : }
683 : 2337 : }
684 : :
685 : :
686 : :
687 : : /* Open assembly code output file. Do this even if -fsyntax-only is
688 : : on, because then the driver will have provided the name of a
689 : : temporary file or bit bucket for us. NAME is the file specified on
690 : : the command line, possibly NULL. */
691 : : static void
692 : 268214 : init_asm_output (const char *name)
693 : : {
694 : 268214 : if (name == NULL && asm_file_name == 0)
695 : 0 : asm_out_file = stdout;
696 : : else
697 : : {
698 : 268214 : if (asm_file_name == 0)
699 : : {
700 : 1249 : int len = strlen (dump_base_name);
701 : 1249 : char *dumpname = XNEWVEC (char, len + 6);
702 : :
703 : 1249 : memcpy (dumpname, dump_base_name, len + 1);
704 : 1249 : strip_off_ending (dumpname, len);
705 : 1249 : strcat (dumpname, ".s");
706 : 1249 : asm_file_name = dumpname;
707 : : }
708 : 268214 : if (!strcmp (asm_file_name, "-"))
709 : 163 : asm_out_file = stdout;
710 : 268051 : else if (!canonical_filename_eq (asm_file_name, name)
711 : 268051 : || !strcmp (asm_file_name, HOST_BIT_BUCKET))
712 : 268051 : asm_out_file = fopen (asm_file_name, "w");
713 : : else
714 : : /* Use UNKOWN_LOCATION to prevent gcc from printing the first
715 : : line in the current file. */
716 : 0 : fatal_error (UNKNOWN_LOCATION,
717 : : "input file %qs is the same as output file",
718 : : asm_file_name);
719 : 268214 : if (asm_out_file == 0)
720 : 0 : fatal_error (UNKNOWN_LOCATION,
721 : : "cannot open %qs for writing: %m", asm_file_name);
722 : : }
723 : :
724 : 268214 : if (!flag_syntax_only && !(global_dc->get_lang_mask () & CL_LTODump))
725 : : {
726 : 268074 : targetm.asm_out.file_start ();
727 : :
728 : 268074 : if (flag_record_gcc_switches)
729 : : {
730 : 0 : if (targetm.asm_out.record_gcc_switches)
731 : : {
732 : 0 : const char *str
733 : 0 : = gen_producer_string (lang_hooks.name,
734 : : save_decoded_options,
735 : : save_decoded_options_count);
736 : 0 : targetm.asm_out.record_gcc_switches (str);
737 : : }
738 : : else
739 : 0 : inform (UNKNOWN_LOCATION,
740 : : "%<-frecord-gcc-switches%> is not supported by "
741 : : "the current target");
742 : : }
743 : :
744 : 268074 : if (flag_verbose_asm)
745 : : {
746 : 11 : print_version (asm_out_file, ASM_COMMENT_START, true);
747 : 11 : fputs (ASM_COMMENT_START, asm_out_file);
748 : 11 : fputs (" options passed: ", asm_out_file);
749 : 11 : char *cmdline = gen_command_line_string (save_decoded_options,
750 : : save_decoded_options_count);
751 : 11 : fputs (cmdline, asm_out_file);
752 : 11 : free (cmdline);
753 : 11 : fputc ('\n', asm_out_file);
754 : : }
755 : : }
756 : 268214 : }
757 : :
758 : : /* A helper function; used as the reallocator function for cpp's line
759 : : table. */
760 : : static void *
761 : 581363078 : realloc_for_line_map (void *ptr, size_t len)
762 : : {
763 : 581363078 : return ggc_realloc (ptr, len);
764 : : }
765 : :
766 : : /* A helper function: used as the allocator function for
767 : : identifier_to_locale. */
768 : : static void *
769 : 1285 : alloc_for_identifier_to_locale (size_t len)
770 : : {
771 : 1285 : return ggc_alloc_atomic (len);
772 : : }
773 : :
774 : : /* Output stack usage information. */
775 : : static void
776 : 355 : output_stack_usage_1 (FILE *cf)
777 : : {
778 : 355 : static bool warning_issued = false;
779 : 355 : enum stack_usage_kind_type { STATIC = 0, DYNAMIC, DYNAMIC_BOUNDED };
780 : 355 : const char *stack_usage_kind_str[] = {
781 : : "static",
782 : : "dynamic",
783 : : "dynamic,bounded"
784 : : };
785 : 355 : HOST_WIDE_INT stack_usage = current_function_static_stack_size;
786 : 355 : enum stack_usage_kind_type stack_usage_kind;
787 : :
788 : 355 : if (stack_usage < 0)
789 : : {
790 : 0 : if (!warning_issued)
791 : : {
792 : 0 : warning (0, "stack usage computation not supported for this target");
793 : 0 : warning_issued = true;
794 : : }
795 : 0 : return;
796 : : }
797 : :
798 : 355 : stack_usage_kind = STATIC;
799 : :
800 : : /* Add the maximum amount of space pushed onto the stack. */
801 : 355 : if (maybe_ne (current_function_pushed_stack_size, 0))
802 : : {
803 : 0 : HOST_WIDE_INT extra;
804 : 0 : if (current_function_pushed_stack_size.is_constant (&extra))
805 : : {
806 : 0 : stack_usage += extra;
807 : 0 : stack_usage_kind = DYNAMIC_BOUNDED;
808 : : }
809 : : else
810 : : {
811 : : extra = constant_lower_bound (current_function_pushed_stack_size);
812 : : stack_usage += extra;
813 : : stack_usage_kind = DYNAMIC;
814 : : }
815 : : }
816 : :
817 : : /* Now on to the tricky part: dynamic stack allocation. */
818 : 355 : if (current_function_allocates_dynamic_stack_space)
819 : : {
820 : 2 : if (stack_usage_kind != DYNAMIC)
821 : : {
822 : 2 : if (current_function_has_unbounded_dynamic_stack_size)
823 : : stack_usage_kind = DYNAMIC;
824 : : else
825 : 1 : stack_usage_kind = DYNAMIC_BOUNDED;
826 : : }
827 : :
828 : : /* Add the size even in the unbounded case, this can't hurt. */
829 : 2 : stack_usage += current_function_dynamic_stack_size;
830 : : }
831 : :
832 : 355 : if (cf && flag_callgraph_info & CALLGRAPH_INFO_STACK_USAGE)
833 : 0 : fprintf (cf, "\\n" HOST_WIDE_INT_PRINT_DEC " bytes (%s)",
834 : : stack_usage,
835 : 0 : stack_usage_kind_str[stack_usage_kind]);
836 : :
837 : 355 : if (stack_usage_file)
838 : : {
839 : 329 : print_decl_identifier (stack_usage_file, current_function_decl,
840 : : PRINT_DECL_ORIGIN | PRINT_DECL_NAME
841 : : | PRINT_DECL_REMAP_DEBUG);
842 : 329 : fprintf (stack_usage_file, "\t" HOST_WIDE_INT_PRINT_DEC"\t%s\n",
843 : 329 : stack_usage, stack_usage_kind_str[stack_usage_kind]);
844 : : }
845 : :
846 : 355 : if (warn_stack_usage >= 0 && warn_stack_usage < HOST_WIDE_INT_MAX)
847 : : {
848 : 13 : const location_t loc = DECL_SOURCE_LOCATION (current_function_decl);
849 : :
850 : 13 : if (stack_usage_kind == DYNAMIC)
851 : 1 : warning_at (loc, OPT_Wstack_usage_, "stack usage might be unbounded");
852 : 12 : else if (stack_usage > warn_stack_usage)
853 : : {
854 : 2 : if (stack_usage_kind == DYNAMIC_BOUNDED)
855 : 1 : warning_at (loc,
856 : : OPT_Wstack_usage_, "stack usage might be %wu bytes",
857 : : stack_usage);
858 : : else
859 : 1 : warning_at (loc, OPT_Wstack_usage_, "stack usage is %wu bytes",
860 : : stack_usage);
861 : : }
862 : : }
863 : : }
864 : :
865 : : /* Dump placeholder node for indirect calls in VCG format. */
866 : :
867 : : #define INDIRECT_CALL_NAME "__indirect_call"
868 : :
869 : : static void
870 : 2 : dump_final_node_vcg_start (FILE *f, tree decl)
871 : : {
872 : 2 : fputs ("node: { title: \"", f);
873 : 2 : if (decl)
874 : 2 : print_decl_identifier (f, decl, PRINT_DECL_UNIQUE_NAME);
875 : : else
876 : 0 : fputs (INDIRECT_CALL_NAME, f);
877 : 2 : fputs ("\" label: \"", f);
878 : 2 : if (decl)
879 : : {
880 : 2 : print_decl_identifier (f, decl, PRINT_DECL_NAME);
881 : 2 : fputs ("\\n", f);
882 : 2 : print_decl_identifier (f, decl, PRINT_DECL_ORIGIN);
883 : : }
884 : : else
885 : 0 : fputs ("Indirect Call Placeholder", f);
886 : 2 : }
887 : :
888 : : /* Dump final cgraph edge in VCG format. */
889 : :
890 : : static void
891 : 0 : dump_final_callee_vcg (FILE *f, location_t location, tree callee)
892 : : {
893 : 0 : if ((!callee || DECL_EXTERNAL (callee))
894 : 0 : && bitmap_set_bit (callgraph_info_external_printed,
895 : 0 : callee ? DECL_UID (callee) + 1 : 0))
896 : : {
897 : 0 : dump_final_node_vcg_start (f, callee);
898 : 0 : fputs ("\" shape : ellipse }\n", f);
899 : : }
900 : :
901 : 0 : fputs ("edge: { sourcename: \"", f);
902 : 0 : print_decl_identifier (f, current_function_decl, PRINT_DECL_UNIQUE_NAME);
903 : 0 : fputs ("\" targetname: \"", f);
904 : 0 : if (callee)
905 : 0 : print_decl_identifier (f, callee, PRINT_DECL_UNIQUE_NAME);
906 : : else
907 : 0 : fputs (INDIRECT_CALL_NAME, f);
908 : 0 : if (LOCATION_LOCUS (location) != UNKNOWN_LOCATION)
909 : : {
910 : 0 : expanded_location loc;
911 : 0 : fputs ("\" label: \"", f);
912 : 0 : loc = expand_location (location);
913 : 0 : fprintf (f, "%s:%d:%d", loc.file, loc.line, loc.column);
914 : : }
915 : 0 : fputs ("\" }\n", f);
916 : 0 : }
917 : :
918 : : /* Callback for cgraph_node::call_for_symbol_thunks_and_aliases to dump to F_ a
919 : : node and an edge from ALIAS->DECL to CURRENT_FUNCTION_DECL. */
920 : :
921 : : static bool
922 : 2 : dump_final_alias_vcg (cgraph_node *alias, void *f_)
923 : : {
924 : 2 : FILE *f = (FILE *)f_;
925 : :
926 : 2 : if (alias->decl == current_function_decl)
927 : : return false;
928 : :
929 : 1 : dump_final_node_vcg_start (f, alias->decl);
930 : 1 : fputs ("\" shape : triangle }\n", f);
931 : :
932 : 1 : fputs ("edge: { sourcename: \"", f);
933 : 1 : print_decl_identifier (f, alias->decl, PRINT_DECL_UNIQUE_NAME);
934 : 1 : fputs ("\" targetname: \"", f);
935 : 1 : print_decl_identifier (f, current_function_decl, PRINT_DECL_UNIQUE_NAME);
936 : 1 : location_t location = DECL_SOURCE_LOCATION (alias->decl);
937 : 1 : if (LOCATION_LOCUS (location) != UNKNOWN_LOCATION)
938 : : {
939 : 1 : expanded_location loc;
940 : 1 : fputs ("\" label: \"", f);
941 : 1 : loc = expand_location (location);
942 : 1 : fprintf (f, "%s:%d:%d", loc.file, loc.line, loc.column);
943 : : }
944 : 1 : fputs ("\" }\n", f);
945 : :
946 : 1 : return false;
947 : : }
948 : :
949 : : /* Dump final cgraph node in VCG format. */
950 : :
951 : : static void
952 : 1 : dump_final_node_vcg (FILE *f)
953 : : {
954 : 1 : dump_final_node_vcg_start (f, current_function_decl);
955 : :
956 : 1 : if (flag_stack_usage_info
957 : 1 : || (flag_callgraph_info & CALLGRAPH_INFO_STACK_USAGE))
958 : 0 : output_stack_usage_1 (f);
959 : :
960 : 1 : if (flag_callgraph_info & CALLGRAPH_INFO_DYNAMIC_ALLOC)
961 : : {
962 : 0 : fprintf (f, "\\n%u dynamic objects", vec_safe_length (cfun->su->dallocs));
963 : :
964 : 0 : unsigned i;
965 : 0 : callinfo_dalloc *cda;
966 : 0 : FOR_EACH_VEC_SAFE_ELT (cfun->su->dallocs, i, cda)
967 : : {
968 : 0 : expanded_location loc = expand_location (cda->location);
969 : 0 : fprintf (f, "\\n %s", cda->name);
970 : 0 : fprintf (f, " %s:%d:%d", loc.file, loc.line, loc.column);
971 : : }
972 : :
973 : 0 : vec_free (cfun->su->dallocs);
974 : 0 : cfun->su->dallocs = NULL;
975 : : }
976 : :
977 : 1 : fputs ("\" }\n", f);
978 : :
979 : 1 : unsigned i;
980 : 1 : callinfo_callee *c;
981 : 2 : FOR_EACH_VEC_SAFE_ELT (cfun->su->callees, i, c)
982 : 0 : dump_final_callee_vcg (f, c->location, c->decl);
983 : 1 : vec_free (cfun->su->callees);
984 : 1 : cfun->su->callees = NULL;
985 : :
986 : 1 : cgraph_node *node = cgraph_node::get (current_function_decl);
987 : 1 : if (!node)
988 : 1 : return;
989 : 1 : node->call_for_symbol_thunks_and_aliases (dump_final_alias_vcg, f,
990 : : true, false);
991 : : }
992 : :
993 : : /* Output stack usage and callgraph info, as requested. */
994 : : void
995 : 356 : output_stack_usage (void)
996 : : {
997 : 356 : if (flag_callgraph_info)
998 : 1 : dump_final_node_vcg (callgraph_info_file);
999 : : else
1000 : 355 : output_stack_usage_1 (NULL);
1001 : 356 : }
1002 : :
1003 : : /* Open an auxiliary output file. */
1004 : : static FILE *
1005 : 312 : open_auxiliary_file (const char *ext)
1006 : : {
1007 : 312 : char *filename;
1008 : 312 : FILE *file;
1009 : :
1010 : 312 : filename = concat (aux_base_name, ".", ext, NULL);
1011 : 312 : file = fopen (filename, "w");
1012 : 312 : if (!file)
1013 : 0 : fatal_error (input_location, "cannot open %s for writing: %m", filename);
1014 : 312 : free (filename);
1015 : 312 : return file;
1016 : : }
1017 : :
1018 : : /* Alternative diagnostics callback for reentered ICE reporting. */
1019 : :
1020 : : static void
1021 : 0 : internal_error_reentered (diagnostic_context *, const char *, va_list *)
1022 : : {
1023 : : /* Flush the dump file if emergency_dump_function itself caused an ICE. */
1024 : 0 : if (dump_file)
1025 : 0 : fflush (dump_file);
1026 : 0 : }
1027 : :
1028 : : /* Auxiliary callback for the diagnostics code. */
1029 : :
1030 : : static void
1031 : 81 : internal_error_function (diagnostic_context *, const char *, va_list *)
1032 : : {
1033 : 81 : global_dc->m_internal_error = internal_error_reentered;
1034 : 81 : warn_if_plugins ();
1035 : 81 : emergency_dump_function ();
1036 : 81 : }
1037 : :
1038 : : /* Initialization of the front end environment, before command line
1039 : : options are parsed. Signal handlers, internationalization etc.
1040 : : ARGV0 is main's argv[0]. */
1041 : : static void
1042 : 283157 : general_init (const char *argv0, bool init_signals, unique_argv original_argv)
1043 : : {
1044 : 283157 : const char *p;
1045 : :
1046 : 283157 : p = argv0 + strlen (argv0);
1047 : 1638332 : while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
1048 : 1355175 : --p;
1049 : 283157 : progname = p;
1050 : :
1051 : 283157 : xmalloc_set_program_name (progname);
1052 : :
1053 : 283157 : hex_init ();
1054 : :
1055 : : /* Unlock the stdio streams. */
1056 : 283157 : unlock_std_streams ();
1057 : :
1058 : 283157 : gcc_init_libintl ();
1059 : :
1060 : 283157 : identifier_to_locale_alloc = alloc_for_identifier_to_locale;
1061 : 283157 : identifier_to_locale_free = ggc_free;
1062 : :
1063 : : /* Initialize the diagnostics reporting machinery, so option parsing
1064 : : can give warnings and errors. */
1065 : 283157 : diagnostic_initialize (global_dc, N_OPTS);
1066 : : /* Set a default printer. Language specific initializations will
1067 : : override it later. */
1068 : 283157 : tree_diagnostics_defaults (global_dc);
1069 : :
1070 : 283157 : global_dc->set_original_argv (std::move (original_argv));
1071 : :
1072 : 283157 : global_dc->m_source_printing.enabled
1073 : 283157 : = global_options_init.x_flag_diagnostics_show_caret;
1074 : 283157 : global_dc->m_source_printing.show_event_links_p
1075 : 283157 : = global_options_init.x_flag_diagnostics_show_event_links;
1076 : 283157 : global_dc->m_source_printing.show_labels_p
1077 : 283157 : = global_options_init.x_flag_diagnostics_show_labels;
1078 : 283157 : global_dc->m_source_printing.show_line_numbers_p
1079 : 283157 : = global_options_init.x_flag_diagnostics_show_line_numbers;
1080 : 283157 : global_dc->set_show_cwe (global_options_init.x_flag_diagnostics_show_cwe);
1081 : 283157 : global_dc->set_show_rules (global_options_init.x_flag_diagnostics_show_rules);
1082 : 283157 : global_dc->set_path_format
1083 : 283157 : ((enum diagnostic_path_format)
1084 : 283157 : global_options_init.x_flag_diagnostics_path_format);
1085 : 283157 : global_dc->set_show_path_depths
1086 : 283157 : (global_options_init.x_flag_diagnostics_show_path_depths);
1087 : 283157 : global_dc->set_show_option_requested
1088 : 283157 : (global_options_init.x_flag_diagnostics_show_option);
1089 : 283157 : global_dc->m_source_printing.min_margin_width
1090 : 283157 : = global_options_init.x_diagnostics_minimum_margin_width;
1091 : 283157 : global_dc->m_show_column
1092 : 283157 : = global_options_init.x_flag_show_column;
1093 : 283157 : global_dc->set_show_highlight_colors
1094 : 283157 : (global_options_init.x_flag_diagnostics_show_highlight_colors);
1095 : 283157 : global_dc->m_internal_error = internal_error_function;
1096 : 283157 : const unsigned lang_mask = lang_hooks.option_lang_mask ();
1097 : 283157 : global_dc->set_option_manager
1098 : 283157 : (::make_unique<compiler_diagnostic_option_manager> (*global_dc,
1099 : : lang_mask,
1100 : 283157 : &global_options),
1101 : : lang_mask);
1102 : 283157 : global_dc->push_owned_urlifier (make_gcc_urlifier (lang_mask));
1103 : :
1104 : 283157 : if (init_signals)
1105 : : {
1106 : : /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
1107 : : #ifdef SIGSEGV
1108 : 281903 : signal (SIGSEGV, crash_signal);
1109 : : #endif
1110 : : #ifdef SIGILL
1111 : 281903 : signal (SIGILL, crash_signal);
1112 : : #endif
1113 : : #ifdef SIGBUS
1114 : 281903 : signal (SIGBUS, crash_signal);
1115 : : #endif
1116 : : #ifdef SIGABRT
1117 : 281903 : signal (SIGABRT, crash_signal);
1118 : : #endif
1119 : : #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1120 : : signal (SIGIOT, crash_signal);
1121 : : #endif
1122 : : #ifdef SIGFPE
1123 : 281903 : signal (SIGFPE, crash_signal);
1124 : : #endif
1125 : :
1126 : : /* Other host-specific signal setup. */
1127 : 281903 : (*host_hooks.extra_signals)();
1128 : : }
1129 : :
1130 : : /* Initialize the garbage-collector, string pools and tree type hash
1131 : : table. */
1132 : 283157 : init_ggc ();
1133 : 283157 : init_stringpool ();
1134 : 283157 : input_location = UNKNOWN_LOCATION;
1135 : 283157 : line_table = ggc_alloc<line_maps> ();
1136 : 283157 : linemap_init (line_table, BUILTINS_LOCATION);
1137 : 283157 : line_table->m_reallocator = realloc_for_line_map;
1138 : 283157 : line_table->m_round_alloc_size = ggc_round_alloc_size;
1139 : 283157 : line_table->default_range_bits = line_map_suggested_range_bits;
1140 : 283157 : init_ttree ();
1141 : :
1142 : : /* Initialize register usage now so switches may override. */
1143 : 283157 : init_reg_sets ();
1144 : :
1145 : : /* Create the singleton holder for global state. This creates the
1146 : : dump manager. */
1147 : 283157 : g = new gcc::context ();
1148 : :
1149 : : /* Allow languages and middle-end to register their dumps before the
1150 : : optimization passes. */
1151 : 283157 : g->get_dumps ()->register_dumps ();
1152 : :
1153 : : /* Create the passes. */
1154 : 283157 : g->set_passes (new gcc::pass_manager (g));
1155 : :
1156 : 283157 : symtab = new (ggc_alloc <symbol_table> ()) symbol_table ();
1157 : :
1158 : 283157 : statistics_early_init ();
1159 : 283157 : debuginfo_early_init ();
1160 : 283157 : }
1161 : :
1162 : : /* Return true if the current target supports -fsection-anchors. */
1163 : :
1164 : : static bool
1165 : 0 : target_supports_section_anchors_p (void)
1166 : : {
1167 : 0 : if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
1168 : : return false;
1169 : :
1170 : 0 : if (targetm.asm_out.output_anchor == NULL)
1171 : 0 : return false;
1172 : :
1173 : : return true;
1174 : : }
1175 : :
1176 : : /* Parse "N[:M][:...]" into struct align_flags A.
1177 : : VALUES contains parsed values (in reverse order), all processed
1178 : : values are popped. */
1179 : :
1180 : : static void
1181 : 582643 : read_log_maxskip (auto_vec<unsigned> &values, align_flags_tuple *a)
1182 : : {
1183 : 582643 : unsigned n = values.pop ();
1184 : 582643 : if (n != 0)
1185 : 466127 : a->log = floor_log2 (n * 2 - 1);
1186 : :
1187 : 582643 : if (values.is_empty ())
1188 : 349580 : a->maxskip = n ? n - 1 : 0;
1189 : : else
1190 : : {
1191 : 233063 : unsigned m = values.pop ();
1192 : : /* -falign-foo=N:M means M-1 max bytes of padding, not M. */
1193 : 233063 : if (m > 0)
1194 : 116547 : m--;
1195 : 233063 : a->maxskip = m;
1196 : : }
1197 : :
1198 : : /* Normalize the tuple. */
1199 : 582643 : a->normalize ();
1200 : 582643 : }
1201 : :
1202 : : /* Parse "N[:M[:N2[:M2]]]" string FLAG into a pair of struct align_flags. */
1203 : :
1204 : : static void
1205 : 2651994560 : parse_N_M (const char *flag, align_flags &a)
1206 : : {
1207 : 2651994560 : if (flag)
1208 : : {
1209 : 2406198406 : static hash_map <nofree_string_hash, align_flags> cache;
1210 : 2406198406 : align_flags *entry = cache.get (flag);
1211 : 2406198406 : if (entry)
1212 : : {
1213 : 2405848823 : a = *entry;
1214 : 2405848823 : return;
1215 : : }
1216 : :
1217 : 349583 : auto_vec<unsigned> result_values;
1218 : 349583 : bool r = parse_and_check_align_values (flag, NULL, result_values, false,
1219 : : UNKNOWN_LOCATION);
1220 : 349583 : if (!r)
1221 : 0 : return;
1222 : :
1223 : : /* Reverse values for easier manipulation. */
1224 : 349583 : result_values.reverse ();
1225 : :
1226 : 349583 : read_log_maxskip (result_values, &a.levels[0]);
1227 : 349583 : if (!result_values.is_empty ())
1228 : 233060 : read_log_maxskip (result_values, &a.levels[1]);
1229 : : #ifdef SUBALIGN_LOG
1230 : : else
1231 : : {
1232 : : /* N2[:M2] is not specified. This arch has a default for N2.
1233 : : Before -falign-foo=N:M:N2:M2 was introduced, x86 had a tweak.
1234 : : -falign-functions=N with N > 8 was adding secondary alignment.
1235 : : -falign-functions=10 was emitting this before every function:
1236 : : .p2align 4,,9
1237 : : .p2align 3
1238 : : Now this behavior (and more) can be explicitly requested:
1239 : : -falign-functions=16:10:8
1240 : : Retain old behavior if N2 is missing: */
1241 : :
1242 : 116523 : int align = 1 << a.levels[0].log;
1243 : 116523 : int subalign = 1 << SUBALIGN_LOG;
1244 : :
1245 : 116523 : if (a.levels[0].log > SUBALIGN_LOG
1246 : 116522 : && a.levels[0].maxskip >= subalign - 1)
1247 : : {
1248 : : /* Set N2 unless subalign can never have any effect. */
1249 : 116522 : if (align > a.levels[0].maxskip + 1)
1250 : : {
1251 : 32 : a.levels[1].log = SUBALIGN_LOG;
1252 : 32 : a.levels[1].normalize ();
1253 : : }
1254 : : }
1255 : : }
1256 : : #endif
1257 : :
1258 : : /* Cache seen value. */
1259 : 349583 : cache.put (flag, a);
1260 : 349583 : }
1261 : : }
1262 : :
1263 : : /* Process -falign-foo=N[:M[:N2[:M2]]] options. */
1264 : :
1265 : : void
1266 : 662998640 : parse_alignment_opts (void)
1267 : : {
1268 : 662998640 : parse_N_M (str_align_loops, align_loops);
1269 : 662998640 : parse_N_M (str_align_jumps, align_jumps);
1270 : 662998640 : parse_N_M (str_align_labels, align_labels);
1271 : 662998640 : parse_N_M (str_align_functions, align_functions);
1272 : 662998640 : }
1273 : :
1274 : : /* Process the options that have been parsed. */
1275 : : static void
1276 : 283049 : process_options ()
1277 : : {
1278 : 283049 : const char *language_string = lang_hooks.name;
1279 : :
1280 : 283049 : maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
1281 : :
1282 : : /* Some machines may reject certain combinations of options. */
1283 : 283049 : location_t saved_location = input_location;
1284 : 283049 : input_location = UNKNOWN_LOCATION;
1285 : 283049 : targetm.target_option.override ();
1286 : 283049 : input_location = saved_location;
1287 : :
1288 : 283049 : if (flag_diagnostics_generate_patch)
1289 : 17 : global_dc->create_edit_context ();
1290 : :
1291 : : /* Avoid any informative notes in the second run of -fcompare-debug. */
1292 : 283049 : if (flag_compare_debug)
1293 : 612 : diagnostic_inhibit_notes (global_dc);
1294 : :
1295 : 283049 : if (flag_section_anchors && !target_supports_section_anchors_p ())
1296 : : {
1297 : 0 : warning_at (UNKNOWN_LOCATION, OPT_fsection_anchors,
1298 : : "this target does not support %qs",
1299 : : "-fsection-anchors");
1300 : 0 : flag_section_anchors = 0;
1301 : : }
1302 : :
1303 : 283049 : if (!OPTION_SET_P (flag_short_enums))
1304 : 282921 : flag_short_enums = targetm.default_short_enums ();
1305 : :
1306 : : /* Set aux_base_name if not already set. */
1307 : 283049 : if (aux_base_name)
1308 : : ;
1309 : 283049 : else if (dump_base_name)
1310 : : {
1311 : 280359 : const char *name = dump_base_name;
1312 : 280359 : int nlen, len;
1313 : :
1314 : 258342 : if (dump_base_ext && (len = strlen (dump_base_ext))
1315 : 258342 : && (nlen = strlen (name)) && nlen > len
1316 : 538701 : && strcmp (name + nlen - len, dump_base_ext) == 0)
1317 : : {
1318 : 258342 : char *p = xstrndup (name, nlen - len);
1319 : 258342 : name = p;
1320 : : }
1321 : :
1322 : 280359 : aux_base_name = name;
1323 : : }
1324 : : else
1325 : 2690 : aux_base_name = "gccaux";
1326 : :
1327 : : #ifndef HAVE_isl
1328 : : if (flag_graphite
1329 : : || flag_loop_nest_optimize
1330 : : || flag_graphite_identity
1331 : : || flag_loop_parallelize_all)
1332 : : sorry ("Graphite loop optimizations cannot be used (isl is not available) "
1333 : : "(%<-fgraphite%>, %<-fgraphite-identity%>, "
1334 : : "%<-floop-nest-optimize%>, %<-floop-parallelize-all%>)");
1335 : : #endif
1336 : :
1337 : 283049 : if (flag_cf_protection != CF_NONE
1338 : 20174 : && !(flag_cf_protection & CF_SET))
1339 : : {
1340 : 0 : if (flag_cf_protection == CF_FULL)
1341 : : {
1342 : 0 : error_at (UNKNOWN_LOCATION,
1343 : : "%<-fcf-protection=full%> is not supported for this "
1344 : : "target");
1345 : 0 : flag_cf_protection = CF_NONE;
1346 : : }
1347 : 0 : if (flag_cf_protection == CF_BRANCH)
1348 : : {
1349 : 0 : error_at (UNKNOWN_LOCATION,
1350 : : "%<-fcf-protection=branch%> is not supported for this "
1351 : : "target");
1352 : 0 : flag_cf_protection = CF_NONE;
1353 : : }
1354 : 0 : if (flag_cf_protection == CF_RETURN)
1355 : : {
1356 : 0 : error_at (UNKNOWN_LOCATION,
1357 : : "%<-fcf-protection=return%> is not supported for this "
1358 : : "target");
1359 : 0 : flag_cf_protection = CF_NONE;
1360 : : }
1361 : : }
1362 : :
1363 : : /* One region RA really helps to decrease the code size. */
1364 : 283049 : if (!OPTION_SET_P (flag_ira_region))
1365 : 283046 : flag_ira_region
1366 : 410634 : = optimize_size || !optimize ? IRA_REGION_ONE : IRA_REGION_MIXED;
1367 : :
1368 : 283049 : if (!abi_version_at_least (2))
1369 : : {
1370 : : /* -fabi-version=1 support was removed after GCC 4.9. */
1371 : 0 : error_at (UNKNOWN_LOCATION,
1372 : : "%<-fabi-version=1%> is no longer supported");
1373 : 0 : flag_abi_version = 2;
1374 : : }
1375 : :
1376 : 283049 : if (flag_non_call_exceptions)
1377 : 5499 : flag_asynchronous_unwind_tables = 1;
1378 : 283049 : if (flag_asynchronous_unwind_tables)
1379 : 283011 : flag_unwind_tables = 1;
1380 : :
1381 : 283049 : if (flag_value_profile_transformations)
1382 : 148 : flag_profile_values = 1;
1383 : :
1384 : : /* Warn about options that are not supported on this machine. */
1385 : : #ifndef INSN_SCHEDULING
1386 : : if (flag_schedule_insns || flag_schedule_insns_after_reload)
1387 : : warning_at (UNKNOWN_LOCATION, 0,
1388 : : "instruction scheduling not supported on this target machine");
1389 : : #endif
1390 : 283049 : if (!DELAY_SLOTS && flag_delayed_branch)
1391 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1392 : : "this target machine does not have delayed branches");
1393 : :
1394 : 283049 : user_label_prefix = USER_LABEL_PREFIX;
1395 : 283049 : if (flag_leading_underscore != -1)
1396 : : {
1397 : : /* If the default prefix is more complicated than "" or "_",
1398 : : issue a warning and ignore this option. */
1399 : 3 : if (user_label_prefix[0] == 0 ||
1400 : : (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
1401 : : {
1402 : 3 : user_label_prefix = flag_leading_underscore ? "_" : "";
1403 : : }
1404 : : else
1405 : : warning_at (UNKNOWN_LOCATION, 0,
1406 : : "%<-f%sleading-underscore%> not supported on this "
1407 : : "target machine", flag_leading_underscore ? "" : "no-");
1408 : : }
1409 : :
1410 : : /* If we are in verbose mode, write out the version and maybe all the
1411 : : option flags in use. */
1412 : 283049 : if (version_flag)
1413 : : {
1414 : : /* We already printed the version header in main (). */
1415 : 109 : if (!quiet_flag)
1416 : : {
1417 : 0 : fputs ("options passed: ", stderr);
1418 : 0 : char *cmdline = gen_command_line_string (save_decoded_options,
1419 : : save_decoded_options_count);
1420 : :
1421 : 0 : fputs (cmdline, stderr);
1422 : 0 : free (cmdline);
1423 : 0 : fputc ('\n', stderr);
1424 : : }
1425 : : }
1426 : :
1427 : : /* CTF is supported for only C at this time. */
1428 : 283049 : if (!lang_GNU_C ()
1429 : 283049 : && ctf_debug_info_level > CTFINFO_LEVEL_NONE)
1430 : : {
1431 : : /* Compiling with -flto results in frontend language of GNU GIMPLE. It
1432 : : is not useful to warn in that case. */
1433 : 36 : if (!startswith (lang_hooks.name, "GNU GIMPLE"))
1434 : 34 : inform (UNKNOWN_LOCATION,
1435 : : "CTF debug info requested, but not supported for %qs frontend",
1436 : : language_string);
1437 : 36 : ctf_debug_info_level = CTFINFO_LEVEL_NONE;
1438 : : }
1439 : :
1440 : 283049 : if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
1441 : : {
1442 : 1225 : FILE *final_output = fopen (flag_dump_final_insns, "w");
1443 : 1225 : if (!final_output)
1444 : : {
1445 : 0 : error_at (UNKNOWN_LOCATION,
1446 : : "could not open final insn dump file %qs: %m",
1447 : : flag_dump_final_insns);
1448 : 0 : flag_dump_final_insns = NULL;
1449 : : }
1450 : 1225 : else if (fclose (final_output))
1451 : : {
1452 : 0 : error_at (UNKNOWN_LOCATION,
1453 : : "could not close zeroed insn dump file %qs: %m",
1454 : : flag_dump_final_insns);
1455 : 0 : flag_dump_final_insns = NULL;
1456 : : }
1457 : : }
1458 : :
1459 : : /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1460 : : level is 0. */
1461 : 283049 : if (debug_info_level == DINFO_LEVEL_NONE
1462 : 283049 : && ctf_debug_info_level == CTFINFO_LEVEL_NONE)
1463 : 225090 : write_symbols = NO_DEBUG;
1464 : :
1465 : 283049 : if (write_symbols == NO_DEBUG)
1466 : : ;
1467 : : #ifdef DWARF2_DEBUGGING_INFO
1468 : 57959 : else if (dwarf_debuginfo_p ())
1469 : 57522 : debug_hooks = &dwarf2_debug_hooks;
1470 : : #endif
1471 : : #ifdef CTF_DEBUGGING_INFO
1472 : 437 : else if (ctf_debuginfo_p ())
1473 : 334 : debug_hooks = &dwarf2_debug_hooks;
1474 : : #endif
1475 : : #ifdef BTF_DEBUGGING_INFO
1476 : 103 : else if (btf_debuginfo_p ())
1477 : 103 : debug_hooks = &dwarf2_debug_hooks;
1478 : : #endif
1479 : : #ifdef VMS_DEBUGGING_INFO
1480 : : else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1481 : : debug_hooks = &vmsdbg_debug_hooks;
1482 : : #endif
1483 : : #ifdef DWARF2_LINENO_DEBUGGING_INFO
1484 : : else if (write_symbols == DWARF2_DEBUG)
1485 : : debug_hooks = &dwarf2_lineno_debug_hooks;
1486 : : #endif
1487 : : #ifdef CODEVIEW_DEBUGGING_INFO
1488 : : else if (codeview_debuginfo_p ())
1489 : : debug_hooks = &dwarf2_debug_hooks;
1490 : : #endif
1491 : : else
1492 : : {
1493 : 0 : gcc_assert (debug_set_count (write_symbols) <= 1);
1494 : 0 : error_at (UNKNOWN_LOCATION,
1495 : : "target system does not support the %qs debug format",
1496 : 0 : debug_type_names[debug_set_to_format (write_symbols)]);
1497 : : }
1498 : :
1499 : : /* The debug hooks are used to implement -fdump-go-spec because it
1500 : : gives a simple and stable API for all the information we need to
1501 : : dump. */
1502 : 283049 : if (flag_dump_go_spec != NULL)
1503 : 4 : debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks);
1504 : :
1505 : 283049 : if (!OPTION_SET_P (dwarf2out_as_loc_support))
1506 : 283043 : dwarf2out_as_loc_support = dwarf2out_default_as_loc_support ();
1507 : 283049 : if (!OPTION_SET_P (dwarf2out_as_locview_support))
1508 : 283049 : dwarf2out_as_locview_support = dwarf2out_default_as_locview_support ();
1509 : 283049 : if (dwarf2out_as_locview_support && !dwarf2out_as_loc_support)
1510 : : {
1511 : 6 : if (OPTION_SET_P (dwarf2out_as_locview_support))
1512 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1513 : : "%<-gas-locview-support%> is forced disabled "
1514 : : "without %<-gas-loc-support%>");
1515 : 6 : dwarf2out_as_locview_support = false;
1516 : : }
1517 : :
1518 : 283049 : if (!OPTION_SET_P (debug_variable_location_views))
1519 : : {
1520 : 283049 : debug_variable_location_views
1521 : 566098 : = (flag_var_tracking
1522 : 49117 : && debug_info_level >= DINFO_LEVEL_NORMAL
1523 : 49117 : && dwarf_debuginfo_p ()
1524 : 566099 : && !dwarf_strict);
1525 : : }
1526 : 0 : else if (debug_variable_location_views == -1 && dwarf_version != 5)
1527 : : {
1528 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1529 : : "without %<-gdwarf-5%>, "
1530 : : "%<-gvariable-location-views=incompat5%> "
1531 : : "is equivalent to %<-gvariable-location-views%>");
1532 : 0 : debug_variable_location_views = 1;
1533 : : }
1534 : :
1535 : 283049 : if (debug_internal_reset_location_views == 2)
1536 : : {
1537 : 283049 : debug_internal_reset_location_views
1538 : 566098 : = (debug_variable_location_views
1539 : 566098 : && targetm.reset_location_view);
1540 : : }
1541 : 0 : else if (debug_internal_reset_location_views
1542 : 0 : && !debug_variable_location_views)
1543 : : {
1544 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1545 : : "%<-ginternal-reset-location-views%> is forced disabled "
1546 : : "without %<-gvariable-location-views%>");
1547 : 0 : debug_internal_reset_location_views = 0;
1548 : : }
1549 : :
1550 : 283049 : if (!OPTION_SET_P (debug_inline_points))
1551 : 283049 : debug_inline_points = debug_variable_location_views;
1552 : 0 : else if (debug_inline_points && !debug_nonbind_markers_p)
1553 : : {
1554 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1555 : : "%<-ginline-points%> is forced disabled without "
1556 : : "%<-gstatement-frontiers%>");
1557 : 0 : debug_inline_points = 0;
1558 : : }
1559 : :
1560 : 283049 : if (!OPTION_SET_P (flag_tree_cselim))
1561 : : {
1562 : 283021 : if (HAVE_conditional_move)
1563 : 283021 : flag_tree_cselim = 1;
1564 : : else
1565 : : flag_tree_cselim = 0;
1566 : : }
1567 : :
1568 : : /* If auxiliary info generation is desired, open the output file.
1569 : : This goes in the same directory as the source file--unlike
1570 : : all the other output files. */
1571 : 283049 : if (flag_gen_aux_info)
1572 : : {
1573 : 0 : aux_info_file = fopen (aux_info_file_name, "w");
1574 : 0 : if (aux_info_file == 0)
1575 : 0 : fatal_error (UNKNOWN_LOCATION,
1576 : : "cannot open %s: %m", aux_info_file_name);
1577 : : }
1578 : :
1579 : 283049 : if (!targetm_common.have_named_sections)
1580 : : {
1581 : 0 : if (flag_function_sections)
1582 : : {
1583 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1584 : : "%<-ffunction-sections%> not supported for this target");
1585 : 0 : flag_function_sections = 0;
1586 : : }
1587 : 0 : if (flag_data_sections)
1588 : : {
1589 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1590 : : "%<-fdata-sections%> not supported for this target");
1591 : 0 : flag_data_sections = 0;
1592 : : }
1593 : : }
1594 : :
1595 : 283049 : if (flag_prefetch_loop_arrays > 0 && !targetm.code_for_prefetch)
1596 : : {
1597 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1598 : : "%<-fprefetch-loop-arrays%> not supported for this target");
1599 : 0 : flag_prefetch_loop_arrays = 0;
1600 : : }
1601 : 283049 : else if (flag_prefetch_loop_arrays > 0 && !targetm.have_prefetch ())
1602 : : {
1603 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1604 : : "%<-fprefetch-loop-arrays%> not supported for this target "
1605 : : "(try %<-march%> switches)");
1606 : 0 : flag_prefetch_loop_arrays = 0;
1607 : : }
1608 : :
1609 : : /* This combination of options isn't handled for i386 targets and doesn't
1610 : : make much sense anyway, so don't allow it. */
1611 : 283049 : if (flag_prefetch_loop_arrays > 0 && optimize_size)
1612 : : {
1613 : 2 : warning_at (UNKNOWN_LOCATION, 0,
1614 : : "%<-fprefetch-loop-arrays%> is not supported with %<-Os%>");
1615 : 2 : flag_prefetch_loop_arrays = 0;
1616 : : }
1617 : :
1618 : : /* The presence of IEEE signaling NaNs, implies all math can trap. */
1619 : 283049 : if (flag_signaling_nans)
1620 : 583 : flag_trapping_math = 1;
1621 : :
1622 : : /* We cannot reassociate if we want traps or signed zeros. */
1623 : 283049 : if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
1624 : : {
1625 : 18 : warning_at (UNKNOWN_LOCATION, 0,
1626 : : "%<-fassociative-math%> disabled; other options take "
1627 : : "precedence");
1628 : 18 : flag_associative_math = 0;
1629 : : }
1630 : :
1631 : 283049 : if (flag_hardened && !HAVE_FHARDENED_SUPPORT)
1632 : : {
1633 : : warning_at (UNKNOWN_LOCATION, 0,
1634 : : "%<-fhardened%> not supported for this target");
1635 : : flag_hardened = 0;
1636 : : }
1637 : :
1638 : : /* -fstack-clash-protection is not currently supported on targets
1639 : : where the stack grows up. */
1640 : 283049 : if (flag_stack_clash_protection && !STACK_GROWS_DOWNWARD)
1641 : : {
1642 : : warning_at (UNKNOWN_LOCATION, 0,
1643 : : "%<-fstack-clash-protection%> is not supported on targets "
1644 : : "where the stack grows from lower to higher addresses");
1645 : : flag_stack_clash_protection = 0;
1646 : : }
1647 : 283049 : else if (flag_hardened)
1648 : : {
1649 : 91 : if (!flag_stack_clash_protection
1650 : : /* Don't enable -fstack-clash-protection when -fstack-check=
1651 : : is used: it would result in confusing errors. */
1652 : 91 : && flag_stack_check == NO_STACK_CHECK)
1653 : 87 : flag_stack_clash_protection = 1;
1654 : 4 : else if (flag_stack_check != NO_STACK_CHECK)
1655 : 4 : warning_at (UNKNOWN_LOCATION, OPT_Whardened,
1656 : : "%<-fstack-clash-protection%> is not enabled by "
1657 : : "%<-fhardened%> because %<-fstack-check%> was "
1658 : : "specified on the command line");
1659 : : }
1660 : :
1661 : : /* We cannot support -fstack-check= and -fstack-clash-protection at
1662 : : the same time. */
1663 : 283049 : if (flag_stack_check != NO_STACK_CHECK && flag_stack_clash_protection)
1664 : : {
1665 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1666 : : "%<-fstack-check=%> and %<-fstack-clash-protection%> are "
1667 : : "mutually exclusive; disabling %<-fstack-check=%>");
1668 : 0 : flag_stack_check = NO_STACK_CHECK;
1669 : : }
1670 : :
1671 : : /* Targets must be able to place spill slots at lower addresses. If the
1672 : : target already uses a soft frame pointer, the transition is trivial. */
1673 : 283049 : if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
1674 : : {
1675 : : if (!flag_stack_protector_set_by_fhardened_p)
1676 : : warning_at (UNKNOWN_LOCATION, 0,
1677 : : "%<-fstack-protector%> not supported for this target");
1678 : : flag_stack_protect = 0;
1679 : : }
1680 : 283049 : if (!flag_stack_protect)
1681 : 282780 : warn_stack_protect = 0;
1682 : :
1683 : : /* Address Sanitizer needs porting to each target architecture. */
1684 : :
1685 : 283049 : if ((flag_sanitize & SANITIZE_ADDRESS)
1686 : : && !FRAME_GROWS_DOWNWARD)
1687 : : {
1688 : : warning_at (UNKNOWN_LOCATION, 0,
1689 : : "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1690 : : "are not supported for this target");
1691 : : flag_sanitize &= ~SANITIZE_ADDRESS;
1692 : : }
1693 : :
1694 : 283049 : if ((flag_sanitize & SANITIZE_USER_ADDRESS)
1695 : 283049 : && ((targetm.asan_shadow_offset == NULL)
1696 : 2836 : || ((targetm.asan_shadow_offset () == 0)
1697 : 0 : && !targetm.asan_dynamic_shadow_offset_p ())))
1698 : : {
1699 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1700 : : "%<-fsanitize=address%> not supported for this target");
1701 : 0 : flag_sanitize &= ~SANITIZE_ADDRESS;
1702 : : }
1703 : :
1704 : 283049 : if ((flag_sanitize & SANITIZE_KERNEL_ADDRESS)
1705 : 283049 : && (targetm.asan_shadow_offset == NULL
1706 : 0 : && !asan_shadow_offset_set_p ()))
1707 : : {
1708 : 0 : warning_at (UNKNOWN_LOCATION, 0,
1709 : : "%<-fsanitize=kernel-address%> with stack protection "
1710 : : "is not supported without %<-fasan-shadow-offset=%> "
1711 : : "for this target");
1712 : 0 : flag_sanitize &= ~SANITIZE_ADDRESS;
1713 : : }
1714 : :
1715 : : /* HWAsan requires top byte ignore feature in the backend. */
1716 : 283049 : if (flag_sanitize & SANITIZE_HWADDRESS
1717 : 283049 : && ! targetm.memtag.can_tag_addresses ())
1718 : : {
1719 : 0 : warning_at (UNKNOWN_LOCATION, 0, "%qs is not supported for this target",
1720 : : "-fsanitize=hwaddress");
1721 : 0 : flag_sanitize &= ~SANITIZE_HWADDRESS;
1722 : : }
1723 : :
1724 : 283049 : if (flag_sanitize & SANITIZE_SHADOW_CALL_STACK)
1725 : : {
1726 : 0 : if (!targetm.have_shadow_call_stack)
1727 : 0 : sorry ("%<-fsanitize=shadow-call-stack%> not supported "
1728 : : "in current platform");
1729 : 0 : else if (flag_exceptions)
1730 : 0 : error_at (UNKNOWN_LOCATION, "%<-fsanitize=shadow-call-stack%> "
1731 : : "requires %<-fno-exceptions%>");
1732 : : }
1733 : :
1734 : 283049 : HOST_WIDE_INT patch_area_size, patch_area_start;
1735 : 283049 : parse_and_check_patch_area (flag_patchable_function_entry, false,
1736 : : &patch_area_size, &patch_area_start);
1737 : :
1738 : : /* Do not use IPA optimizations for register allocation if profiler is active
1739 : : or patchable function entries are inserted for run-time instrumentation
1740 : : or port does not emit prologue and epilogue as RTL. */
1741 : 282726 : if (profile_flag || patch_area_size
1742 : 565742 : || !targetm.have_prologue () || !targetm.have_epilogue ())
1743 : 356 : flag_ipa_ra = 0;
1744 : :
1745 : : /* Enable -Werror=coverage-mismatch when -Werror and -Wno-error
1746 : : have not been set. */
1747 : 283049 : if (!OPTION_SET_P (warnings_are_errors))
1748 : : {
1749 : 278715 : if (warn_coverage_mismatch
1750 : 278715 : && option_unspecified_p (OPT_Wcoverage_mismatch))
1751 : 278709 : diagnostic_classify_diagnostic (global_dc, OPT_Wcoverage_mismatch,
1752 : : DK_ERROR, UNKNOWN_LOCATION);
1753 : 278715 : if (warn_coverage_invalid_linenum
1754 : 278715 : && option_unspecified_p (OPT_Wcoverage_invalid_line_number))
1755 : 278714 : diagnostic_classify_diagnostic (global_dc, OPT_Wcoverage_invalid_line_number,
1756 : : DK_ERROR, UNKNOWN_LOCATION);
1757 : : }
1758 : :
1759 : : /* Save the current optimization options. */
1760 : 283049 : optimization_default_node
1761 : 283049 : = build_optimization_node (&global_options, &global_options_set);
1762 : 283049 : optimization_current_node = optimization_default_node;
1763 : :
1764 : 283049 : if (flag_checking >= 2)
1765 : 282985 : hash_table_sanitize_eq_limit
1766 : 282985 : = param_hash_table_verification_limit;
1767 : :
1768 : 283049 : diagnose_options (&global_options, &global_options_set, UNKNOWN_LOCATION);
1769 : :
1770 : : /* Please don't change global_options after this point, those changes won't
1771 : : be reflected in optimization_{default,current}_node. */
1772 : 283049 : }
1773 : :
1774 : : /* This function can be called multiple times to reinitialize the compiler
1775 : : back end when register classes or instruction sets have changed,
1776 : : before each function. */
1777 : : static void
1778 : 210346 : backend_init_target (void)
1779 : : {
1780 : : /* This depends on stack_pointer_rtx. */
1781 : 210346 : init_fake_stack_mems ();
1782 : :
1783 : : /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
1784 : : mode-dependent. */
1785 : 210346 : init_alias_target ();
1786 : :
1787 : : /* Depends on HARD_FRAME_POINTER_REGNUM. */
1788 : 210346 : if (!ira_use_lra_p)
1789 : 0 : init_reload ();
1790 : :
1791 : : /* Depends on the enabled attribute. */
1792 : 210346 : recog_init ();
1793 : :
1794 : : /* The following initialization functions need to generate rtl, so
1795 : : provide a dummy function context for them. */
1796 : 210346 : init_dummy_function_start ();
1797 : :
1798 : : /* rtx_cost is mode-dependent, so cached values need to be recomputed
1799 : : on a mode change. */
1800 : 210346 : init_expmed ();
1801 : 210346 : init_lower_subreg ();
1802 : 210346 : init_set_costs ();
1803 : :
1804 : 210346 : init_expr_target ();
1805 : 210346 : ira_init ();
1806 : :
1807 : : /* We may need to recompute regno_save_code[] and regno_restore_code[]
1808 : : after a mode change as well. */
1809 : 210346 : caller_save_initialized_p = false;
1810 : :
1811 : 210346 : expand_dummy_function_end ();
1812 : 210346 : }
1813 : :
1814 : : /* Initialize the compiler back end. This function is called only once,
1815 : : when starting the compiler. */
1816 : : static void
1817 : 276803 : backend_init (void)
1818 : : {
1819 : 276803 : init_emit_once ();
1820 : :
1821 : 276803 : init_rtlanal ();
1822 : 276803 : init_inline_once ();
1823 : 276803 : init_varasm_once ();
1824 : 276803 : save_register_info ();
1825 : :
1826 : : /* Middle end needs this initialization for default mem attributes
1827 : : used by early calls to make_decl_rtl. */
1828 : 276803 : init_emit_regs ();
1829 : :
1830 : : /* Middle end needs this initialization for mode tables used to assign
1831 : : modes to vector variables. */
1832 : 276803 : init_regs ();
1833 : 276803 : }
1834 : :
1835 : : /* Initialize things that are both lang-dependent and target-dependent.
1836 : : This function can be called more than once if target parameters change. */
1837 : : static void
1838 : 831558 : lang_dependent_init_target (void)
1839 : : {
1840 : : /* This creates various _DECL nodes, so needs to be called after the
1841 : : front end is initialized. It also depends on the HAVE_xxx macros
1842 : : generated from the target machine description. */
1843 : 831558 : init_optabs ();
1844 : :
1845 : 831558 : gcc_assert (!this_target_rtl->target_specific_initialized);
1846 : 831558 : }
1847 : :
1848 : : /* Perform initializations that are lang-dependent or target-dependent.
1849 : : but matters only for late optimizations and RTL generation. */
1850 : :
1851 : : static int rtl_initialized;
1852 : :
1853 : : void
1854 : 1442187 : initialize_rtl (void)
1855 : : {
1856 : 1442187 : auto_timevar tv (g_timer, TV_INITIALIZE_RTL);
1857 : :
1858 : : /* Initialization done just once per compilation, but delayed
1859 : : till code generation. */
1860 : 1442187 : if (!rtl_initialized)
1861 : 206001 : ira_init_once ();
1862 : 1442187 : rtl_initialized = true;
1863 : :
1864 : : /* Target specific RTL backend initialization. */
1865 : 1442187 : if (!this_target_rtl->target_specific_initialized)
1866 : : {
1867 : 210346 : backend_init_target ();
1868 : 210346 : this_target_rtl->target_specific_initialized = true;
1869 : : }
1870 : 1442187 : }
1871 : :
1872 : : /* Language-dependent initialization. Returns nonzero on success. */
1873 : : static int
1874 : 282857 : lang_dependent_init (const char *name)
1875 : : {
1876 : 282857 : location_t save_loc = input_location;
1877 : 282857 : if (!dump_base_name)
1878 : : {
1879 : 2685 : dump_base_name = name && name[0] ? name : "gccdump";
1880 : :
1881 : : /* We do not want to derive a non-empty dumpbase-ext from an
1882 : : explicit -dumpbase argument, only from a defaulted
1883 : : dumpbase. */
1884 : 2685 : if (!dump_base_ext)
1885 : : {
1886 : 2685 : const char *base = lbasename (dump_base_name);
1887 : 2685 : const char *ext = strrchr (base, '.');
1888 : 2685 : if (ext)
1889 : 2685 : dump_base_ext = ext;
1890 : : }
1891 : : }
1892 : :
1893 : : /* Other front-end initialization. */
1894 : 282857 : input_location = BUILTINS_LOCATION;
1895 : 282857 : if (lang_hooks.init () == 0)
1896 : : return 0;
1897 : 276800 : input_location = save_loc;
1898 : :
1899 : 276800 : if (!flag_wpa)
1900 : : {
1901 : 268214 : init_asm_output (name);
1902 : :
1903 : 268214 : if (!flag_generate_lto && !flag_compare_debug)
1904 : : {
1905 : : /* If stack usage information is desired, open the output file. */
1906 : 243598 : if (flag_stack_usage)
1907 : 311 : stack_usage_file = open_auxiliary_file ("su");
1908 : :
1909 : : /* If call graph information is desired, open the output file. */
1910 : 243598 : if (flag_callgraph_info)
1911 : : {
1912 : 1 : callgraph_info_file = open_auxiliary_file ("ci");
1913 : : /* Write the file header. */
1914 : 1 : fprintf (callgraph_info_file,
1915 : : "graph: { title: \"%s\"\n", main_input_filename);
1916 : 1 : bitmap_obstack_initialize (NULL);
1917 : 1 : callgraph_info_external_printed = BITMAP_ALLOC (NULL);
1918 : : }
1919 : : }
1920 : : else
1921 : 24616 : flag_stack_usage = flag_callgraph_info = false;
1922 : : }
1923 : :
1924 : : /* This creates various _DECL nodes, so needs to be called after the
1925 : : front end is initialized. */
1926 : 276800 : init_eh ();
1927 : :
1928 : : /* Do the target-specific parts of the initialization. */
1929 : 276800 : lang_dependent_init_target ();
1930 : :
1931 : 276800 : if (!flag_wpa)
1932 : : {
1933 : : /* If dbx symbol table desired, initialize writing it and output the
1934 : : predefined types. */
1935 : 268214 : timevar_push (TV_SYMOUT);
1936 : :
1937 : : /* Now we have the correct original filename, we can initialize
1938 : : debug output. */
1939 : 268214 : (*debug_hooks->init) (name);
1940 : :
1941 : 268214 : timevar_pop (TV_SYMOUT);
1942 : : }
1943 : :
1944 : : return 1;
1945 : : }
1946 : :
1947 : :
1948 : : /* Reinitialize everything when target parameters, such as register usage,
1949 : : have changed. */
1950 : : void
1951 : 557245 : target_reinit (void)
1952 : : {
1953 : 557245 : if (no_backend)
1954 : 2487 : return;
1955 : :
1956 : 554758 : struct rtl_data saved_x_rtl;
1957 : 554758 : rtx *saved_regno_reg_rtx;
1958 : 554758 : tree saved_optimization_current_node;
1959 : 554758 : struct target_optabs *saved_this_fn_optabs;
1960 : :
1961 : : /* Temporarily switch to the default optimization node, so that
1962 : : *this_target_optabs is set to the default, not reflecting
1963 : : whatever a previous function used for the optimize
1964 : : attribute. */
1965 : 554758 : saved_optimization_current_node = optimization_current_node;
1966 : 554758 : saved_this_fn_optabs = this_fn_optabs;
1967 : 554758 : if (saved_optimization_current_node != optimization_default_node)
1968 : : {
1969 : 0 : optimization_current_node = optimization_default_node;
1970 : 0 : cl_optimization_restore
1971 : 0 : (&global_options, &global_options_set,
1972 : 0 : TREE_OPTIMIZATION (optimization_default_node));
1973 : : }
1974 : 554758 : this_fn_optabs = this_target_optabs;
1975 : :
1976 : : /* Save *crtl and regno_reg_rtx around the reinitialization
1977 : : to allow target_reinit being called even after prepare_function_start. */
1978 : 554758 : saved_regno_reg_rtx = regno_reg_rtx;
1979 : 554758 : if (saved_regno_reg_rtx)
1980 : : {
1981 : 5 : saved_x_rtl = *crtl;
1982 : 5 : memset (crtl, '\0', sizeof (*crtl));
1983 : 5 : regno_reg_rtx = NULL;
1984 : : }
1985 : :
1986 : 554758 : this_target_rtl->target_specific_initialized = false;
1987 : :
1988 : : /* This initializes hard_frame_pointer, and calls init_reg_modes_target()
1989 : : to initialize reg_raw_mode[]. */
1990 : 554758 : init_emit_regs ();
1991 : :
1992 : : /* This invokes target hooks to set fixed_reg[] etc, which is
1993 : : mode-dependent. */
1994 : 554758 : init_regs ();
1995 : :
1996 : : /* Reinitialize lang-dependent parts. */
1997 : 554758 : lang_dependent_init_target ();
1998 : :
1999 : : /* Restore the original optimization node. */
2000 : 554758 : if (saved_optimization_current_node != optimization_default_node)
2001 : : {
2002 : 0 : optimization_current_node = saved_optimization_current_node;
2003 : 0 : cl_optimization_restore (&global_options, &global_options_set,
2004 : 0 : TREE_OPTIMIZATION (optimization_current_node));
2005 : : }
2006 : 554758 : this_fn_optabs = saved_this_fn_optabs;
2007 : :
2008 : : /* Restore regno_reg_rtx at the end, as free_after_compilation from
2009 : : expand_dummy_function_end clears it. */
2010 : 554758 : if (saved_regno_reg_rtx)
2011 : : {
2012 : 5 : *crtl = saved_x_rtl;
2013 : 5 : regno_reg_rtx = saved_regno_reg_rtx;
2014 : 5 : saved_regno_reg_rtx = NULL;
2015 : : }
2016 : : }
2017 : :
2018 : : void
2019 : 0 : dump_memory_report (const char *header)
2020 : : {
2021 : : /* Print significant header. */
2022 : 0 : fputc ('\n', stderr);
2023 : 0 : for (unsigned i = 0; i < 80; i++)
2024 : 0 : fputc ('#', stderr);
2025 : 0 : fprintf (stderr, "\n# %-77s#\n", header);
2026 : 0 : for (unsigned i = 0; i < 80; i++)
2027 : 0 : fputc ('#', stderr);
2028 : 0 : fputs ("\n\n", stderr);
2029 : :
2030 : 0 : dump_line_table_statistics ();
2031 : 0 : ggc_print_statistics ();
2032 : 0 : stringpool_statistics ();
2033 : 0 : dump_tree_statistics ();
2034 : 0 : dump_gimple_statistics ();
2035 : 0 : dump_rtx_statistics ();
2036 : 0 : dump_alloc_pool_statistics ();
2037 : 0 : dump_bitmap_statistics ();
2038 : 0 : dump_hash_table_loc_statistics ();
2039 : 0 : dump_vec_loc_statistics ();
2040 : 0 : dump_ggc_loc_statistics ();
2041 : 0 : dump_alias_stats (stderr);
2042 : 0 : dump_pta_stats (stderr);
2043 : 0 : }
2044 : :
2045 : : /* Clean up: close opened files, etc. */
2046 : :
2047 : : static void
2048 : 280917 : finalize ()
2049 : : {
2050 : : /* Close the dump files. */
2051 : 280917 : if (flag_gen_aux_info)
2052 : : {
2053 : 0 : fclose (aux_info_file);
2054 : 0 : aux_info_file = NULL;
2055 : 0 : if (seen_error ())
2056 : 0 : unlink (aux_info_file_name);
2057 : : }
2058 : :
2059 : : /* Close non-debugging input and output files. Take special care to note
2060 : : whether fclose returns an error, since the pages might still be on the
2061 : : buffer chain while the file is open. */
2062 : :
2063 : 280917 : if (asm_out_file)
2064 : : {
2065 : 266451 : if (ferror (asm_out_file) != 0)
2066 : 0 : fatal_error (input_location, "error writing to %s: %m", asm_file_name);
2067 : 266451 : if (fclose (asm_out_file) != 0)
2068 : 0 : fatal_error (input_location, "error closing %s: %m", asm_file_name);
2069 : 266451 : asm_out_file = NULL;
2070 : : }
2071 : :
2072 : 280917 : if (stack_usage_file)
2073 : : {
2074 : 311 : fclose (stack_usage_file);
2075 : 311 : stack_usage_file = NULL;
2076 : : }
2077 : :
2078 : 280917 : if (callgraph_info_file)
2079 : : {
2080 : 1 : fputs ("}\n", callgraph_info_file);
2081 : 1 : fclose (callgraph_info_file);
2082 : 1 : callgraph_info_file = NULL;
2083 : 1 : BITMAP_FREE (callgraph_info_external_printed);
2084 : 1 : bitmap_obstack_release (NULL);
2085 : : }
2086 : :
2087 : 280917 : if (seen_error ())
2088 : 26118 : coverage_remove_note_file ();
2089 : :
2090 : 280917 : if (!no_backend)
2091 : : {
2092 : 275037 : statistics_fini ();
2093 : 275037 : debuginfo_fini ();
2094 : :
2095 : 275037 : g->get_passes ()->finish_optimization_passes ();
2096 : :
2097 : 275037 : lra_finish_once ();
2098 : : }
2099 : :
2100 : 280917 : if (mem_report)
2101 : 0 : dump_memory_report ("Final");
2102 : :
2103 : 280917 : if (profile_report)
2104 : 0 : dump_profile_report ();
2105 : :
2106 : 280917 : if (flag_dbg_cnt_list)
2107 : 0 : dbg_cnt_list_all_counters ();
2108 : :
2109 : : /* Language-specific end of compilation actions. */
2110 : 280917 : lang_hooks.finish ();
2111 : 280917 : }
2112 : :
2113 : : static bool
2114 : 275808 : standard_type_bitsize (int bitsize)
2115 : : {
2116 : : /* As a special exception, we always want __int128 enabled if possible. */
2117 : 275808 : if (bitsize == 128)
2118 : : return false;
2119 : : if (bitsize == CHAR_TYPE_SIZE
2120 : : || bitsize == SHORT_TYPE_SIZE
2121 : : || bitsize == INT_TYPE_SIZE
2122 : 0 : || bitsize == LONG_TYPE_SIZE
2123 : 0 : || bitsize == LONG_LONG_TYPE_SIZE)
2124 : 0 : return true;
2125 : : return false;
2126 : : }
2127 : :
2128 : : /* Initialize the compiler, and compile the input file. */
2129 : : static void
2130 : 283049 : do_compile ()
2131 : : {
2132 : : /* Don't do any more if an error has already occurred. */
2133 : 283049 : if (!seen_error ())
2134 : : {
2135 : 282857 : int i;
2136 : :
2137 : 282857 : timevar_start (TV_PHASE_SETUP);
2138 : :
2139 : 282857 : if (flag_save_optimization_record)
2140 : : {
2141 : 41 : dump_context::get ().set_json_writer (new optrecord_json_writer ());
2142 : : }
2143 : :
2144 : : /* This must be run always, because it is needed to compute the FP
2145 : : predefined macros, such as __LDBL_MAX__, for targets using non
2146 : : default FP formats. */
2147 : 282857 : init_adjust_machine_modes ();
2148 : 282857 : init_derived_machine_modes ();
2149 : :
2150 : : /* This must happen after the backend has a chance to process
2151 : : command line options, but before the parsers are
2152 : : initialized. */
2153 : 848571 : for (i = 0; i < NUM_INT_N_ENTS; i ++)
2154 : 282857 : if (targetm.scalar_mode_supported_p (int_n_data[i].m)
2155 : 282857 : && ! standard_type_bitsize (int_n_data[i].bitsize))
2156 : 275808 : int_n_enabled_p[i] = true;
2157 : : else
2158 : 7049 : int_n_enabled_p[i] = false;
2159 : :
2160 : : /* Initialize mpfrs exponent range. This is important to get
2161 : : underflow/overflow in a reasonable timeframe. */
2162 : 282857 : machine_mode mode;
2163 : 282857 : int min_exp = -1;
2164 : 282857 : int max_exp = 1;
2165 : 1979999 : FOR_EACH_MODE_IN_CLASS (mode, MODE_FLOAT)
2166 : 1697142 : if (SCALAR_FLOAT_MODE_P (mode))
2167 : : {
2168 : 1697142 : const real_format *fmt = REAL_MODE_FORMAT (mode);
2169 : 1697142 : if (fmt)
2170 : : {
2171 : : /* fmt->emin - fmt->p + 1 should be enough but the
2172 : : back-and-forth dance in real_to_decimal_for_mode we
2173 : : do for checking fails due to rounding effects then. */
2174 : 1697142 : if ((fmt->emin - fmt->p) < min_exp)
2175 : : min_exp = fmt->emin - fmt->p;
2176 : 1697142 : if (fmt->emax > max_exp)
2177 : : max_exp = fmt->emax;
2178 : : }
2179 : : }
2180 : : /* E.g. mpc_norm assumes it can square a number without bothering with
2181 : : with range scaling, so until that is fixed, double the minimum
2182 : : and maximum exponents, plus add some buffer for arithmetics
2183 : : on the squared numbers. */
2184 : 282857 : if (mpfr_set_emin (2 * (min_exp - 1))
2185 : 282857 : || mpfr_set_emax (2 * (max_exp + 1)))
2186 : 0 : sorry ("mpfr not configured to handle all floating modes");
2187 : :
2188 : : /* Set up the back-end if requested. */
2189 : 282857 : if (!no_backend)
2190 : 276803 : backend_init ();
2191 : :
2192 : : /* Language-dependent initialization. Returns true on success. */
2193 : 282857 : if (lang_dependent_init (main_input_filename))
2194 : : {
2195 : : /* Initialize yet another pass. */
2196 : :
2197 : 276800 : ggc_protect_identifiers = true;
2198 : :
2199 : 276800 : symtab->initialize ();
2200 : 276800 : init_final (main_input_filename);
2201 : 276800 : coverage_init (aux_base_name);
2202 : 276800 : statistics_init ();
2203 : 276800 : debuginfo_init ();
2204 : 276800 : invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
2205 : :
2206 : 276800 : timevar_stop (TV_PHASE_SETUP);
2207 : :
2208 : 276800 : compile_file ();
2209 : : }
2210 : : else
2211 : : {
2212 : 5880 : timevar_stop (TV_PHASE_SETUP);
2213 : : }
2214 : :
2215 : 280917 : timevar_start (TV_PHASE_FINALIZE);
2216 : :
2217 : 280917 : finalize ();
2218 : :
2219 : 280917 : timevar_stop (TV_PHASE_FINALIZE);
2220 : : }
2221 : 281109 : }
2222 : :
2223 : 283157 : toplev::toplev (timer *external_timer,
2224 : 283157 : bool init_signals)
2225 : 283157 : : m_use_TV_TOTAL (external_timer == NULL),
2226 : 283157 : m_init_signals (init_signals)
2227 : : {
2228 : 283157 : if (external_timer)
2229 : 400 : g_timer = external_timer;
2230 : 283157 : }
2231 : :
2232 : 281212 : toplev::~toplev ()
2233 : : {
2234 : 281212 : if (g_timer && m_use_TV_TOTAL)
2235 : : {
2236 : 12 : g_timer->stop (TV_TOTAL);
2237 : 12 : g_timer->print (stderr);
2238 : 12 : delete g_timer;
2239 : 12 : g_timer = NULL;
2240 : : }
2241 : 281212 : }
2242 : :
2243 : : /* Potentially call timevar_init (which will create g_timevars if it
2244 : : doesn't already exist). */
2245 : :
2246 : : void
2247 : 282649 : toplev::start_timevars ()
2248 : : {
2249 : 282649 : if (time_report || !quiet_flag || flag_detailed_statistics)
2250 : 20 : timevar_init ();
2251 : :
2252 : 282649 : timevar_start (TV_TOTAL);
2253 : 282649 : }
2254 : :
2255 : : /* Handle -fself-test. */
2256 : :
2257 : : void
2258 : 4 : toplev::run_self_tests ()
2259 : : {
2260 : : #if CHECKING_P
2261 : : /* Reset some state. */
2262 : 4 : input_location = UNKNOWN_LOCATION;
2263 : 4 : bitmap_obstack_initialize (NULL);
2264 : :
2265 : : /* Run the tests; any failures will lead to an abort of the process.
2266 : : Use "make selftests-gdb" to run under the debugger. */
2267 : 4 : ::selftest::run_tests ();
2268 : :
2269 : : /* Cleanup. */
2270 : 4 : bitmap_obstack_release (NULL);
2271 : : #else
2272 : : inform (UNKNOWN_LOCATION, "self-tests are not enabled in this build");
2273 : : #endif /* #if CHECKING_P */
2274 : 4 : }
2275 : :
2276 : : /* Entry point of cc1, cc1plus, jc1, f771, etc.
2277 : : Exit code is FATAL_EXIT_CODE if can't open files or if there were
2278 : : any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
2279 : :
2280 : : It is not safe to call this function more than once. */
2281 : :
2282 : : int
2283 : 283157 : toplev::main (int argc, char **argv)
2284 : : {
2285 : : /* Parsing and gimplification sometimes need quite large stack.
2286 : : Increase stack size limits if possible. */
2287 : 283157 : stack_limit_increase (64 * 1024 * 1024);
2288 : :
2289 : : /* Stash a copy of the original argv before expansion
2290 : : for use by SARIF output. */
2291 : 283157 : unique_argv original_argv (dupargv (argv));
2292 : :
2293 : 283157 : expandargv (&argc, &argv);
2294 : :
2295 : : /* Initialization of GCC's environment, and diagnostics. */
2296 : 283157 : general_init (argv[0], m_init_signals, std::move (original_argv));
2297 : :
2298 : : /* One-off initialization of options that does not need to be
2299 : : repeated when options are added for particular functions. */
2300 : 283157 : init_options_once ();
2301 : 283157 : init_opts_obstack ();
2302 : :
2303 : : /* Initialize global options structures; this must be repeated for
2304 : : each structure used for parsing options. */
2305 : 283157 : init_options_struct (&global_options, &global_options_set);
2306 : 283157 : lang_hooks.init_options_struct (&global_options);
2307 : :
2308 : : /* Init GGC heuristics must be caller after we initialize
2309 : : options. */
2310 : 283157 : init_ggc_heuristics ();
2311 : :
2312 : : /* Convert the options to an array. */
2313 : 283157 : decode_cmdline_options_to_array_default_mask (argc,
2314 : : CONST_CAST2 (const char **,
2315 : : char **, argv),
2316 : : &save_decoded_options,
2317 : : &save_decoded_options_count);
2318 : :
2319 : : /* Save Optimization decoded options. */
2320 : 283157 : save_opt_decoded_options = new vec<cl_decoded_option> ();
2321 : 7934567 : for (unsigned i = 1; i < save_decoded_options_count; ++i)
2322 : 7651410 : if (save_decoded_options[i].opt_index < cl_options_count
2323 : 7357418 : && cl_options[save_decoded_options[i].opt_index].flags & CL_OPTIMIZATION)
2324 : 310695 : save_opt_decoded_options->safe_push (save_decoded_options[i]);
2325 : :
2326 : : /* Perform language-specific options initialization. */
2327 : 283157 : lang_hooks.init_options (save_decoded_options_count, save_decoded_options);
2328 : :
2329 : : /* Parse the options and do minimal processing; basically just
2330 : : enough to default flags appropriately. */
2331 : 283157 : decode_options (&global_options, &global_options_set,
2332 : : save_decoded_options, save_decoded_options_count,
2333 : : UNKNOWN_LOCATION, global_dc,
2334 : : targetm.target_option.override);
2335 : :
2336 : 283157 : global_dc->get_file_cache ().tune (param_file_cache_files,
2337 : 283157 : param_file_cache_lines);
2338 : :
2339 : 283157 : handle_common_deferred_options ();
2340 : :
2341 : 283153 : init_local_tick ();
2342 : :
2343 : 283153 : initialize_plugins ();
2344 : :
2345 : : /* Handle the dump options now that plugins have had a chance to install new
2346 : : passes. */
2347 : 283153 : handle_deferred_dump_options ();
2348 : :
2349 : 283153 : if (version_flag)
2350 : 112 : print_version (stderr, "", true);
2351 : :
2352 : 283153 : if (help_flag)
2353 : 3 : print_plugins_help (stderr, "");
2354 : :
2355 : : /* Exit early if we can (e.g. -help). */
2356 : 283153 : if (!exit_after_options)
2357 : : {
2358 : : /* Just in case lang_hooks.post_options ends up calling a debug_hook.
2359 : : This can happen with incorrect pre-processed input. */
2360 : 283050 : debug_hooks = &do_nothing_debug_hooks;
2361 : : /* Allow the front end to perform consistency checks and do further
2362 : : initialization based on the command line options. This hook also
2363 : : sets the original filename if appropriate (e.g. foo.i -> foo.c)
2364 : : so we can correctly initialize debug output. */
2365 : 283050 : no_backend = lang_hooks.post_options (&main_input_filename);
2366 : :
2367 : 283049 : process_options ();
2368 : :
2369 : 283049 : if (m_use_TV_TOTAL)
2370 : 282649 : start_timevars ();
2371 : 283049 : do_compile ();
2372 : :
2373 : 281109 : if (flag_self_test && !seen_error ())
2374 : : {
2375 : 5 : if (no_backend)
2376 : 1 : error_at (UNKNOWN_LOCATION, "self-tests incompatible with %<-E%>");
2377 : : else
2378 : 4 : run_self_tests ();
2379 : : }
2380 : : }
2381 : :
2382 : 281212 : if (warningcount || errorcount || werrorcount)
2383 : 38776 : print_ignored_options ();
2384 : :
2385 : : /* Invoke registered plugin callbacks if any. Some plugins could
2386 : : emit some diagnostics here. */
2387 : 281212 : invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
2388 : :
2389 : 281212 : if (auto edit_context_ptr = global_dc->get_edit_context ())
2390 : : {
2391 : 17 : pretty_printer pp;
2392 : 17 : pp_show_color (&pp) = pp_show_color (global_dc->get_reference_printer ());
2393 : 17 : edit_context_ptr->print_diff (&pp, true);
2394 : 17 : pp_flush (&pp);
2395 : 17 : }
2396 : :
2397 : 281212 : diagnostic_finish (global_dc);
2398 : :
2399 : 281212 : finalize_plugins ();
2400 : :
2401 : 281212 : after_memory_report = true;
2402 : :
2403 : 281212 : if (global_dc->execution_failed_p ())
2404 : 26583 : return (FATAL_EXIT_CODE);
2405 : :
2406 : : return (SUCCESS_EXIT_CODE);
2407 : 281212 : }
2408 : :
2409 : : /* For those that want to, this function aims to clean up enough state that
2410 : : you can call toplev::main again. */
2411 : : void
2412 : 254814 : toplev::finalize (void)
2413 : : {
2414 : 254814 : no_backend = false;
2415 : 254814 : rtl_initialized = false;
2416 : 254814 : this_target_rtl->target_specific_initialized = false;
2417 : :
2418 : : /* Needs to be called before cgraph_cc_finalize since it uses symtab. */
2419 : 254814 : ipa_reference_cc_finalize ();
2420 : 254814 : ipa_fnsummary_cc_finalize ();
2421 : 254814 : ipa_modref_cc_finalize ();
2422 : 254814 : ipa_edge_modifications_finalize ();
2423 : 254814 : ipa_icf_cc_finalize ();
2424 : :
2425 : 254814 : ipa_prop_cc_finalize ();
2426 : 254814 : ipa_profile_cc_finalize ();
2427 : 254814 : ipa_sra_cc_finalize ();
2428 : 254814 : cgraph_cc_finalize ();
2429 : 254814 : cgraphunit_cc_finalize ();
2430 : 254814 : symtab_thunks_cc_finalize ();
2431 : 254814 : dwarf2cfi_cc_finalize ();
2432 : 254814 : dwarf2out_cc_finalize ();
2433 : 254814 : gcse_cc_finalize ();
2434 : 254814 : ipa_cp_cc_finalize ();
2435 : 254814 : ira_costs_cc_finalize ();
2436 : 254814 : tree_cc_finalize ();
2437 : 254814 : reginfo_cc_finalize ();
2438 : 254814 : varasm_cc_finalize ();
2439 : :
2440 : : /* save_decoded_options uses opts_obstack, so these must
2441 : : be cleaned up together. */
2442 : 254814 : obstack_free (&opts_obstack, NULL);
2443 : 254814 : XDELETEVEC (save_decoded_options);
2444 : 254814 : save_decoded_options = NULL;
2445 : 254814 : save_decoded_options_count = 0;
2446 : :
2447 : 254814 : ggc_common_finalize ();
2448 : :
2449 : : /* Clean up the context (and pass_manager etc). */
2450 : 254814 : delete g;
2451 : 254814 : g = NULL;
2452 : :
2453 : 254814 : }
|
